tcp.c 72 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461
  1. /*
  2. * This file is part of the UCB release of Plan 9. It is subject to the license
  3. * terms in the LICENSE file found in the top-level directory of this
  4. * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
  5. * part of the UCB release of Plan 9, including this file, may be copied,
  6. * modified, propagated, or distributed except according to the terms contained
  7. * in the LICENSE file.
  8. */
  9. #include "u.h"
  10. #include "../port/lib.h"
  11. #include "mem.h"
  12. #include "dat.h"
  13. #include "fns.h"
  14. #include "../port/error.h"
  15. #include "ip.h"
  16. enum
  17. {
  18. QMAX = 64*1024-1,
  19. IP_TCPPROTO = 6,
  20. TCP4_IPLEN = 8,
  21. TCP4_PHDRSIZE = 12,
  22. TCP4_HDRSIZE = 20,
  23. TCP4_TCBPHDRSZ = 40,
  24. TCP4_PKT = TCP4_IPLEN+TCP4_PHDRSIZE,
  25. TCP6_IPLEN = 0,
  26. TCP6_PHDRSIZE = 40,
  27. TCP6_HDRSIZE = 20,
  28. TCP6_TCBPHDRSZ = 60,
  29. TCP6_PKT = TCP6_IPLEN+TCP6_PHDRSIZE,
  30. TcptimerOFF = 0,
  31. TcptimerON = 1,
  32. TcptimerDONE = 2,
  33. MAX_TIME = (1<<20), /* Forever */
  34. TCP_ACK = 50, /* Timed ack sequence in ms */
  35. MAXBACKMS = 9*60*1000, /* longest backoff time (ms) before hangup */
  36. URG = 0x20, /* Data marked urgent */
  37. ACK = 0x10, /* Acknowledge is valid */
  38. PSH = 0x08, /* Whole data pipe is pushed */
  39. RST = 0x04, /* Reset connection */
  40. SYN = 0x02, /* Pkt. is synchronise */
  41. FIN = 0x01, /* Start close down */
  42. EOLOPT = 0,
  43. NOOPOPT = 1,
  44. MSSOPT = 2,
  45. MSS_LENGTH = 4, /* Maximum segment size */
  46. WSOPT = 3,
  47. WS_LENGTH = 3, /* Bits to scale window size by */
  48. MSL2 = 10,
  49. MSPTICK = 50, /* Milliseconds per timer tick */
  50. DEF_MSS = 1460, /* Default maximum segment */
  51. DEF_MSS6 = 1280, /* Default maximum segment (min) for v6 */
  52. DEF_RTT = 500, /* Default round trip */
  53. DEF_KAT = 120000, /* Default time (ms) between keep alives */
  54. TCP_LISTEN = 0, /* Listen connection */
  55. TCP_CONNECT = 1, /* Outgoing connection */
  56. SYNACK_RXTIMER = 250, /* ms between SYNACK retransmits */
  57. TCPREXMTTHRESH = 3, /* dupack threshhold for rxt */
  58. FORCE = 1,
  59. CLONE = 2,
  60. RETRAN = 4,
  61. ACTIVE = 8,
  62. SYNACK = 16,
  63. LOGAGAIN = 3,
  64. LOGDGAIN = 2,
  65. Closed = 0, /* Connection states */
  66. Listen,
  67. Syn_sent,
  68. Syn_received,
  69. Established,
  70. Finwait1,
  71. Finwait2,
  72. Close_wait,
  73. Closing,
  74. Last_ack,
  75. Time_wait,
  76. Maxlimbo = 1000, /* maximum procs waiting for response to SYN ACK */
  77. NLHT = 256, /* hash table size, must be a power of 2 */
  78. LHTMASK = NLHT-1,
  79. /*
  80. * window is 64kb * 2ⁿ
  81. * these factors determine the ultimate bandwidth-delay product.
  82. * 64kb * 2⁵ = 2mb, or 2× overkill for 100mbps * 70ms.
  83. */
  84. Maxqscale = 4, /* maximum queuing scale */
  85. Defadvscale = 4, /* default advertisement */
  86. };
  87. /* Must correspond to the enumeration above */
  88. char *tcpstates[] =
  89. {
  90. "Closed", "Listen", "Syn_sent", "Syn_received",
  91. "Established", "Finwait1", "Finwait2", "Close_wait",
  92. "Closing", "Last_ack", "Time_wait"
  93. };
  94. typedef struct Tcptimer Tcptimer;
  95. struct Tcptimer
  96. {
  97. Tcptimer *next;
  98. Tcptimer *prev;
  99. Tcptimer *readynext;
  100. int state;
  101. int start;
  102. int count;
  103. void (*func)(void*);
  104. void *arg;
  105. };
  106. /*
  107. * v4 and v6 pseudo headers used for
  108. * checksuming tcp
  109. */
  110. typedef struct Tcp4hdr Tcp4hdr;
  111. struct Tcp4hdr
  112. {
  113. uint8_t vihl; /* Version and header length */
  114. uint8_t tos; /* Type of service */
  115. uint8_t length[2]; /* packet length */
  116. uint8_t id[2]; /* Identification */
  117. uint8_t frag[2]; /* Fragment information */
  118. uint8_t Unused;
  119. uint8_t proto;
  120. uint8_t tcplen[2];
  121. uint8_t tcpsrc[4];
  122. uint8_t tcpdst[4];
  123. /* same as v6 from here on */
  124. uint8_t tcpsport[2];
  125. uint8_t tcpdport[2];
  126. uint8_t tcpseq[4];
  127. uint8_t tcpack[4];
  128. uint8_t tcpflag[2];
  129. uint8_t tcpwin[2];
  130. uint8_t tcpcksum[2];
  131. uint8_t tcpurg[2];
  132. /* Options segment */
  133. uint8_t tcpopt[1];
  134. };
  135. typedef struct Tcp6hdr Tcp6hdr;
  136. struct Tcp6hdr
  137. {
  138. uint8_t vcf[4];
  139. uint8_t ploadlen[2];
  140. uint8_t proto;
  141. uint8_t ttl;
  142. uint8_t tcpsrc[IPaddrlen];
  143. uint8_t tcpdst[IPaddrlen];
  144. /* same as v4 from here on */
  145. uint8_t tcpsport[2];
  146. uint8_t tcpdport[2];
  147. uint8_t tcpseq[4];
  148. uint8_t tcpack[4];
  149. uint8_t tcpflag[2];
  150. uint8_t tcpwin[2];
  151. uint8_t tcpcksum[2];
  152. uint8_t tcpurg[2];
  153. /* Options segment */
  154. uint8_t tcpopt[1];
  155. };
  156. /*
  157. * this represents the control info
  158. * for a single packet. It is derived from
  159. * a packet in ntohtcp{4,6}() and stuck into
  160. * a packet in htontcp{4,6}().
  161. */
  162. typedef struct Tcp Tcp;
  163. struct Tcp
  164. {
  165. uint16_t source;
  166. uint16_t dest;
  167. uint32_t seq;
  168. uint32_t ack;
  169. uint8_t flags;
  170. uint8_t update;
  171. uint16_t ws; /* window scale option */
  172. uint32_t wnd; /* prescaled window*/
  173. uint16_t urg;
  174. uint16_t mss; /* max segment size option (if not zero) */
  175. uint16_t len; /* size of data */
  176. };
  177. /*
  178. * this header is malloc'd to thread together fragments
  179. * waiting to be coalesced
  180. */
  181. typedef struct Reseq Reseq;
  182. struct Reseq
  183. {
  184. Reseq *next;
  185. Tcp seg;
  186. Block *bp;
  187. uint16_t length;
  188. };
  189. /*
  190. * the qlock in the Conv locks this structure
  191. */
  192. typedef struct Tcpctl Tcpctl;
  193. struct Tcpctl
  194. {
  195. uint8_t state; /* Connection state */
  196. uint8_t type; /* Listening or active connection */
  197. uint8_t code; /* Icmp code */
  198. struct {
  199. uint32_t una; /* Unacked data pointer */
  200. uint32_t nxt; /* Next sequence expected */
  201. uint32_t ptr; /* Data pointer */
  202. uint32_t wnd; /* Tcp send window */
  203. uint32_t urg; /* Urgent data pointer */
  204. uint32_t wl2;
  205. uint scale; /* how much to right shift window */
  206. /* in xmitted packets */
  207. /* to implement tahoe and reno TCP */
  208. uint32_t dupacks; /* number of duplicate acks rcvd */
  209. uint32_t partialack;
  210. int recovery; /* loss recovery flag */
  211. int retransmit; /* retransmit 1 packet @ una flag */
  212. int rto;
  213. uint32_t rxt; /* right window marker for recovery */
  214. /* "recover" rfc3782 */
  215. } snd;
  216. struct {
  217. uint32_t nxt; /* Receive pointer to next uint8_t slot */
  218. uint32_t wnd; /* Receive window incoming */
  219. uint32_t wsnt; /* Last wptr sent. important to */
  220. /* track for large bdp */
  221. uint32_t wptr;
  222. uint32_t urg; /* Urgent pointer */
  223. uint32_t ackptr; /* last acked sequence */
  224. int blocked;
  225. uint scale; /* how much to left shift window in */
  226. /* rcv'd packets */
  227. } rcv;
  228. uint32_t iss; /* Initial sequence number */
  229. uint32_t cwind; /* Congestion window */
  230. uint32_t abcbytes; /* appropriate byte counting rfc 3465 */
  231. uint scale; /* desired snd.scale */
  232. uint32_t ssthresh; /* Slow start threshold */
  233. int resent; /* Bytes just resent */
  234. int irs; /* Initial received squence */
  235. uint16_t mss; /* Maximum segment size */
  236. int rerecv; /* Overlap of data rerecevived */
  237. uint32_t window; /* Our receive window (queue) */
  238. uint qscale; /* Log2 of our receive window (queue) */
  239. uint8_t backoff; /* Exponential backoff counter */
  240. int backedoff; /* ms we've backed off for rexmits */
  241. uint8_t flags; /* State flags */
  242. Reseq *reseq; /* Resequencing queue */
  243. int nreseq;
  244. int reseqlen;
  245. Tcptimer timer; /* Activity timer */
  246. Tcptimer acktimer; /* Acknowledge timer */
  247. Tcptimer rtt_timer; /* Round trip timer */
  248. Tcptimer katimer; /* keep alive timer */
  249. uint32_t rttseq; /* Round trip sequence */
  250. int srtt; /* Smoothed round trip */
  251. int mdev; /* Mean deviation of round trip */
  252. int kacounter; /* count down for keep alive */
  253. uint sndsyntime; /* time syn sent */
  254. uint32_t time; /* time Finwait2 or Syn_received was sent */
  255. uint32_t timeuna; /* snd.una when time was set */
  256. int nochecksum; /* non-zero means don't send checksums */
  257. int flgcnt; /* number of flags in the sequence (FIN,SEQ) */
  258. union {
  259. Tcp4hdr tcp4hdr;
  260. Tcp6hdr tcp6hdr;
  261. } protohdr; /* prototype header */
  262. };
  263. /*
  264. * New calls are put in limbo rather than having a conversation structure
  265. * allocated. Thus, a SYN attack results in lots of limbo'd calls but not
  266. * any real Conv structures mucking things up. Calls in limbo rexmit their
  267. * SYN ACK every SYNACK_RXTIMER ms up to 4 times, i.e., they disappear after 1 second.
  268. *
  269. * In particular they aren't on a listener's queue so that they don't figure
  270. * in the input queue limit.
  271. *
  272. * If 1/2 of a T3 was attacking SYN packets, we'ld have a permanent queue
  273. * of 70000 limbo'd calls. Not great for a linear list but doable. Therefore
  274. * there is no hashing of this list.
  275. */
  276. typedef struct Limbo Limbo;
  277. struct Limbo
  278. {
  279. Limbo *next;
  280. uint8_t laddr[IPaddrlen];
  281. uint8_t raddr[IPaddrlen];
  282. uint16_t lport;
  283. uint16_t rport;
  284. uint32_t irs; /* initial received sequence */
  285. uint32_t iss; /* initial sent sequence */
  286. uint16_t mss; /* mss from the other end */
  287. uint16_t rcvscale; /* how much to scale rcvd windows */
  288. uint16_t sndscale; /* how much to scale sent windows */
  289. uint32_t lastsend; /* last time we sent a synack */
  290. uint8_t version; /* v4 or v6 */
  291. uint8_t rexmits; /* number of retransmissions */
  292. };
  293. int tcp_irtt = DEF_RTT; /* Initial guess at round trip time */
  294. enum {
  295. /* MIB stats */
  296. MaxConn,
  297. Mss,
  298. ActiveOpens,
  299. PassiveOpens,
  300. EstabResets,
  301. CurrEstab,
  302. InSegs,
  303. OutSegs,
  304. RetransSegs,
  305. RetransSegsSent,
  306. RetransTimeouts,
  307. InErrs,
  308. OutRsts,
  309. /* non-MIB stats */
  310. CsumErrs,
  311. HlenErrs,
  312. LenErrs,
  313. Resequenced,
  314. OutOfOrder,
  315. ReseqBytelim,
  316. ReseqPktlim,
  317. Delayack,
  318. Wopenack,
  319. Recovery,
  320. RecoveryDone,
  321. RecoveryRTO,
  322. RecoveryNoSeq,
  323. RecoveryCwind,
  324. RecoveryPA,
  325. Nstats
  326. };
  327. static char *statnames[Nstats] =
  328. {
  329. [MaxConn] = "MaxConn",
  330. [Mss] = "MaxSegment",
  331. [ActiveOpens] = "ActiveOpens",
  332. [PassiveOpens] = "PassiveOpens",
  333. [EstabResets] = "EstabResets",
  334. [CurrEstab] = "CurrEstab",
  335. [InSegs] = "InSegs",
  336. [OutSegs] = "OutSegs",
  337. [RetransSegs] = "RetransSegs",
  338. [RetransSegsSent] = "RetransSegsSent",
  339. [RetransTimeouts] = "RetransTimeouts",
  340. [InErrs] = "InErrs",
  341. [OutRsts] = "OutRsts",
  342. [CsumErrs] = "CsumErrs",
  343. [HlenErrs] = "HlenErrs",
  344. [LenErrs] = "LenErrs",
  345. [OutOfOrder] = "OutOfOrder",
  346. [Resequenced] = "Resequenced",
  347. [ReseqBytelim] = "ReseqBytelim",
  348. [ReseqPktlim] = "ReseqPktlim",
  349. [Delayack] = "Delayack",
  350. [Wopenack] = "Wopenack",
  351. [Recovery] = "Recovery",
  352. [RecoveryDone] = "RecoveryDone",
  353. [RecoveryRTO] = "RecoveryRTO",
  354. [RecoveryNoSeq] = "RecoveryNoSeq",
  355. [RecoveryCwind] = "RecoveryCwind",
  356. [RecoveryPA] = "RecoveryPA",
  357. };
  358. typedef struct Tcppriv Tcppriv;
  359. struct Tcppriv
  360. {
  361. /* List of active timers */
  362. QLock tl;
  363. Tcptimer *timers;
  364. /* hash table for matching conversations */
  365. Ipht ht;
  366. /* calls in limbo waiting for an ACK to our SYN ACK */
  367. int nlimbo;
  368. Limbo *lht[NLHT];
  369. /* for keeping track of tcpackproc */
  370. QLock apl;
  371. int ackprocstarted;
  372. uint64_t stats[Nstats];
  373. };
  374. /*
  375. * Setting tcpporthogdefense to non-zero enables Dong Lin's
  376. * solution to hijacked systems staking out port's as a form
  377. * of DoS attack.
  378. *
  379. * To avoid stateless Conv hogs, we pick a sequence number at random. If
  380. * that number gets acked by the other end, we shut down the connection.
  381. * Look for tcpporthogdefense in the code.
  382. */
  383. int tcpporthogdefense = 0;
  384. static int addreseq(Fs*, Tcpctl*, Tcppriv*, Tcp*, Block*, uint16_t);
  385. static int dumpreseq(Tcpctl*);
  386. static void getreseq(Tcpctl*, Tcp*, Block**, uint16_t*);
  387. static void limbo(Conv*, uint8_t*, uint8_t*, Tcp*, int);
  388. static void limborexmit(Proto*);
  389. static void localclose(Conv*, char*);
  390. static void procsyn(Conv*, Tcp*);
  391. static void tcpacktimer(void*);
  392. static void tcpiput(Proto*, Ipifc*, Block*);
  393. static void tcpkeepalive(void*);
  394. static void tcpoutput(Conv*);
  395. static void tcprcvwin(Conv*);
  396. static void tcprxmit(Conv*);
  397. static void tcpsetkacounter(Tcpctl*);
  398. static void tcpsetscale(Conv*, Tcpctl*, uint16_t, uint16_t);
  399. static void tcpsettimer(Tcpctl*);
  400. static void tcpsndsyn(Conv*, Tcpctl*);
  401. static void tcpstart(Conv*, int);
  402. static void tcpsynackrtt(Conv*);
  403. static void tcptimeout(void*);
  404. static int tcptrim(Tcpctl*, Tcp*, Block**, uint16_t*);
  405. static void
  406. tcpsetstate(Conv *s, uint8_t newstate)
  407. {
  408. Tcpctl *tcb;
  409. uint8_t oldstate;
  410. Tcppriv *tpriv;
  411. tpriv = s->p->priv;
  412. tcb = (Tcpctl*)s->ptcl;
  413. oldstate = tcb->state;
  414. if(oldstate == newstate)
  415. return;
  416. if(oldstate == Established)
  417. tpriv->stats[CurrEstab]--;
  418. if(newstate == Established)
  419. tpriv->stats[CurrEstab]++;
  420. switch(newstate) {
  421. case Closed:
  422. qclose(s->rq);
  423. qclose(s->wq);
  424. qclose(s->eq);
  425. break;
  426. case Close_wait: /* Remote closes */
  427. qhangup(s->rq, nil);
  428. break;
  429. }
  430. tcb->state = newstate;
  431. if(oldstate == Syn_sent && newstate != Closed)
  432. Fsconnected(s, nil);
  433. }
  434. static char*
  435. tcpconnect(Conv *c, char **argv, int argc)
  436. {
  437. char *e;
  438. Tcpctl *tcb;
  439. tcb = (Tcpctl*)(c->ptcl);
  440. if(tcb->state != Closed)
  441. return Econinuse;
  442. e = Fsstdconnect(c, argv, argc);
  443. if(e != nil)
  444. return e;
  445. tcpstart(c, TCP_CONNECT);
  446. return nil;
  447. }
  448. static int
  449. tcpstate(Conv *c, char *state, int n)
  450. {
  451. Tcpctl *s;
  452. s = (Tcpctl*)(c->ptcl);
  453. return snprint(state, n,
  454. "%s qin %d qout %d rq %d.%d srtt %d mdev %d sst %lu cwin %lu "
  455. "swin %lu>>%d rwin %lu>>%d qscale %d timer.start %d "
  456. "timer.count %d rerecv %d katimer.start %d katimer.count %d\n",
  457. tcpstates[s->state],
  458. c->rq ? qlen(c->rq) : 0,
  459. c->wq ? qlen(c->wq) : 0,
  460. s->nreseq, s->reseqlen,
  461. s->srtt, s->mdev, s->ssthresh,
  462. s->cwind, s->snd.wnd, s->rcv.scale, s->rcv.wnd, s->snd.scale,
  463. s->qscale,
  464. s->timer.start, s->timer.count, s->rerecv,
  465. s->katimer.start, s->katimer.count);
  466. }
  467. static int
  468. tcpinuse(Conv *c)
  469. {
  470. Tcpctl *s;
  471. s = (Tcpctl*)(c->ptcl);
  472. return s->state != Closed;
  473. }
  474. static char*
  475. tcpannounce(Conv *c, char **argv, int argc)
  476. {
  477. char *e;
  478. Tcpctl *tcb;
  479. tcb = (Tcpctl*)(c->ptcl);
  480. if(tcb->state != Closed)
  481. return Econinuse;
  482. e = Fsstdannounce(c, argv, argc);
  483. if(e != nil)
  484. return e;
  485. tcpstart(c, TCP_LISTEN);
  486. Fsconnected(c, nil);
  487. return nil;
  488. }
  489. /*
  490. * tcpclose is always called with the q locked
  491. */
  492. static void
  493. tcpclose(Conv *c)
  494. {
  495. Tcpctl *tcb;
  496. tcb = (Tcpctl*)c->ptcl;
  497. qhangup(c->rq, nil);
  498. qhangup(c->wq, nil);
  499. qhangup(c->eq, nil);
  500. qflush(c->rq);
  501. switch(tcb->state) {
  502. case Listen:
  503. /*
  504. * reset any incoming calls to this listener
  505. */
  506. Fsconnected(c, "Hangup");
  507. localclose(c, nil);
  508. break;
  509. case Closed:
  510. case Syn_sent:
  511. localclose(c, nil);
  512. break;
  513. case Syn_received:
  514. case Established:
  515. tcb->flgcnt++;
  516. tcb->snd.nxt++;
  517. tcpsetstate(c, Finwait1);
  518. tcpoutput(c);
  519. break;
  520. case Close_wait:
  521. tcb->flgcnt++;
  522. tcb->snd.nxt++;
  523. tcpsetstate(c, Last_ack);
  524. tcpoutput(c);
  525. break;
  526. }
  527. }
  528. static void
  529. tcpkick(void *x)
  530. {
  531. Proc *up = externup();
  532. Conv *s = x;
  533. Tcpctl *tcb;
  534. tcb = (Tcpctl*)s->ptcl;
  535. if(waserror()){
  536. qunlock(&s->ql);
  537. nexterror();
  538. }
  539. qlock(&s->ql);
  540. switch(tcb->state) {
  541. case Syn_sent:
  542. case Syn_received:
  543. case Established:
  544. case Close_wait:
  545. /*
  546. * Push data
  547. */
  548. tcpoutput(s);
  549. break;
  550. default:
  551. localclose(s, "Hangup");
  552. break;
  553. }
  554. qunlock(&s->ql);
  555. poperror();
  556. }
  557. static int seq_lt(uint32_t, uint32_t);
  558. static void
  559. tcprcvwin(Conv *s) /* Call with tcb locked */
  560. {
  561. int w;
  562. Tcpctl *tcb;
  563. tcb = (Tcpctl*)s->ptcl;
  564. w = tcb->window - qlen(s->rq);
  565. if(w < 0)
  566. w = 0;
  567. /* RFC 1122 § 4.2.2.17 do not move right edge of window left */
  568. if(seq_lt(tcb->rcv.nxt + w, tcb->rcv.wptr))
  569. w = tcb->rcv.wptr - tcb->rcv.nxt;
  570. if(w != tcb->rcv.wnd)
  571. if(w>>tcb->rcv.scale == 0 || (tcb->window > 4*tcb->mss && w < tcb->mss/4)){
  572. tcb->rcv.blocked = 1;
  573. netlog(s->p->f, Logtcp, "tcprcvwin: window %lu qlen %d ws %u lport %d\n",
  574. tcb->window, qlen(s->rq), tcb->rcv.scale, s->lport);
  575. }
  576. tcb->rcv.wnd = w;
  577. tcb->rcv.wptr = tcb->rcv.nxt + w;
  578. }
  579. static void
  580. tcpacktimer(void *v)
  581. {
  582. Proc *up = externup();
  583. Tcpctl *tcb;
  584. Conv *s;
  585. s = v;
  586. tcb = (Tcpctl*)s->ptcl;
  587. if(waserror()){
  588. qunlock(&s->ql);
  589. nexterror();
  590. }
  591. qlock(&s->ql);
  592. if(tcb->state != Closed){
  593. tcb->flags |= FORCE;
  594. tcpoutput(s);
  595. }
  596. qunlock(&s->ql);
  597. poperror();
  598. }
  599. static void
  600. tcpcongestion(Tcpctl *tcb)
  601. {
  602. uint32_t inflight;
  603. inflight = tcb->snd.nxt - tcb->snd.una;
  604. if(inflight > tcb->cwind)
  605. inflight = tcb->cwind;
  606. tcb->ssthresh = inflight / 2;
  607. if(tcb->ssthresh < 2*tcb->mss)
  608. tcb->ssthresh = 2*tcb->mss;
  609. }
  610. enum {
  611. L = 2, /* aggressive slow start; legal values ∈ (1.0, 2.0) */
  612. };
  613. static void
  614. tcpabcincr(Tcpctl *tcb, uint acked)
  615. {
  616. uint limit;
  617. tcb->abcbytes += acked;
  618. if(tcb->cwind < tcb->ssthresh){
  619. /* slow start */
  620. if(tcb->snd.rto)
  621. limit = tcb->mss;
  622. else
  623. limit = L*tcb->mss;
  624. tcb->cwind += MIN(tcb->abcbytes, limit);
  625. tcb->abcbytes = 0;
  626. } else {
  627. tcb->snd.rto = 0;
  628. /* avoidance */
  629. if(tcb->abcbytes >= tcb->cwind){
  630. tcb->abcbytes -= tcb->cwind;
  631. tcb->cwind += tcb->mss;
  632. }
  633. }
  634. }
  635. static void
  636. tcpcreate(Conv *c)
  637. {
  638. c->rq = qopen(QMAX, Qcoalesce, tcpacktimer, c);
  639. c->wq = qopen(QMAX, Qkick, tcpkick, c);
  640. }
  641. static void
  642. timerstate(Tcppriv *priv, Tcptimer *t, int newstate)
  643. {
  644. if(newstate != TcptimerON){
  645. if(t->state == TcptimerON){
  646. /* unchain */
  647. if(priv->timers == t){
  648. priv->timers = t->next;
  649. if(t->prev != nil)
  650. panic("timerstate1");
  651. }
  652. if(t->next)
  653. t->next->prev = t->prev;
  654. if(t->prev)
  655. t->prev->next = t->next;
  656. t->next = t->prev = nil;
  657. }
  658. } else {
  659. if(t->state != TcptimerON){
  660. /* chain */
  661. if(t->prev != nil || t->next != nil)
  662. panic("timerstate2");
  663. t->prev = nil;
  664. t->next = priv->timers;
  665. if(t->next)
  666. t->next->prev = t;
  667. priv->timers = t;
  668. }
  669. }
  670. t->state = newstate;
  671. }
  672. static void
  673. tcpackproc(void *a)
  674. {
  675. Proc *up = externup();
  676. Tcptimer *t, *tp, *timeo;
  677. Proto *tcp;
  678. Tcppriv *priv;
  679. int loop;
  680. tcp = a;
  681. priv = tcp->priv;
  682. for(;;) {
  683. tsleep(&up->sleep, return0, 0, MSPTICK);
  684. qlock(&priv->tl);
  685. timeo = nil;
  686. loop = 0;
  687. for(t = priv->timers; t != nil; t = tp) {
  688. if(loop++ > 10000)
  689. panic("tcpackproc1");
  690. tp = t->next;
  691. if(t->state == TcptimerON) {
  692. t->count--;
  693. if(t->count == 0) {
  694. timerstate(priv, t, TcptimerDONE);
  695. t->readynext = timeo;
  696. timeo = t;
  697. }
  698. }
  699. }
  700. qunlock(&priv->tl);
  701. loop = 0;
  702. for(t = timeo; t != nil; t = t->readynext) {
  703. if(loop++ > 10000)
  704. panic("tcpackproc2");
  705. if(t->state == TcptimerDONE && t->func != nil && !waserror()){
  706. (*t->func)(t->arg);
  707. poperror();
  708. }
  709. }
  710. limborexmit(tcp);
  711. }
  712. }
  713. static void
  714. tcpgo(Tcppriv *priv, Tcptimer *t)
  715. {
  716. if(t == nil || t->start == 0)
  717. return;
  718. qlock(&priv->tl);
  719. t->count = t->start;
  720. timerstate(priv, t, TcptimerON);
  721. qunlock(&priv->tl);
  722. }
  723. static void
  724. tcphalt(Tcppriv *priv, Tcptimer *t)
  725. {
  726. if(t == nil)
  727. return;
  728. qlock(&priv->tl);
  729. timerstate(priv, t, TcptimerOFF);
  730. qunlock(&priv->tl);
  731. }
  732. static int
  733. backoff(int n)
  734. {
  735. return 1 << n;
  736. }
  737. static void
  738. localclose(Conv *s, char *reason) /* called with tcb locked */
  739. {
  740. Tcpctl *tcb;
  741. Tcppriv *tpriv;
  742. tpriv = s->p->priv;
  743. tcb = (Tcpctl*)s->ptcl;
  744. iphtrem(&tpriv->ht, s);
  745. tcphalt(tpriv, &tcb->timer);
  746. tcphalt(tpriv, &tcb->rtt_timer);
  747. tcphalt(tpriv, &tcb->acktimer);
  748. tcphalt(tpriv, &tcb->katimer);
  749. /* Flush reassembly queue; nothing more can arrive */
  750. dumpreseq(tcb);
  751. if(tcb->state == Syn_sent)
  752. Fsconnected(s, reason);
  753. if(s->state == Announced)
  754. wakeup(&s->listenr);
  755. qhangup(s->rq, reason);
  756. qhangup(s->wq, reason);
  757. tcpsetstate(s, Closed);
  758. }
  759. /* mtu (- TCP + IP hdr len) of 1st hop */
  760. static int
  761. tcpmtu(Proto *tcp, uint8_t *addr, int version, uint *scale)
  762. {
  763. Ipifc *ifc;
  764. int mtu;
  765. ifc = findipifc(tcp->f, addr, 0);
  766. switch(version){
  767. default:
  768. case V4:
  769. mtu = DEF_MSS;
  770. if(ifc != nil)
  771. mtu = ifc->maxtu - ifc->medium->hsize - (TCP4_PKT + TCP4_HDRSIZE);
  772. break;
  773. case V6:
  774. mtu = DEF_MSS6;
  775. if(ifc != nil)
  776. mtu = ifc->maxtu - ifc->medium->hsize - (TCP6_PKT + TCP6_HDRSIZE);
  777. break;
  778. }
  779. /*
  780. * set the ws. it doesn't commit us to anything.
  781. * ws is the ultimate limit to the bandwidth-delay product.
  782. */
  783. *scale = Defadvscale;
  784. return mtu;
  785. }
  786. static void
  787. inittcpctl(Conv *s, int mode)
  788. {
  789. Tcpctl *tcb;
  790. Tcp4hdr* h4;
  791. Tcp6hdr* h6;
  792. Tcppriv *tpriv;
  793. int mss;
  794. tcb = (Tcpctl*)s->ptcl;
  795. memset(tcb, 0, sizeof(Tcpctl));
  796. tcb->ssthresh = QMAX; /* reset by tcpsetscale() */
  797. tcb->srtt = tcp_irtt<<LOGAGAIN;
  798. tcb->mdev = 0;
  799. /* setup timers */
  800. tcb->timer.start = tcp_irtt / MSPTICK;
  801. tcb->timer.func = tcptimeout;
  802. tcb->timer.arg = s;
  803. tcb->rtt_timer.start = MAX_TIME;
  804. tcb->acktimer.start = TCP_ACK / MSPTICK;
  805. tcb->acktimer.func = tcpacktimer;
  806. tcb->acktimer.arg = s;
  807. tcb->katimer.start = DEF_KAT / MSPTICK;
  808. tcb->katimer.func = tcpkeepalive;
  809. tcb->katimer.arg = s;
  810. mss = DEF_MSS;
  811. /* create a prototype(pseudo) header */
  812. if(mode != TCP_LISTEN){
  813. if(ipcmp(s->laddr, IPnoaddr) == 0)
  814. findlocalip(s->p->f, s->laddr, s->raddr);
  815. switch(s->ipversion){
  816. case V4:
  817. h4 = &tcb->protohdr.tcp4hdr;
  818. memset(h4, 0, sizeof(*h4));
  819. h4->proto = IP_TCPPROTO;
  820. hnputs(h4->tcpsport, s->lport);
  821. hnputs(h4->tcpdport, s->rport);
  822. v6tov4(h4->tcpsrc, s->laddr);
  823. v6tov4(h4->tcpdst, s->raddr);
  824. break;
  825. case V6:
  826. h6 = &tcb->protohdr.tcp6hdr;
  827. memset(h6, 0, sizeof(*h6));
  828. h6->proto = IP_TCPPROTO;
  829. hnputs(h6->tcpsport, s->lport);
  830. hnputs(h6->tcpdport, s->rport);
  831. ipmove(h6->tcpsrc, s->laddr);
  832. ipmove(h6->tcpdst, s->raddr);
  833. mss = DEF_MSS6;
  834. break;
  835. default:
  836. panic("inittcpctl: version %d", s->ipversion);
  837. }
  838. }
  839. tcb->mss = tcb->cwind = mss;
  840. tcb->abcbytes = 0;
  841. tpriv = s->p->priv;
  842. tpriv->stats[Mss] = tcb->mss;
  843. /* default is no window scaling */
  844. tcpsetscale(s, tcb, 0, 0);
  845. }
  846. /*
  847. * called with s qlocked
  848. */
  849. static void
  850. tcpstart(Conv *s, int mode)
  851. {
  852. Tcpctl *tcb;
  853. Tcppriv *tpriv;
  854. char kpname[KNAMELEN];
  855. tpriv = s->p->priv;
  856. if(tpriv->ackprocstarted == 0){
  857. qlock(&tpriv->apl);
  858. if(tpriv->ackprocstarted == 0){
  859. snprint(kpname, sizeof kpname, "#I%dtcpack", s->p->f->dev);
  860. kproc(kpname, tcpackproc, s->p);
  861. tpriv->ackprocstarted = 1;
  862. }
  863. qunlock(&tpriv->apl);
  864. }
  865. tcb = (Tcpctl*)s->ptcl;
  866. inittcpctl(s, mode);
  867. iphtadd(&tpriv->ht, s);
  868. switch(mode) {
  869. case TCP_LISTEN:
  870. tpriv->stats[PassiveOpens]++;
  871. tcb->flags |= CLONE;
  872. tcpsetstate(s, Listen);
  873. break;
  874. case TCP_CONNECT:
  875. tpriv->stats[ActiveOpens]++;
  876. tcb->flags |= ACTIVE;
  877. tcpsndsyn(s, tcb);
  878. tcpsetstate(s, Syn_sent);
  879. tcpoutput(s);
  880. break;
  881. }
  882. }
  883. #if 0
  884. static char*
  885. tcpflag(char *buf, char *e, uint16_t flag)
  886. {
  887. char *p;
  888. p = seprint(buf, e, "%d", flag>>10); /* Head len */
  889. if(flag & URG)
  890. p = seprint(p, e, " URG");
  891. if(flag & ACK)
  892. p = seprint(p, e, " ACK");
  893. if(flag & PSH)
  894. p = seprint(p, e, " PSH");
  895. if(flag & RST)
  896. p = seprint(p, e, " RST");
  897. if(flag & SYN)
  898. p = seprint(p, e, " SYN");
  899. if(flag & FIN)
  900. p = seprint(p, e, " FIN");
  901. USED(p);
  902. return buf;
  903. }
  904. #endif
  905. static Block*
  906. htontcp6(Tcp *tcph, Block *data, Tcp6hdr *ph, Tcpctl *tcb)
  907. {
  908. int dlen;
  909. Tcp6hdr *h;
  910. uint16_t csum;
  911. uint16_t hdrlen, optpad = 0;
  912. uint8_t *opt;
  913. hdrlen = TCP6_HDRSIZE;
  914. if(tcph->flags & SYN){
  915. if(tcph->mss)
  916. hdrlen += MSS_LENGTH;
  917. if(tcph->ws)
  918. hdrlen += WS_LENGTH;
  919. optpad = hdrlen & 3;
  920. if(optpad)
  921. optpad = 4 - optpad;
  922. hdrlen += optpad;
  923. }
  924. if(data) {
  925. dlen = blocklen(data);
  926. data = padblock(data, hdrlen + TCP6_PKT);
  927. if(data == nil)
  928. return nil;
  929. }
  930. else {
  931. dlen = 0;
  932. data = allocb(hdrlen + TCP6_PKT + 64); /* the 64 pad is to meet mintu's */
  933. if(data == nil)
  934. return nil;
  935. data->wp += hdrlen + TCP6_PKT;
  936. }
  937. /* copy in pseudo ip header plus port numbers */
  938. h = (Tcp6hdr *)(data->rp);
  939. memmove(h, ph, TCP6_TCBPHDRSZ);
  940. /* compose pseudo tcp header, do cksum calculation */
  941. hnputl(h->vcf, hdrlen + dlen);
  942. h->ploadlen[0] = h->ploadlen[1] = h->proto = 0;
  943. h->ttl = ph->proto;
  944. /* copy in variable bits */
  945. hnputl(h->tcpseq, tcph->seq);
  946. hnputl(h->tcpack, tcph->ack);
  947. hnputs(h->tcpflag, (hdrlen<<10) | tcph->flags);
  948. hnputs(h->tcpwin, tcph->wnd>>(tcb != nil ? tcb->snd.scale : 0));
  949. hnputs(h->tcpurg, tcph->urg);
  950. if(tcph->flags & SYN){
  951. opt = h->tcpopt;
  952. if(tcph->mss != 0){
  953. *opt++ = MSSOPT;
  954. *opt++ = MSS_LENGTH;
  955. hnputs(opt, tcph->mss);
  956. opt += 2;
  957. }
  958. if(tcph->ws != 0){
  959. *opt++ = WSOPT;
  960. *opt++ = WS_LENGTH;
  961. *opt++ = tcph->ws;
  962. }
  963. while(optpad-- > 0)
  964. *opt++ = NOOPOPT;
  965. }
  966. if(tcb != nil && tcb->nochecksum){
  967. h->tcpcksum[0] = h->tcpcksum[1] = 0;
  968. } else {
  969. csum = ptclcsum(data, TCP6_IPLEN, hdrlen+dlen+TCP6_PHDRSIZE);
  970. hnputs(h->tcpcksum, csum);
  971. }
  972. /* move from pseudo header back to normal ip header */
  973. memset(h->vcf, 0, 4);
  974. h->vcf[0] = IP_VER6;
  975. hnputs(h->ploadlen, hdrlen+dlen);
  976. h->proto = ph->proto;
  977. return data;
  978. }
  979. static Block*
  980. htontcp4(Tcp *tcph, Block *data, Tcp4hdr *ph, Tcpctl *tcb)
  981. {
  982. int dlen;
  983. Tcp4hdr *h;
  984. uint16_t csum;
  985. uint16_t hdrlen, optpad = 0;
  986. uint8_t *opt;
  987. hdrlen = TCP4_HDRSIZE;
  988. if(tcph->flags & SYN){
  989. if(tcph->mss)
  990. hdrlen += MSS_LENGTH;
  991. if(1)
  992. hdrlen += WS_LENGTH;
  993. optpad = hdrlen & 3;
  994. if(optpad)
  995. optpad = 4 - optpad;
  996. hdrlen += optpad;
  997. }
  998. if(data) {
  999. dlen = blocklen(data);
  1000. data = padblock(data, hdrlen + TCP4_PKT);
  1001. if(data == nil)
  1002. return nil;
  1003. }
  1004. else {
  1005. dlen = 0;
  1006. data = allocb(hdrlen + TCP4_PKT + 64); /* the 64 pad is to meet mintu's */
  1007. if(data == nil)
  1008. return nil;
  1009. data->wp += hdrlen + TCP4_PKT;
  1010. }
  1011. /* copy in pseudo ip header plus port numbers */
  1012. h = (Tcp4hdr *)(data->rp);
  1013. memmove(h, ph, TCP4_TCBPHDRSZ);
  1014. /* copy in variable bits */
  1015. hnputs(h->tcplen, hdrlen + dlen);
  1016. hnputl(h->tcpseq, tcph->seq);
  1017. hnputl(h->tcpack, tcph->ack);
  1018. hnputs(h->tcpflag, (hdrlen<<10) | tcph->flags);
  1019. hnputs(h->tcpwin, tcph->wnd>>(tcb != nil ? tcb->snd.scale : 0));
  1020. hnputs(h->tcpurg, tcph->urg);
  1021. if(tcph->flags & SYN){
  1022. opt = h->tcpopt;
  1023. if(tcph->mss != 0){
  1024. *opt++ = MSSOPT;
  1025. *opt++ = MSS_LENGTH;
  1026. hnputs(opt, tcph->mss);
  1027. opt += 2;
  1028. }
  1029. /* always offer. rfc1323 §2.2 */
  1030. if(1){
  1031. *opt++ = WSOPT;
  1032. *opt++ = WS_LENGTH;
  1033. *opt++ = tcph->ws;
  1034. }
  1035. while(optpad-- > 0)
  1036. *opt++ = NOOPOPT;
  1037. }
  1038. if(tcb != nil && tcb->nochecksum){
  1039. h->tcpcksum[0] = h->tcpcksum[1] = 0;
  1040. } else {
  1041. csum = ptclcsum(data, TCP4_IPLEN, hdrlen+dlen+TCP4_PHDRSIZE);
  1042. hnputs(h->tcpcksum, csum);
  1043. }
  1044. return data;
  1045. }
  1046. static int
  1047. ntohtcp6(Tcp *tcph, Block **bpp)
  1048. {
  1049. Tcp6hdr *h;
  1050. uint8_t *optr;
  1051. uint16_t hdrlen;
  1052. uint16_t optlen;
  1053. int n;
  1054. *bpp = pullupblock(*bpp, TCP6_PKT+TCP6_HDRSIZE);
  1055. if(*bpp == nil)
  1056. return -1;
  1057. h = (Tcp6hdr *)((*bpp)->rp);
  1058. tcph->source = nhgets(h->tcpsport);
  1059. tcph->dest = nhgets(h->tcpdport);
  1060. tcph->seq = nhgetl(h->tcpseq);
  1061. tcph->ack = nhgetl(h->tcpack);
  1062. hdrlen = (h->tcpflag[0]>>2) & ~3;
  1063. if(hdrlen < TCP6_HDRSIZE) {
  1064. freeblist(*bpp);
  1065. return -1;
  1066. }
  1067. tcph->flags = h->tcpflag[1];
  1068. tcph->wnd = nhgets(h->tcpwin);
  1069. tcph->urg = nhgets(h->tcpurg);
  1070. tcph->mss = 0;
  1071. tcph->ws = 0;
  1072. tcph->update = 0;
  1073. tcph->len = nhgets(h->ploadlen) - hdrlen;
  1074. *bpp = pullupblock(*bpp, hdrlen+TCP6_PKT);
  1075. if(*bpp == nil)
  1076. return -1;
  1077. optr = h->tcpopt;
  1078. n = hdrlen - TCP6_HDRSIZE;
  1079. while(n > 0 && *optr != EOLOPT) {
  1080. if(*optr == NOOPOPT) {
  1081. n--;
  1082. optr++;
  1083. continue;
  1084. }
  1085. optlen = optr[1];
  1086. if(optlen < 2 || optlen > n)
  1087. break;
  1088. switch(*optr) {
  1089. case MSSOPT:
  1090. if(optlen == MSS_LENGTH)
  1091. tcph->mss = nhgets(optr+2);
  1092. break;
  1093. case WSOPT:
  1094. if(optlen == WS_LENGTH && *(optr+2) <= 14)
  1095. tcph->ws = *(optr+2);
  1096. break;
  1097. }
  1098. n -= optlen;
  1099. optr += optlen;
  1100. }
  1101. return hdrlen;
  1102. }
  1103. static int
  1104. ntohtcp4(Tcp *tcph, Block **bpp)
  1105. {
  1106. Tcp4hdr *h;
  1107. uint8_t *optr;
  1108. uint16_t hdrlen;
  1109. uint16_t optlen;
  1110. int n;
  1111. *bpp = pullupblock(*bpp, TCP4_PKT+TCP4_HDRSIZE);
  1112. if(*bpp == nil)
  1113. return -1;
  1114. h = (Tcp4hdr *)((*bpp)->rp);
  1115. tcph->source = nhgets(h->tcpsport);
  1116. tcph->dest = nhgets(h->tcpdport);
  1117. tcph->seq = nhgetl(h->tcpseq);
  1118. tcph->ack = nhgetl(h->tcpack);
  1119. hdrlen = (h->tcpflag[0]>>2) & ~3;
  1120. if(hdrlen < TCP4_HDRSIZE) {
  1121. freeblist(*bpp);
  1122. return -1;
  1123. }
  1124. tcph->flags = h->tcpflag[1];
  1125. tcph->wnd = nhgets(h->tcpwin);
  1126. tcph->urg = nhgets(h->tcpurg);
  1127. tcph->mss = 0;
  1128. tcph->ws = 0;
  1129. tcph->update = 0;
  1130. tcph->len = nhgets(h->length) - (hdrlen + TCP4_PKT);
  1131. *bpp = pullupblock(*bpp, hdrlen+TCP4_PKT);
  1132. if(*bpp == nil)
  1133. return -1;
  1134. optr = h->tcpopt;
  1135. n = hdrlen - TCP4_HDRSIZE;
  1136. while(n > 0 && *optr != EOLOPT) {
  1137. if(*optr == NOOPOPT) {
  1138. n--;
  1139. optr++;
  1140. continue;
  1141. }
  1142. optlen = optr[1];
  1143. if(optlen < 2 || optlen > n)
  1144. break;
  1145. switch(*optr) {
  1146. case MSSOPT:
  1147. if(optlen == MSS_LENGTH)
  1148. tcph->mss = nhgets(optr+2);
  1149. break;
  1150. case WSOPT:
  1151. if(optlen == WS_LENGTH && *(optr+2) <= 14)
  1152. tcph->ws = *(optr+2);
  1153. break;
  1154. }
  1155. n -= optlen;
  1156. optr += optlen;
  1157. }
  1158. return hdrlen;
  1159. }
  1160. /*
  1161. * For outgoing calls, generate an initial sequence
  1162. * number and put a SYN on the send queue
  1163. */
  1164. static void
  1165. tcpsndsyn(Conv *s, Tcpctl *tcb)
  1166. {
  1167. Tcppriv *tpriv;
  1168. tcb->iss = (nrand(1<<16)<<16)|nrand(1<<16);
  1169. tcb->rttseq = tcb->iss;
  1170. tcb->snd.wl2 = tcb->iss;
  1171. tcb->snd.una = tcb->iss;
  1172. tcb->snd.rxt = tcb->iss;
  1173. tcb->snd.ptr = tcb->rttseq;
  1174. tcb->snd.nxt = tcb->rttseq;
  1175. tcb->flgcnt++;
  1176. tcb->flags |= FORCE;
  1177. tcb->sndsyntime = NOW;
  1178. /* set desired mss and scale */
  1179. tcb->mss = tcpmtu(s->p, s->laddr, s->ipversion, &tcb->scale);
  1180. tpriv = s->p->priv;
  1181. tpriv->stats[Mss] = tcb->mss;
  1182. }
  1183. void
  1184. sndrst(Proto *tcp, uint8_t *source, uint8_t *dest, uint16_t length, Tcp *seg, uint8_t version, char *reason)
  1185. {
  1186. Block *hbp;
  1187. uint8_t rflags;
  1188. Tcppriv *tpriv;
  1189. Tcp4hdr ph4;
  1190. Tcp6hdr ph6;
  1191. netlog(tcp->f, Logtcp, "sndrst: %s\n", reason);
  1192. tpriv = tcp->priv;
  1193. if(seg->flags & RST)
  1194. return;
  1195. /* make pseudo header */
  1196. switch(version) {
  1197. case V4:
  1198. memset(&ph4, 0, sizeof(ph4));
  1199. ph4.vihl = IP_VER4;
  1200. v6tov4(ph4.tcpsrc, dest);
  1201. v6tov4(ph4.tcpdst, source);
  1202. ph4.proto = IP_TCPPROTO;
  1203. hnputs(ph4.tcplen, TCP4_HDRSIZE);
  1204. hnputs(ph4.tcpsport, seg->dest);
  1205. hnputs(ph4.tcpdport, seg->source);
  1206. break;
  1207. case V6:
  1208. memset(&ph6, 0, sizeof(ph6));
  1209. ph6.vcf[0] = IP_VER6;
  1210. ipmove(ph6.tcpsrc, dest);
  1211. ipmove(ph6.tcpdst, source);
  1212. ph6.proto = IP_TCPPROTO;
  1213. hnputs(ph6.ploadlen, TCP6_HDRSIZE);
  1214. hnputs(ph6.tcpsport, seg->dest);
  1215. hnputs(ph6.tcpdport, seg->source);
  1216. break;
  1217. default:
  1218. panic("sndrst: version %d", version);
  1219. }
  1220. tpriv->stats[OutRsts]++;
  1221. rflags = RST;
  1222. /* convince the other end that this reset is in band */
  1223. if(seg->flags & ACK) {
  1224. seg->seq = seg->ack;
  1225. seg->ack = 0;
  1226. }
  1227. else {
  1228. rflags |= ACK;
  1229. seg->ack = seg->seq;
  1230. seg->seq = 0;
  1231. if(seg->flags & SYN)
  1232. seg->ack++;
  1233. seg->ack += length;
  1234. if(seg->flags & FIN)
  1235. seg->ack++;
  1236. }
  1237. seg->flags = rflags;
  1238. seg->wnd = 0;
  1239. seg->urg = 0;
  1240. seg->mss = 0;
  1241. seg->ws = 0;
  1242. switch(version) {
  1243. case V4:
  1244. hbp = htontcp4(seg, nil, &ph4, nil);
  1245. if(hbp == nil)
  1246. return;
  1247. ipoput4(tcp->f, hbp, 0, MAXTTL, DFLTTOS, nil);
  1248. break;
  1249. case V6:
  1250. hbp = htontcp6(seg, nil, &ph6, nil);
  1251. if(hbp == nil)
  1252. return;
  1253. ipoput6(tcp->f, hbp, 0, MAXTTL, DFLTTOS, nil);
  1254. break;
  1255. default:
  1256. panic("sndrst2: version %d", version);
  1257. }
  1258. }
  1259. /*
  1260. * send a reset to the remote side and close the conversation
  1261. * called with s qlocked
  1262. */
  1263. static char*
  1264. tcphangup(Conv *s)
  1265. {
  1266. Proc *up = externup();
  1267. Tcp seg;
  1268. Tcpctl *tcb;
  1269. Block *hbp;
  1270. tcb = (Tcpctl*)s->ptcl;
  1271. if(waserror())
  1272. return commonerror();
  1273. if(ipcmp(s->raddr, IPnoaddr) != 0) {
  1274. if(!waserror()){
  1275. memset(&seg, 0, sizeof seg);
  1276. seg.flags = RST | ACK;
  1277. seg.ack = tcb->rcv.nxt;
  1278. tcb->rcv.ackptr = seg.ack;
  1279. seg.seq = tcb->snd.ptr;
  1280. seg.wnd = 0;
  1281. seg.urg = 0;
  1282. seg.mss = 0;
  1283. seg.ws = 0;
  1284. switch(s->ipversion) {
  1285. case V4:
  1286. tcb->protohdr.tcp4hdr.vihl = IP_VER4;
  1287. hbp = htontcp4(&seg, nil, &tcb->protohdr.tcp4hdr, tcb);
  1288. ipoput4(s->p->f, hbp, 0, s->ttl, s->tos, s);
  1289. break;
  1290. case V6:
  1291. tcb->protohdr.tcp6hdr.vcf[0] = IP_VER6;
  1292. hbp = htontcp6(&seg, nil, &tcb->protohdr.tcp6hdr, tcb);
  1293. ipoput6(s->p->f, hbp, 0, s->ttl, s->tos, s);
  1294. break;
  1295. default:
  1296. panic("tcphangup: version %d", s->ipversion);
  1297. }
  1298. poperror();
  1299. }
  1300. }
  1301. localclose(s, nil);
  1302. poperror();
  1303. return nil;
  1304. }
  1305. /*
  1306. * (re)send a SYN ACK
  1307. */
  1308. static int
  1309. sndsynack(Proto *tcp, Limbo *lp)
  1310. {
  1311. Block *hbp;
  1312. Tcp4hdr ph4;
  1313. Tcp6hdr ph6;
  1314. Tcp seg;
  1315. uint scale;
  1316. /* make pseudo header */
  1317. switch(lp->version) {
  1318. case V4:
  1319. memset(&ph4, 0, sizeof(ph4));
  1320. ph4.vihl = IP_VER4;
  1321. v6tov4(ph4.tcpsrc, lp->laddr);
  1322. v6tov4(ph4.tcpdst, lp->raddr);
  1323. ph4.proto = IP_TCPPROTO;
  1324. hnputs(ph4.tcplen, TCP4_HDRSIZE);
  1325. hnputs(ph4.tcpsport, lp->lport);
  1326. hnputs(ph4.tcpdport, lp->rport);
  1327. break;
  1328. case V6:
  1329. memset(&ph6, 0, sizeof(ph6));
  1330. ph6.vcf[0] = IP_VER6;
  1331. ipmove(ph6.tcpsrc, lp->laddr);
  1332. ipmove(ph6.tcpdst, lp->raddr);
  1333. ph6.proto = IP_TCPPROTO;
  1334. hnputs(ph6.ploadlen, TCP6_HDRSIZE);
  1335. hnputs(ph6.tcpsport, lp->lport);
  1336. hnputs(ph6.tcpdport, lp->rport);
  1337. break;
  1338. default:
  1339. panic("sndrst: version %d", lp->version);
  1340. }
  1341. memset(&seg, 0, sizeof seg);
  1342. seg.seq = lp->iss;
  1343. seg.ack = lp->irs+1;
  1344. seg.flags = SYN|ACK;
  1345. seg.urg = 0;
  1346. seg.mss = tcpmtu(tcp, lp->laddr, lp->version, &scale);
  1347. seg.wnd = QMAX;
  1348. /* if the other side set scale, we should too */
  1349. if(lp->rcvscale){
  1350. seg.ws = scale;
  1351. lp->sndscale = scale;
  1352. } else {
  1353. seg.ws = 0;
  1354. lp->sndscale = 0;
  1355. }
  1356. switch(lp->version) {
  1357. case V4:
  1358. hbp = htontcp4(&seg, nil, &ph4, nil);
  1359. if(hbp == nil)
  1360. return -1;
  1361. ipoput4(tcp->f, hbp, 0, MAXTTL, DFLTTOS, nil);
  1362. break;
  1363. case V6:
  1364. hbp = htontcp6(&seg, nil, &ph6, nil);
  1365. if(hbp == nil)
  1366. return -1;
  1367. ipoput6(tcp->f, hbp, 0, MAXTTL, DFLTTOS, nil);
  1368. break;
  1369. default:
  1370. panic("sndsnack: version %d", lp->version);
  1371. }
  1372. lp->lastsend = NOW;
  1373. return 0;
  1374. }
  1375. #define hashipa(a, p) ( ( (a)[IPaddrlen-2] + (a)[IPaddrlen-1] + p )&LHTMASK )
  1376. /*
  1377. * put a call into limbo and respond with a SYN ACK
  1378. *
  1379. * called with proto locked
  1380. */
  1381. static void
  1382. limbo(Conv *s, uint8_t *source, uint8_t *dest, Tcp *seg, int version)
  1383. {
  1384. Limbo *lp, **l;
  1385. Tcppriv *tpriv;
  1386. int h;
  1387. tpriv = s->p->priv;
  1388. h = hashipa(source, seg->source);
  1389. for(l = &tpriv->lht[h]; *l != nil; l = &lp->next){
  1390. lp = *l;
  1391. if(lp->lport != seg->dest || lp->rport != seg->source || lp->version != version)
  1392. continue;
  1393. if(ipcmp(lp->raddr, source) != 0)
  1394. continue;
  1395. if(ipcmp(lp->laddr, dest) != 0)
  1396. continue;
  1397. /* each new SYN restarts the retransmits */
  1398. lp->irs = seg->seq;
  1399. break;
  1400. }
  1401. lp = *l;
  1402. if(lp == nil){
  1403. if(tpriv->nlimbo >= Maxlimbo && tpriv->lht[h]){
  1404. lp = tpriv->lht[h];
  1405. tpriv->lht[h] = lp->next;
  1406. lp->next = nil;
  1407. } else {
  1408. lp = malloc(sizeof(*lp));
  1409. if(lp == nil)
  1410. return;
  1411. tpriv->nlimbo++;
  1412. }
  1413. *l = lp;
  1414. lp->version = version;
  1415. ipmove(lp->laddr, dest);
  1416. ipmove(lp->raddr, source);
  1417. lp->lport = seg->dest;
  1418. lp->rport = seg->source;
  1419. lp->mss = seg->mss;
  1420. lp->rcvscale = seg->ws;
  1421. lp->irs = seg->seq;
  1422. lp->iss = (nrand(1<<16)<<16)|nrand(1<<16);
  1423. }
  1424. if(sndsynack(s->p, lp) < 0){
  1425. *l = lp->next;
  1426. tpriv->nlimbo--;
  1427. free(lp);
  1428. }
  1429. }
  1430. /*
  1431. * resend SYN ACK's once every SYNACK_RXTIMER ms.
  1432. */
  1433. static void
  1434. limborexmit(Proto *tcp)
  1435. {
  1436. Tcppriv *tpriv;
  1437. Limbo **l, *lp;
  1438. int h;
  1439. int seen;
  1440. uint32_t now;
  1441. tpriv = tcp->priv;
  1442. if(!canqlock(&tcp->ql))
  1443. return;
  1444. seen = 0;
  1445. now = NOW;
  1446. for(h = 0; h < NLHT && seen < tpriv->nlimbo; h++){
  1447. for(l = &tpriv->lht[h]; *l != nil && seen < tpriv->nlimbo; ){
  1448. lp = *l;
  1449. seen++;
  1450. if(now - lp->lastsend < (lp->rexmits+1)*SYNACK_RXTIMER)
  1451. continue;
  1452. /* time it out after 1 second */
  1453. if(++(lp->rexmits) > 5){
  1454. tpriv->nlimbo--;
  1455. *l = lp->next;
  1456. free(lp);
  1457. continue;
  1458. }
  1459. /* if we're being attacked, don't bother resending SYN ACK's */
  1460. if(tpriv->nlimbo > 100)
  1461. continue;
  1462. if(sndsynack(tcp, lp) < 0){
  1463. tpriv->nlimbo--;
  1464. *l = lp->next;
  1465. free(lp);
  1466. continue;
  1467. }
  1468. l = &lp->next;
  1469. }
  1470. }
  1471. qunlock(&tcp->ql);
  1472. }
  1473. /*
  1474. * lookup call in limbo. if found, throw it out.
  1475. *
  1476. * called with proto locked
  1477. */
  1478. static void
  1479. limborst(Conv *s, Tcp *segp, uint8_t *src, uint8_t *dst, uint8_t version)
  1480. {
  1481. Limbo *lp, **l;
  1482. int h;
  1483. Tcppriv *tpriv;
  1484. tpriv = s->p->priv;
  1485. /* find a call in limbo */
  1486. h = hashipa(src, segp->source);
  1487. for(l = &tpriv->lht[h]; *l != nil; l = &lp->next){
  1488. lp = *l;
  1489. if(lp->lport != segp->dest || lp->rport != segp->source || lp->version != version)
  1490. continue;
  1491. if(ipcmp(lp->laddr, dst) != 0)
  1492. continue;
  1493. if(ipcmp(lp->raddr, src) != 0)
  1494. continue;
  1495. /* RST can only follow the SYN */
  1496. if(segp->seq == lp->irs+1){
  1497. tpriv->nlimbo--;
  1498. *l = lp->next;
  1499. free(lp);
  1500. }
  1501. break;
  1502. }
  1503. }
  1504. static void
  1505. initialwindow(Tcpctl *tcb)
  1506. {
  1507. /* RFC 3390 initial window */
  1508. if(tcb->mss < 1095)
  1509. tcb->cwind = 4*tcb->mss;
  1510. else if(tcb->mss < 2190)
  1511. tcb->cwind = 2*2190;
  1512. else
  1513. tcb->cwind = 2*tcb->mss;
  1514. }
  1515. /*
  1516. * come here when we finally get an ACK to our SYN-ACK.
  1517. * lookup call in limbo. if found, create a new conversation
  1518. *
  1519. * called with proto locked
  1520. */
  1521. static Conv*
  1522. tcpincoming(Conv *s, Tcp *segp, uint8_t *src, uint8_t *dst, uint8_t version)
  1523. {
  1524. Conv *new;
  1525. Tcpctl *tcb;
  1526. Tcppriv *tpriv;
  1527. Tcp4hdr *h4;
  1528. Tcp6hdr *h6;
  1529. Limbo *lp, **l;
  1530. int h;
  1531. /* unless it's just an ack, it can't be someone coming out of limbo */
  1532. if((segp->flags & SYN) || (segp->flags & ACK) == 0)
  1533. return nil;
  1534. tpriv = s->p->priv;
  1535. /* find a call in limbo */
  1536. h = hashipa(src, segp->source);
  1537. for(l = &tpriv->lht[h]; (lp = *l) != nil; l = &lp->next){
  1538. netlog(s->p->f, Logtcp, "tcpincoming s %I!%u/%I!%u d %I!%u/%I!%u v %d/%d\n",
  1539. src, segp->source, lp->raddr, lp->rport,
  1540. dst, segp->dest, lp->laddr, lp->lport,
  1541. version, lp->version
  1542. );
  1543. if(lp->lport != segp->dest || lp->rport != segp->source || lp->version != version)
  1544. continue;
  1545. if(ipcmp(lp->laddr, dst) != 0)
  1546. continue;
  1547. if(ipcmp(lp->raddr, src) != 0)
  1548. continue;
  1549. /* we're assuming no data with the initial SYN */
  1550. if(segp->seq != lp->irs+1 || segp->ack != lp->iss+1){
  1551. netlog(s->p->f, Logtcp, "tcpincoming s %lx/%lx a %lx %lx\n",
  1552. segp->seq, lp->irs+1, segp->ack, lp->iss+1);
  1553. lp = nil;
  1554. } else {
  1555. tpriv->nlimbo--;
  1556. *l = lp->next;
  1557. }
  1558. break;
  1559. }
  1560. if(lp == nil)
  1561. return nil;
  1562. new = Fsnewcall(s, src, segp->source, dst, segp->dest, version);
  1563. if(new == nil)
  1564. return nil;
  1565. memmove(new->ptcl, s->ptcl, sizeof(Tcpctl));
  1566. tcb = (Tcpctl*)new->ptcl;
  1567. tcb->flags &= ~CLONE;
  1568. tcb->timer.arg = new;
  1569. tcb->timer.state = TcptimerOFF;
  1570. tcb->acktimer.arg = new;
  1571. tcb->acktimer.state = TcptimerOFF;
  1572. tcb->katimer.arg = new;
  1573. tcb->katimer.state = TcptimerOFF;
  1574. tcb->rtt_timer.arg = new;
  1575. tcb->rtt_timer.state = TcptimerOFF;
  1576. tcb->irs = lp->irs;
  1577. tcb->rcv.nxt = tcb->irs+1;
  1578. tcb->rcv.wptr = tcb->rcv.nxt;
  1579. tcb->rcv.wsnt = 0;
  1580. tcb->rcv.urg = tcb->rcv.nxt;
  1581. tcb->iss = lp->iss;
  1582. tcb->rttseq = tcb->iss;
  1583. tcb->snd.wl2 = tcb->iss;
  1584. tcb->snd.una = tcb->iss+1;
  1585. tcb->snd.ptr = tcb->iss+1;
  1586. tcb->snd.nxt = tcb->iss+1;
  1587. tcb->snd.rxt = tcb->iss+1;
  1588. tcb->flgcnt = 0;
  1589. tcb->flags |= SYNACK;
  1590. /* set desired mss and scale */
  1591. tcb->mss = tcpmtu(s->p, s->laddr, s->ipversion, &tcb->scale);
  1592. /* our sending max segment size cannot be bigger than what he asked for */
  1593. if(lp->mss != 0 && lp->mss < tcb->mss) {
  1594. tcb->mss = lp->mss;
  1595. }
  1596. tpriv->stats[Mss] = tcb->mss;
  1597. /* window scaling */
  1598. tcpsetscale(new, tcb, lp->rcvscale, lp->sndscale);
  1599. /* congestion window */
  1600. tcb->snd.wnd = segp->wnd;
  1601. initialwindow(tcb);
  1602. /* set initial round trip time */
  1603. tcb->sndsyntime = lp->lastsend+lp->rexmits*SYNACK_RXTIMER;
  1604. tcpsynackrtt(new);
  1605. free(lp);
  1606. /* set up proto header */
  1607. switch(version){
  1608. case V4:
  1609. h4 = &tcb->protohdr.tcp4hdr;
  1610. memset(h4, 0, sizeof(*h4));
  1611. h4->proto = IP_TCPPROTO;
  1612. hnputs(h4->tcpsport, new->lport);
  1613. hnputs(h4->tcpdport, new->rport);
  1614. v6tov4(h4->tcpsrc, dst);
  1615. v6tov4(h4->tcpdst, src);
  1616. break;
  1617. case V6:
  1618. h6 = &tcb->protohdr.tcp6hdr;
  1619. memset(h6, 0, sizeof(*h6));
  1620. h6->proto = IP_TCPPROTO;
  1621. hnputs(h6->tcpsport, new->lport);
  1622. hnputs(h6->tcpdport, new->rport);
  1623. ipmove(h6->tcpsrc, dst);
  1624. ipmove(h6->tcpdst, src);
  1625. break;
  1626. default:
  1627. panic("tcpincoming: version %d", new->ipversion);
  1628. }
  1629. tcpsetstate(new, Established);
  1630. iphtadd(&tpriv->ht, new);
  1631. return new;
  1632. }
  1633. static int
  1634. seq_within(uint32_t x, uint32_t low, uint32_t high)
  1635. {
  1636. if(low <= high){
  1637. if(low <= x && x <= high)
  1638. return 1;
  1639. }
  1640. else {
  1641. if(x >= low || x <= high)
  1642. return 1;
  1643. }
  1644. return 0;
  1645. }
  1646. static int
  1647. seq_lt(uint32_t x, uint32_t y)
  1648. {
  1649. return (int)(x-y) < 0;
  1650. }
  1651. static int
  1652. seq_le(uint32_t x, uint32_t y)
  1653. {
  1654. return (int)(x-y) <= 0;
  1655. }
  1656. static int
  1657. seq_gt(uint32_t x, uint32_t y)
  1658. {
  1659. return (int)(x-y) > 0;
  1660. }
  1661. static int
  1662. seq_ge(uint32_t x, uint32_t y)
  1663. {
  1664. return (int)(x-y) >= 0;
  1665. }
  1666. /*
  1667. * use the time between the first SYN and it's ack as the
  1668. * initial round trip time
  1669. */
  1670. static void
  1671. tcpsynackrtt(Conv *s)
  1672. {
  1673. Tcpctl *tcb;
  1674. int delta;
  1675. Tcppriv *tpriv;
  1676. tcb = (Tcpctl*)s->ptcl;
  1677. tpriv = s->p->priv;
  1678. delta = NOW - tcb->sndsyntime;
  1679. tcb->srtt = delta<<LOGAGAIN;
  1680. tcb->mdev = delta<<LOGDGAIN;
  1681. /* halt round trip timer */
  1682. tcphalt(tpriv, &tcb->rtt_timer);
  1683. }
  1684. static void
  1685. update(Conv *s, Tcp *seg)
  1686. {
  1687. int rtt, delta;
  1688. Tcpctl *tcb;
  1689. uint32_t acked;
  1690. Tcppriv *tpriv;
  1691. if(seg->update)
  1692. return;
  1693. seg->update = 1;
  1694. tpriv = s->p->priv;
  1695. tcb = (Tcpctl*)s->ptcl;
  1696. /* catch zero-window updates, update window & recover */
  1697. if(tcb->snd.wnd == 0 && seg->wnd > 0 &&
  1698. seq_lt(seg->ack, tcb->snd.ptr)){
  1699. netlog(s->p->f, Logtcp, "tcp: zwu ack %lu una %lu ptr %lu win %lu\n",
  1700. seg->ack, tcb->snd.una, tcb->snd.ptr, seg->wnd);
  1701. tcb->snd.wnd = seg->wnd;
  1702. goto recovery;
  1703. }
  1704. /* newreno fast retransmit */
  1705. if(seg->ack == tcb->snd.una && tcb->snd.una != tcb->snd.nxt &&
  1706. ++tcb->snd.dupacks == 3){ /* was TCPREXMTTHRESH */
  1707. recovery:
  1708. if(tcb->snd.recovery){
  1709. tpriv->stats[RecoveryCwind]++;
  1710. tcb->cwind += tcb->mss;
  1711. }else if(seq_le(tcb->snd.rxt, seg->ack)){
  1712. tpriv->stats[Recovery]++;
  1713. tcb->abcbytes = 0;
  1714. tcb->snd.recovery = 1;
  1715. tcb->snd.partialack = 0;
  1716. tcb->snd.rxt = tcb->snd.nxt;
  1717. tcpcongestion(tcb);
  1718. tcb->cwind = tcb->ssthresh + 3*tcb->mss;
  1719. netlog(s->p->f, Logtcpwin, "recovery inflate %ld ss %ld @%lu\n",
  1720. tcb->cwind, tcb->ssthresh, tcb->snd.rxt);
  1721. tcprxmit(s);
  1722. }else{
  1723. tpriv->stats[RecoveryNoSeq]++;
  1724. netlog(s->p->f, Logtcpwin, "!recov %lu not ≤ %lu %ld\n",
  1725. tcb->snd.rxt, seg->ack, tcb->snd.rxt - seg->ack);
  1726. /* don't enter fast retransmit, don't change ssthresh */
  1727. }
  1728. }else if(tcb->snd.recovery){
  1729. tpriv->stats[RecoveryCwind]++;
  1730. tcb->cwind += tcb->mss;
  1731. }
  1732. /*
  1733. * update window
  1734. */
  1735. if(seq_gt(seg->ack, tcb->snd.wl2)
  1736. || (tcb->snd.wl2 == seg->ack && seg->wnd > tcb->snd.wnd)){
  1737. /* clear dupack if we advance wl2 */
  1738. if(tcb->snd.wl2 != seg->ack)
  1739. tcb->snd.dupacks = 0;
  1740. tcb->snd.wnd = seg->wnd;
  1741. tcb->snd.wl2 = seg->ack;
  1742. }
  1743. if(!seq_gt(seg->ack, tcb->snd.una)){
  1744. /*
  1745. * don't let us hangup if sending into a closed window and
  1746. * we're still getting acks
  1747. */
  1748. if((tcb->flags&RETRAN) && tcb->snd.wnd == 0)
  1749. tcb->backedoff = MAXBACKMS/4;
  1750. return;
  1751. }
  1752. /* Compute the new send window size */
  1753. acked = seg->ack - tcb->snd.una;
  1754. /* avoid slow start and timers for SYN acks */
  1755. if((tcb->flags & SYNACK) == 0) {
  1756. tcb->flags |= SYNACK;
  1757. acked--;
  1758. tcb->flgcnt--;
  1759. goto done;
  1760. }
  1761. /*
  1762. * congestion control
  1763. */
  1764. if(tcb->snd.recovery){
  1765. if(seq_ge(seg->ack, tcb->snd.rxt)){
  1766. /* recovery finished; deflate window */
  1767. tpriv->stats[RecoveryDone]++;
  1768. tcb->snd.dupacks = 0;
  1769. tcb->snd.recovery = 0;
  1770. tcb->cwind = (tcb->snd.nxt - tcb->snd.una) + tcb->mss;
  1771. if(tcb->ssthresh < tcb->cwind)
  1772. tcb->cwind = tcb->ssthresh;
  1773. netlog(s->p->f, Logtcpwin, "recovery deflate %ld %ld\n",
  1774. tcb->cwind, tcb->ssthresh);
  1775. } else {
  1776. /* partial ack; we lost more than one segment */
  1777. tpriv->stats[RecoveryPA]++;
  1778. if(tcb->cwind > acked)
  1779. tcb->cwind -= acked;
  1780. else{
  1781. netlog(s->p->f, Logtcpwin, "partial ack neg\n");
  1782. tcb->cwind = tcb->mss;
  1783. }
  1784. netlog(s->p->f, Logtcpwin, "partial ack %ld left %ld cwind %ld\n",
  1785. acked, tcb->snd.rxt - seg->ack, tcb->cwind);
  1786. if(acked >= tcb->mss)
  1787. tcb->cwind += tcb->mss;
  1788. tcb->snd.partialack++;
  1789. }
  1790. } else
  1791. tcpabcincr(tcb, acked);
  1792. /* Adjust the timers according to the round trip time */
  1793. /* TODO: fix sloppy treatment of overflow cases here. */
  1794. if(tcb->rtt_timer.state == TcptimerON && seq_ge(seg->ack, tcb->rttseq)) {
  1795. tcphalt(tpriv, &tcb->rtt_timer);
  1796. if((tcb->flags&RETRAN) == 0) {
  1797. tcb->backoff = 0;
  1798. tcb->backedoff = 0;
  1799. rtt = tcb->rtt_timer.start - tcb->rtt_timer.count;
  1800. if(rtt == 0)
  1801. rtt = 1; /* else all close sys's will rexmit in 0 time */
  1802. rtt *= MSPTICK;
  1803. if(tcb->srtt == 0) {
  1804. tcb->srtt = rtt << LOGAGAIN;
  1805. tcb->mdev = rtt << LOGDGAIN;
  1806. } else {
  1807. delta = rtt - (tcb->srtt>>LOGAGAIN);
  1808. tcb->srtt += delta;
  1809. if(tcb->srtt <= 0)
  1810. tcb->srtt = 1;
  1811. delta = abs(delta) - (tcb->mdev>>LOGDGAIN);
  1812. tcb->mdev += delta;
  1813. if(tcb->mdev <= 0)
  1814. tcb->mdev = 1;
  1815. }
  1816. tcpsettimer(tcb);
  1817. }
  1818. }
  1819. done:
  1820. if(qdiscard(s->wq, acked) < acked)
  1821. tcb->flgcnt--;
  1822. tcb->snd.una = seg->ack;
  1823. /* newreno fast recovery */
  1824. if(tcb->snd.recovery)
  1825. tcprxmit(s);
  1826. if(seq_gt(seg->ack, tcb->snd.urg))
  1827. tcb->snd.urg = seg->ack;
  1828. if(tcb->snd.una != tcb->snd.nxt){
  1829. /* `impatient' variant */
  1830. if(!tcb->snd.recovery || tcb->snd.partialack == 1){
  1831. tcb->time = NOW;
  1832. tcb->timeuna = tcb->snd.una;
  1833. tcpgo(tpriv, &tcb->timer);
  1834. }
  1835. } else
  1836. tcphalt(tpriv, &tcb->timer);
  1837. if(seq_lt(tcb->snd.ptr, tcb->snd.una))
  1838. tcb->snd.ptr = tcb->snd.una;
  1839. if(!tcb->snd.recovery)
  1840. tcb->flags &= ~RETRAN;
  1841. tcb->backoff = 0;
  1842. tcb->backedoff = 0;
  1843. }
  1844. static void
  1845. tcpiput(Proto *tcp, Ipifc *ipifc, Block *bp)
  1846. {
  1847. Proc *up = externup();
  1848. Tcp seg;
  1849. Tcp4hdr *h4;
  1850. Tcp6hdr *h6;
  1851. int hdrlen;
  1852. Tcpctl *tcb;
  1853. uint16_t length, csum;
  1854. uint8_t source[IPaddrlen], dest[IPaddrlen];
  1855. Conv *s;
  1856. Fs *f;
  1857. Tcppriv *tpriv;
  1858. uint8_t version;
  1859. f = tcp->f;
  1860. tpriv = tcp->priv;
  1861. tpriv->stats[InSegs]++;
  1862. h4 = (Tcp4hdr*)(bp->rp);
  1863. h6 = (Tcp6hdr*)(bp->rp);
  1864. if((h4->vihl&0xF0)==IP_VER4) {
  1865. version = V4;
  1866. length = nhgets(h4->length);
  1867. v4tov6(dest, h4->tcpdst);
  1868. v4tov6(source, h4->tcpsrc);
  1869. h4->Unused = 0;
  1870. hnputs(h4->tcplen, length-TCP4_PKT);
  1871. if(!(bp->flag & Btcpck) && (h4->tcpcksum[0] || h4->tcpcksum[1]) &&
  1872. ptclcsum(bp, TCP4_IPLEN, length-TCP4_IPLEN)) {
  1873. tpriv->stats[CsumErrs]++;
  1874. tpriv->stats[InErrs]++;
  1875. netlog(f, Logtcp, "bad tcp proto cksum\n");
  1876. freeblist(bp);
  1877. return;
  1878. }
  1879. hdrlen = ntohtcp4(&seg, &bp);
  1880. if(hdrlen < 0){
  1881. tpriv->stats[HlenErrs]++;
  1882. tpriv->stats[InErrs]++;
  1883. netlog(f, Logtcp, "bad tcp hdr len\n");
  1884. return;
  1885. }
  1886. /* trim the packet to the size claimed by the datagram */
  1887. length -= hdrlen+TCP4_PKT;
  1888. bp = trimblock(bp, hdrlen+TCP4_PKT, length);
  1889. if(bp == nil){
  1890. tpriv->stats[LenErrs]++;
  1891. tpriv->stats[InErrs]++;
  1892. netlog(f, Logtcp, "tcp len < 0 after trim\n");
  1893. return;
  1894. }
  1895. }
  1896. else {
  1897. int ttl = h6->ttl;
  1898. int proto = h6->proto;
  1899. version = V6;
  1900. length = nhgets(h6->ploadlen);
  1901. ipmove(dest, h6->tcpdst);
  1902. ipmove(source, h6->tcpsrc);
  1903. h6->ploadlen[0] = h6->ploadlen[1] = h6->proto = 0;
  1904. h6->ttl = proto;
  1905. hnputl(h6->vcf, length);
  1906. if((h6->tcpcksum[0] || h6->tcpcksum[1]) &&
  1907. (csum = ptclcsum(bp, TCP6_IPLEN, length+TCP6_PHDRSIZE)) != 0) {
  1908. tpriv->stats[CsumErrs]++;
  1909. tpriv->stats[InErrs]++;
  1910. netlog(f, Logtcp,
  1911. "bad tcpv6 proto cksum: got %#x, computed %#x\n",
  1912. h6->tcpcksum[0]<<8 | h6->tcpcksum[1], csum);
  1913. freeblist(bp);
  1914. return;
  1915. }
  1916. h6->ttl = ttl;
  1917. h6->proto = proto;
  1918. hnputs(h6->ploadlen, length);
  1919. hdrlen = ntohtcp6(&seg, &bp);
  1920. if(hdrlen < 0){
  1921. tpriv->stats[HlenErrs]++;
  1922. tpriv->stats[InErrs]++;
  1923. netlog(f, Logtcp, "bad tcpv6 hdr len\n");
  1924. return;
  1925. }
  1926. /* trim the packet to the size claimed by the datagram */
  1927. length -= hdrlen;
  1928. bp = trimblock(bp, hdrlen+TCP6_PKT, length);
  1929. if(bp == nil){
  1930. tpriv->stats[LenErrs]++;
  1931. tpriv->stats[InErrs]++;
  1932. netlog(f, Logtcp, "tcpv6 len < 0 after trim\n");
  1933. return;
  1934. }
  1935. }
  1936. /* lock protocol while searching for a conversation */
  1937. qlock(&tcp->ql);
  1938. /* Look for a matching conversation */
  1939. s = iphtlook(&tpriv->ht, source, seg.source, dest, seg.dest);
  1940. if(s == nil){
  1941. netlog(f, Logtcp, "iphtlook(src %I!%d, dst %I!%d) failed\n",
  1942. source, seg.source, dest, seg.dest);
  1943. reset:
  1944. qunlock(&tcp->ql);
  1945. sndrst(tcp, source, dest, length, &seg, version, "no conversation");
  1946. freeblist(bp);
  1947. return;
  1948. }
  1949. /* if it's a listener, look for the right flags and get a new conv */
  1950. tcb = (Tcpctl*)s->ptcl;
  1951. if(tcb->state == Listen){
  1952. if(seg.flags & RST){
  1953. limborst(s, &seg, source, dest, version);
  1954. qunlock(&tcp->ql);
  1955. freeblist(bp);
  1956. return;
  1957. }
  1958. /* if this is a new SYN, put the call into limbo */
  1959. if((seg.flags & SYN) && (seg.flags & ACK) == 0){
  1960. limbo(s, source, dest, &seg, version);
  1961. qunlock(&tcp->ql);
  1962. freeblist(bp);
  1963. return;
  1964. }
  1965. /*
  1966. * if there's a matching call in limbo, tcpincoming will
  1967. * return it in state Syn_received
  1968. */
  1969. s = tcpincoming(s, &seg, source, dest, version);
  1970. if(s == nil)
  1971. goto reset;
  1972. }
  1973. /* The rest of the input state machine is run with the control block
  1974. * locked and implements the state machine directly out of the RFC.
  1975. * Out-of-band data is ignored - it was always a bad idea.
  1976. */
  1977. tcb = (Tcpctl*)s->ptcl;
  1978. if(waserror()){
  1979. qunlock(&s->ql);
  1980. nexterror();
  1981. }
  1982. qlock(&s->ql);
  1983. qunlock(&tcp->ql);
  1984. /* fix up window */
  1985. seg.wnd <<= tcb->rcv.scale;
  1986. /* every input packet in puts off the keep alive time out */
  1987. tcpsetkacounter(tcb);
  1988. switch(tcb->state) {
  1989. case Closed:
  1990. sndrst(tcp, source, dest, length, &seg, version, "sending to Closed");
  1991. goto raise;
  1992. case Syn_sent:
  1993. if(seg.flags & ACK) {
  1994. if(!seq_within(seg.ack, tcb->iss+1, tcb->snd.nxt)) {
  1995. sndrst(tcp, source, dest, length, &seg, version,
  1996. "bad seq in Syn_sent");
  1997. goto raise;
  1998. }
  1999. }
  2000. if(seg.flags & RST) {
  2001. if(seg.flags & ACK)
  2002. localclose(s, Econrefused);
  2003. goto raise;
  2004. }
  2005. if(seg.flags & SYN) {
  2006. procsyn(s, &seg);
  2007. if(seg.flags & ACK){
  2008. update(s, &seg);
  2009. tcpsynackrtt(s);
  2010. tcpsetstate(s, Established);
  2011. tcpsetscale(s, tcb, seg.ws, tcb->scale);
  2012. }
  2013. else {
  2014. tcb->time = NOW;
  2015. tcpsetstate(s, Syn_received); /* DLP - shouldn't this be a reset? */
  2016. }
  2017. if(length != 0 || (seg.flags & FIN))
  2018. break;
  2019. freeblist(bp);
  2020. goto output;
  2021. }
  2022. else
  2023. freeblist(bp);
  2024. qunlock(&s->ql);
  2025. poperror();
  2026. return;
  2027. case Syn_received:
  2028. /* doesn't matter if it's the correct ack, we're just trying to set timing */
  2029. if(seg.flags & ACK)
  2030. tcpsynackrtt(s);
  2031. break;
  2032. }
  2033. /*
  2034. * One DOS attack is to open connections to us and then forget about them,
  2035. * thereby tying up a conv at no long term cost to the attacker.
  2036. * This is an attempt to defeat these stateless DOS attacks. See
  2037. * corresponding code in tcpsendka().
  2038. */
  2039. if(tcb->state != Syn_received && (seg.flags & RST) == 0){
  2040. if(tcpporthogdefense
  2041. && seq_within(seg.ack, tcb->snd.una-(1<<31), tcb->snd.una-(1<<29))){
  2042. print("stateless hog %I.%d->%I.%d f %x %lx - %lx - %lx\n",
  2043. source, seg.source, dest, seg.dest, seg.flags,
  2044. tcb->snd.una-(1<<31), seg.ack, tcb->snd.una-(1<<29));
  2045. localclose(s, "stateless hog");
  2046. }
  2047. }
  2048. /* Cut the data to fit the receive window */
  2049. tcprcvwin(s);
  2050. if(tcptrim(tcb, &seg, &bp, &length) == -1) {
  2051. if(seg.seq+1 != tcb->rcv.nxt || length != 1)
  2052. netlog(f, Logtcp, "tcp: trim: !inwind: seq %lu-%lu win "
  2053. "%lu-%lu l %d from %I\n", seg.seq,
  2054. seg.seq + length - 1, tcb->rcv.nxt,
  2055. tcb->rcv.nxt + tcb->rcv.wnd-1, length, s->raddr);
  2056. update(s, &seg);
  2057. if(qlen(s->wq)+tcb->flgcnt == 0 && tcb->state == Closing) {
  2058. tcphalt(tpriv, &tcb->rtt_timer);
  2059. tcphalt(tpriv, &tcb->acktimer);
  2060. tcphalt(tpriv, &tcb->katimer);
  2061. tcpsetstate(s, Time_wait);
  2062. tcb->timer.start = MSL2*(1000 / MSPTICK);
  2063. tcpgo(tpriv, &tcb->timer);
  2064. }
  2065. if(!(seg.flags & RST)) {
  2066. tcb->flags |= FORCE;
  2067. goto output;
  2068. }
  2069. qunlock(&s->ql);
  2070. poperror();
  2071. return;
  2072. }
  2073. /* Cannot accept so answer with a rst */
  2074. if(length && tcb->state == Closed) {
  2075. sndrst(tcp, source, dest, length, &seg, version, "sending to Closed");
  2076. goto raise;
  2077. }
  2078. /* The segment is beyond the current receive pointer so
  2079. * queue the data in the resequence queue
  2080. */
  2081. if(seg.seq != tcb->rcv.nxt)
  2082. if(length != 0 || (seg.flags & (SYN|FIN))) {
  2083. update(s, &seg);
  2084. if(addreseq(f, tcb, tpriv, &seg, bp, length) < 0)
  2085. print("reseq %I.%d -> %I.%d\n", s->raddr, s->rport,
  2086. s->laddr, s->lport);
  2087. tcb->flags |= FORCE; /* force duplicate ack; RFC 5681 §3.2 */
  2088. goto output;
  2089. }
  2090. if(tcb->nreseq > 0)
  2091. tcb->flags |= FORCE; /* filled hole in seq. space; RFC 5681 §3.2 */
  2092. /*
  2093. * keep looping till we've processed this packet plus any
  2094. * adjacent packets in the resequence queue
  2095. */
  2096. for(;;) {
  2097. if(seg.flags & RST) {
  2098. if(tcb->state == Established) {
  2099. tpriv->stats[EstabResets]++;
  2100. if(tcb->rcv.nxt != seg.seq)
  2101. netlog(f, Logtcp, "out of order RST "
  2102. "rcvd: %I.%d -> %I.%d, rcv.nxt "
  2103. "%lx seq %lx\n",
  2104. s->raddr, s->rport, s->laddr,
  2105. s->lport, tcb->rcv.nxt, seg.seq);
  2106. }
  2107. localclose(s, Econrefused);
  2108. goto raise;
  2109. }
  2110. if((seg.flags&ACK) == 0)
  2111. goto raise;
  2112. switch(tcb->state) {
  2113. case Syn_received:
  2114. if(!seq_within(seg.ack, tcb->snd.una+1, tcb->snd.nxt)){
  2115. sndrst(tcp, source, dest, length, &seg, version,
  2116. "bad seq in Syn_received");
  2117. goto raise;
  2118. }
  2119. update(s, &seg);
  2120. tcpsetstate(s, Established);
  2121. case Established:
  2122. case Close_wait:
  2123. update(s, &seg);
  2124. break;
  2125. case Finwait1:
  2126. update(s, &seg);
  2127. if(qlen(s->wq)+tcb->flgcnt == 0){
  2128. tcphalt(tpriv, &tcb->rtt_timer);
  2129. tcphalt(tpriv, &tcb->acktimer);
  2130. tcpsetkacounter(tcb);
  2131. tcb->time = NOW;
  2132. tcpsetstate(s, Finwait2);
  2133. tcb->katimer.start = MSL2 * (1000 / MSPTICK);
  2134. tcpgo(tpriv, &tcb->katimer);
  2135. }
  2136. break;
  2137. case Finwait2:
  2138. update(s, &seg);
  2139. break;
  2140. case Closing:
  2141. update(s, &seg);
  2142. if(qlen(s->wq)+tcb->flgcnt == 0) {
  2143. tcphalt(tpriv, &tcb->rtt_timer);
  2144. tcphalt(tpriv, &tcb->acktimer);
  2145. tcphalt(tpriv, &tcb->katimer);
  2146. tcpsetstate(s, Time_wait);
  2147. tcb->timer.start = MSL2*(1000 / MSPTICK);
  2148. tcpgo(tpriv, &tcb->timer);
  2149. }
  2150. break;
  2151. case Last_ack:
  2152. update(s, &seg);
  2153. if(qlen(s->wq)+tcb->flgcnt == 0) {
  2154. localclose(s, nil);
  2155. goto raise;
  2156. }
  2157. case Time_wait:
  2158. tcb->flags |= FORCE;
  2159. if(tcb->timer.state != TcptimerON)
  2160. tcpgo(tpriv, &tcb->timer);
  2161. }
  2162. if((seg.flags&URG) && seg.urg) {
  2163. if(seq_gt(seg.urg + seg.seq, tcb->rcv.urg)) {
  2164. tcb->rcv.urg = seg.urg + seg.seq;
  2165. pullblock(&bp, seg.urg);
  2166. }
  2167. }
  2168. else
  2169. if(seq_gt(tcb->rcv.nxt, tcb->rcv.urg))
  2170. tcb->rcv.urg = tcb->rcv.nxt;
  2171. if(length == 0) {
  2172. if(bp != nil)
  2173. freeblist(bp);
  2174. }
  2175. else {
  2176. switch(tcb->state){
  2177. default:
  2178. /* Ignore segment text */
  2179. if(bp != nil)
  2180. freeblist(bp);
  2181. break;
  2182. case Syn_received:
  2183. case Established:
  2184. case Finwait1:
  2185. /* If we still have some data place on
  2186. * receive queue
  2187. */
  2188. if(bp) {
  2189. bp = packblock(bp);
  2190. if(bp == nil)
  2191. panic("tcp packblock");
  2192. qpassnolim(s->rq, bp);
  2193. bp = nil;
  2194. }
  2195. tcb->rcv.nxt += length;
  2196. /*
  2197. * turn on the acktimer if there's something
  2198. * to ack
  2199. */
  2200. if(tcb->acktimer.state != TcptimerON)
  2201. tcpgo(tpriv, &tcb->acktimer);
  2202. break;
  2203. case Finwait2:
  2204. /* no process to read the data, send a reset */
  2205. if(bp != nil)
  2206. freeblist(bp);
  2207. sndrst(tcp, source, dest, length, &seg, version,
  2208. "send to Finwait2");
  2209. qunlock(&s->ql);
  2210. poperror();
  2211. return;
  2212. }
  2213. }
  2214. if(seg.flags & FIN) {
  2215. tcb->flags |= FORCE;
  2216. switch(tcb->state) {
  2217. case Syn_received:
  2218. case Established:
  2219. tcb->rcv.nxt++;
  2220. tcpsetstate(s, Close_wait);
  2221. break;
  2222. case Finwait1:
  2223. tcb->rcv.nxt++;
  2224. if(qlen(s->wq)+tcb->flgcnt == 0) {
  2225. tcphalt(tpriv, &tcb->rtt_timer);
  2226. tcphalt(tpriv, &tcb->acktimer);
  2227. tcphalt(tpriv, &tcb->katimer);
  2228. tcpsetstate(s, Time_wait);
  2229. tcb->timer.start = MSL2*(1000/MSPTICK);
  2230. tcpgo(tpriv, &tcb->timer);
  2231. }
  2232. else
  2233. tcpsetstate(s, Closing);
  2234. break;
  2235. case Finwait2:
  2236. tcb->rcv.nxt++;
  2237. tcphalt(tpriv, &tcb->rtt_timer);
  2238. tcphalt(tpriv, &tcb->acktimer);
  2239. tcphalt(tpriv, &tcb->katimer);
  2240. tcpsetstate(s, Time_wait);
  2241. tcb->timer.start = MSL2 * (1000/MSPTICK);
  2242. tcpgo(tpriv, &tcb->timer);
  2243. break;
  2244. case Close_wait:
  2245. case Closing:
  2246. case Last_ack:
  2247. break;
  2248. case Time_wait:
  2249. tcpgo(tpriv, &tcb->timer);
  2250. break;
  2251. }
  2252. }
  2253. /*
  2254. * get next adjacent segment from the resequence queue.
  2255. * dump/trim any overlapping segments
  2256. */
  2257. for(;;) {
  2258. if(tcb->reseq == nil)
  2259. goto output;
  2260. if(seq_ge(tcb->rcv.nxt, tcb->reseq->seg.seq) == 0)
  2261. goto output;
  2262. getreseq(tcb, &seg, &bp, &length);
  2263. tcprcvwin(s);
  2264. if(tcptrim(tcb, &seg, &bp, &length) == 0){
  2265. tcb->flags |= FORCE;
  2266. break;
  2267. }
  2268. }
  2269. }
  2270. output:
  2271. tcpoutput(s);
  2272. qunlock(&s->ql);
  2273. poperror();
  2274. return;
  2275. raise:
  2276. qunlock(&s->ql);
  2277. poperror();
  2278. freeblist(bp);
  2279. tcpkick(s);
  2280. }
  2281. /*
  2282. * always enters and exits with the s locked. We drop
  2283. * the lock to ipoput the packet so some care has to be
  2284. * taken by callers.
  2285. */
  2286. static void
  2287. tcpoutput(Conv *s)
  2288. {
  2289. Tcp seg;
  2290. uint msgs;
  2291. Tcpctl *tcb;
  2292. Block *hbp, *bp;
  2293. int sndcnt;
  2294. uint32_t ssize, dsize, sent;
  2295. Fs *f;
  2296. Tcppriv *tpriv;
  2297. uint8_t version;
  2298. f = s->p->f;
  2299. tpriv = s->p->priv;
  2300. version = s->ipversion;
  2301. tcb = (Tcpctl*)s->ptcl;
  2302. /* force ack every 2*mss */
  2303. if((tcb->flags & FORCE) == 0 &&
  2304. tcb->rcv.nxt - tcb->rcv.ackptr >= 2*tcb->mss){
  2305. tpriv->stats[Delayack]++;
  2306. tcb->flags |= FORCE;
  2307. }
  2308. /* force ack if window opening */
  2309. if((tcb->flags & FORCE) == 0){
  2310. tcprcvwin(s);
  2311. if((int)(tcb->rcv.wptr - tcb->rcv.wsnt) >= 2*tcb->mss){
  2312. tpriv->stats[Wopenack]++;
  2313. tcb->flags |= FORCE;
  2314. }
  2315. }
  2316. for(msgs = 0; msgs < 100; msgs++) {
  2317. switch(tcb->state) {
  2318. case Listen:
  2319. case Closed:
  2320. case Finwait2:
  2321. return;
  2322. }
  2323. /* Don't send anything else until our SYN has been acked */
  2324. if(tcb->snd.ptr != tcb->iss && (tcb->flags & SYNACK) == 0)
  2325. break;
  2326. /* force an ack when a window has opened up */
  2327. tcprcvwin(s);
  2328. if(tcb->rcv.blocked && tcb->rcv.wnd > 0){
  2329. tcb->rcv.blocked = 0;
  2330. tcb->flags |= FORCE;
  2331. }
  2332. sndcnt = qlen(s->wq)+tcb->flgcnt;
  2333. sent = tcb->snd.ptr - tcb->snd.una;
  2334. ssize = sndcnt;
  2335. if(tcb->snd.wnd == 0){
  2336. /* zero window probe */
  2337. if(sent > 0 && !(tcb->flags & FORCE))
  2338. break; /* already probing, rto re-probes */
  2339. if(ssize < sent)
  2340. ssize = 0;
  2341. else{
  2342. ssize -= sent;
  2343. if(ssize > 0)
  2344. ssize = 1;
  2345. }
  2346. } else {
  2347. /* calculate usable segment size */
  2348. if(ssize > tcb->cwind)
  2349. ssize = tcb->cwind;
  2350. if(ssize > tcb->snd.wnd)
  2351. ssize = tcb->snd.wnd;
  2352. if(ssize < sent)
  2353. ssize = 0;
  2354. else {
  2355. ssize -= sent;
  2356. if(ssize > tcb->mss)
  2357. ssize = tcb->mss;
  2358. }
  2359. }
  2360. dsize = ssize;
  2361. seg.urg = 0;
  2362. if(!(tcb->flags & FORCE))
  2363. if(ssize == 0 ||
  2364. (ssize < tcb->mss && tcb->snd.nxt == tcb->snd.ptr &&
  2365. sent > TCPREXMTTHRESH * tcb->mss))
  2366. break;
  2367. tcb->flags &= ~FORCE;
  2368. /* By default we will generate an ack */
  2369. tcphalt(tpriv, &tcb->acktimer);
  2370. seg.source = s->lport;
  2371. seg.dest = s->rport;
  2372. seg.flags = ACK;
  2373. seg.mss = 0;
  2374. seg.ws = 0;
  2375. seg.update = 0;
  2376. switch(tcb->state){
  2377. case Syn_sent:
  2378. seg.flags = 0;
  2379. if(tcb->snd.ptr == tcb->iss){
  2380. seg.flags |= SYN;
  2381. dsize--;
  2382. seg.mss = tcb->mss;
  2383. seg.ws = tcb->scale;
  2384. }
  2385. break;
  2386. case Syn_received:
  2387. /*
  2388. * don't send any data with a SYN/ACK packet
  2389. * because Linux rejects the packet in its
  2390. * attempt to solve the SYN attack problem
  2391. */
  2392. if(tcb->snd.ptr == tcb->iss){
  2393. seg.flags |= SYN;
  2394. dsize = 0;
  2395. ssize = 1;
  2396. seg.mss = tcb->mss;
  2397. seg.ws = tcb->scale;
  2398. }
  2399. break;
  2400. }
  2401. seg.seq = tcb->snd.ptr;
  2402. seg.ack = tcb->rcv.nxt;
  2403. seg.wnd = tcb->rcv.wnd;
  2404. /* Pull out data to send */
  2405. bp = nil;
  2406. if(dsize != 0) {
  2407. bp = qcopy(s->wq, dsize, sent);
  2408. if(BLEN(bp) != dsize) {
  2409. seg.flags |= FIN;
  2410. dsize--;
  2411. }
  2412. }
  2413. if(sent+dsize == sndcnt && dsize)
  2414. seg.flags |= PSH;
  2415. tcb->snd.ptr += ssize;
  2416. /* Pull up the send pointer so we can accept acks
  2417. * for this window
  2418. */
  2419. if(seq_gt(tcb->snd.ptr,tcb->snd.nxt))
  2420. tcb->snd.nxt = tcb->snd.ptr;
  2421. /* Build header, link data and compute cksum */
  2422. switch(version){
  2423. case V4:
  2424. tcb->protohdr.tcp4hdr.vihl = IP_VER4;
  2425. hbp = htontcp4(&seg, bp, &tcb->protohdr.tcp4hdr, tcb);
  2426. if(hbp == nil) {
  2427. freeblist(bp);
  2428. return;
  2429. }
  2430. break;
  2431. case V6:
  2432. tcb->protohdr.tcp6hdr.vcf[0] = IP_VER6;
  2433. hbp = htontcp6(&seg, bp, &tcb->protohdr.tcp6hdr, tcb);
  2434. if(hbp == nil) {
  2435. freeblist(bp);
  2436. return;
  2437. }
  2438. break;
  2439. default:
  2440. hbp = nil; /* to suppress a warning */
  2441. panic("tcpoutput: version %d", version);
  2442. }
  2443. /* Start the transmission timers if there is new data and we
  2444. * expect acknowledges
  2445. */
  2446. if(ssize != 0){
  2447. if(tcb->timer.state != TcptimerON){
  2448. tcb->time = NOW;
  2449. tcb->timeuna = tcb->snd.una;
  2450. tcpgo(tpriv, &tcb->timer);
  2451. }
  2452. /* If round trip timer isn't running, start it.
  2453. * measure the longest packet only in case the
  2454. * transmission time dominates RTT
  2455. */
  2456. if(tcb->snd.retransmit == 0)
  2457. if(tcb->rtt_timer.state != TcptimerON)
  2458. if(ssize == tcb->mss) {
  2459. tcpgo(tpriv, &tcb->rtt_timer);
  2460. tcb->rttseq = tcb->snd.ptr;
  2461. }
  2462. }
  2463. tpriv->stats[OutSegs]++;
  2464. if(tcb->snd.retransmit)
  2465. tpriv->stats[RetransSegsSent]++;
  2466. tcb->rcv.ackptr = seg.ack;
  2467. tcb->rcv.wsnt = tcb->rcv.wptr;
  2468. /* put off the next keep alive */
  2469. tcpgo(tpriv, &tcb->katimer);
  2470. switch(version){
  2471. case V4:
  2472. if(ipoput4(f, hbp, 0, s->ttl, s->tos, s) < 0){
  2473. /* a negative return means no route */
  2474. localclose(s, "no route");
  2475. }
  2476. break;
  2477. case V6:
  2478. if(ipoput6(f, hbp, 0, s->ttl, s->tos, s) < 0){
  2479. /* a negative return means no route */
  2480. localclose(s, "no route");
  2481. }
  2482. break;
  2483. default:
  2484. panic("tcpoutput2: version %d", version);
  2485. }
  2486. if((msgs%4) == 3){
  2487. qunlock(&s->ql);
  2488. qlock(&s->ql);
  2489. }
  2490. }
  2491. }
  2492. /*
  2493. * the BSD convention (hack?) for keep alives. resend last uint8_t acked.
  2494. */
  2495. static void
  2496. tcpsendka(Conv *s)
  2497. {
  2498. Tcp seg;
  2499. Tcpctl *tcb;
  2500. Block *hbp,*dbp;
  2501. tcb = (Tcpctl*)s->ptcl;
  2502. dbp = nil;
  2503. memset(&seg, 0, sizeof seg);
  2504. seg.urg = 0;
  2505. seg.source = s->lport;
  2506. seg.dest = s->rport;
  2507. seg.flags = ACK|PSH;
  2508. seg.mss = 0;
  2509. seg.ws = 0;
  2510. if(tcpporthogdefense)
  2511. seg.seq = tcb->snd.una-(1<<30)-nrand(1<<20);
  2512. else
  2513. seg.seq = tcb->snd.una-1;
  2514. seg.ack = tcb->rcv.nxt;
  2515. tcb->rcv.ackptr = seg.ack;
  2516. tcprcvwin(s);
  2517. seg.wnd = tcb->rcv.wnd;
  2518. if(tcb->state == Finwait2){
  2519. seg.flags |= FIN;
  2520. } else {
  2521. dbp = allocb(1);
  2522. dbp->wp++;
  2523. }
  2524. if(isv4(s->raddr)) {
  2525. /* Build header, link data and compute cksum */
  2526. tcb->protohdr.tcp4hdr.vihl = IP_VER4;
  2527. hbp = htontcp4(&seg, dbp, &tcb->protohdr.tcp4hdr, tcb);
  2528. if(hbp == nil) {
  2529. freeblist(dbp);
  2530. return;
  2531. }
  2532. ipoput4(s->p->f, hbp, 0, s->ttl, s->tos, s);
  2533. }
  2534. else {
  2535. /* Build header, link data and compute cksum */
  2536. tcb->protohdr.tcp6hdr.vcf[0] = IP_VER6;
  2537. hbp = htontcp6(&seg, dbp, &tcb->protohdr.tcp6hdr, tcb);
  2538. if(hbp == nil) {
  2539. freeblist(dbp);
  2540. return;
  2541. }
  2542. ipoput6(s->p->f, hbp, 0, s->ttl, s->tos, s);
  2543. }
  2544. }
  2545. /*
  2546. * set connection to time out after 12 minutes
  2547. */
  2548. static void
  2549. tcpsetkacounter(Tcpctl *tcb)
  2550. {
  2551. tcb->kacounter = (12 * 60 * 1000) / (tcb->katimer.start*MSPTICK);
  2552. if(tcb->kacounter < 3)
  2553. tcb->kacounter = 3;
  2554. }
  2555. /*
  2556. * if we've timed out, close the connection
  2557. * otherwise, send a keepalive and restart the timer
  2558. */
  2559. static void
  2560. tcpkeepalive(void *v)
  2561. {
  2562. Proc *up = externup();
  2563. Tcpctl *tcb;
  2564. Conv *s;
  2565. s = v;
  2566. tcb = (Tcpctl*)s->ptcl;
  2567. if(waserror()){
  2568. qunlock(&s->ql);
  2569. nexterror();
  2570. }
  2571. qlock(&s->ql);
  2572. if(tcb->state != Closed){
  2573. if(--(tcb->kacounter) <= 0) {
  2574. localclose(s, Etimedout);
  2575. } else {
  2576. tcpsendka(s);
  2577. tcpgo(s->p->priv, &tcb->katimer);
  2578. }
  2579. }
  2580. qunlock(&s->ql);
  2581. poperror();
  2582. }
  2583. /*
  2584. * start keepalive timer
  2585. */
  2586. static char*
  2587. tcpstartka(Conv *s, char **f, int n)
  2588. {
  2589. Tcpctl *tcb;
  2590. int x;
  2591. tcb = (Tcpctl*)s->ptcl;
  2592. if(tcb->state != Established)
  2593. return "connection must be in Establised state";
  2594. if(n > 1){
  2595. x = atoi(f[1]);
  2596. if(x >= MSPTICK)
  2597. tcb->katimer.start = x/MSPTICK;
  2598. }
  2599. tcpsetkacounter(tcb);
  2600. tcpgo(s->p->priv, &tcb->katimer);
  2601. return nil;
  2602. }
  2603. /*
  2604. * turn checksums on/off
  2605. */
  2606. static char*
  2607. tcpsetchecksum(Conv *s, char **f, int i)
  2608. {
  2609. Tcpctl *tcb;
  2610. tcb = (Tcpctl*)s->ptcl;
  2611. tcb->nochecksum = !atoi(f[1]);
  2612. return nil;
  2613. }
  2614. /*
  2615. * retransmit (at most) one segment at snd.una.
  2616. * preserve cwind & snd.ptr
  2617. */
  2618. static void
  2619. tcprxmit(Conv *s)
  2620. {
  2621. Tcpctl *tcb;
  2622. Tcppriv *tpriv;
  2623. uint32_t tcwind, tptr;
  2624. tcb = (Tcpctl*)s->ptcl;
  2625. tcb->flags |= RETRAN|FORCE;
  2626. tptr = tcb->snd.ptr;
  2627. tcwind = tcb->cwind;
  2628. tcb->snd.ptr = tcb->snd.una;
  2629. tcb->cwind = tcb->mss;
  2630. tcb->snd.retransmit = 1;
  2631. tcpoutput(s);
  2632. tcb->snd.retransmit = 0;
  2633. tcb->cwind = tcwind;
  2634. tcb->snd.ptr = tptr;
  2635. tpriv = s->p->priv;
  2636. tpriv->stats[RetransSegs]++;
  2637. }
  2638. /*
  2639. * TODO: RFC 4138 F-RTO
  2640. */
  2641. static void
  2642. tcptimeout(void *arg)
  2643. {
  2644. Proc *up = externup();
  2645. Conv *s;
  2646. Tcpctl *tcb;
  2647. int maxback;
  2648. Tcppriv *tpriv;
  2649. s = (Conv*)arg;
  2650. tpriv = s->p->priv;
  2651. tcb = (Tcpctl*)s->ptcl;
  2652. if(waserror()){
  2653. qunlock(&s->ql);
  2654. nexterror();
  2655. }
  2656. qlock(&s->ql);
  2657. switch(tcb->state){
  2658. default:
  2659. tcb->backoff++;
  2660. if(tcb->state == Syn_sent)
  2661. maxback = MAXBACKMS/2;
  2662. else
  2663. maxback = MAXBACKMS;
  2664. tcb->backedoff += tcb->timer.start * MSPTICK;
  2665. if(tcb->backedoff >= maxback) {
  2666. localclose(s, Etimedout);
  2667. break;
  2668. }
  2669. netlog(s->p->f, Logtcprxmt, "rxm %d/%d %ldms %lu rto %d %lu %s\n",
  2670. tcb->srtt, tcb->mdev, NOW - tcb->time,
  2671. tcb->snd.una - tcb->timeuna, tcb->snd.rto, tcb->snd.ptr,
  2672. tcpstates[s->state]);
  2673. tcpsettimer(tcb);
  2674. if(tcb->snd.rto == 0)
  2675. tcpcongestion(tcb);
  2676. tcprxmit(s);
  2677. tcb->snd.ptr = tcb->snd.una;
  2678. tcb->cwind = tcb->mss;
  2679. tcb->snd.rto = 1;
  2680. tpriv->stats[RetransTimeouts]++;
  2681. if(tcb->snd.recovery){
  2682. tcb->snd.dupacks = 0; /* reno rto */
  2683. tcb->snd.recovery = 0;
  2684. tpriv->stats[RecoveryRTO]++;
  2685. tcb->snd.rxt = tcb->snd.nxt;
  2686. netlog(s->p->f, Logtcpwin,
  2687. "rto recovery rxt @%lu\n", tcb->snd.nxt);
  2688. }
  2689. tcb->abcbytes = 0;
  2690. break;
  2691. case Time_wait:
  2692. localclose(s, nil);
  2693. break;
  2694. case Closed:
  2695. break;
  2696. }
  2697. qunlock(&s->ql);
  2698. poperror();
  2699. }
  2700. static int
  2701. inwindow(Tcpctl *tcb, int seq)
  2702. {
  2703. return seq_within(seq, tcb->rcv.nxt, tcb->rcv.nxt+tcb->rcv.wnd-1);
  2704. }
  2705. /*
  2706. * set up state for a received SYN (or SYN ACK) packet
  2707. */
  2708. static void
  2709. procsyn(Conv *s, Tcp *seg)
  2710. {
  2711. Tcpctl *tcb;
  2712. Tcppriv *tpriv;
  2713. tcb = (Tcpctl*)s->ptcl;
  2714. tcb->flags |= FORCE;
  2715. tcb->rcv.nxt = seg->seq + 1;
  2716. tcb->rcv.wptr = tcb->rcv.nxt;
  2717. tcb->rcv.wsnt = 0;
  2718. tcb->rcv.urg = tcb->rcv.nxt;
  2719. tcb->irs = seg->seq;
  2720. /* our sending max segment size cannot be bigger than what he asked for */
  2721. if(seg->mss != 0 && seg->mss < tcb->mss) {
  2722. tcb->mss = seg->mss;
  2723. tpriv = s->p->priv;
  2724. tpriv->stats[Mss] = tcb->mss;
  2725. }
  2726. tcb->snd.wnd = seg->wnd;
  2727. initialwindow(tcb);
  2728. }
  2729. static int
  2730. dumpreseq(Tcpctl *tcb)
  2731. {
  2732. Reseq *r, *next;
  2733. for(r = tcb->reseq; r != nil; r = next){
  2734. next = r->next;
  2735. freeblist(r->bp);
  2736. free(r);
  2737. }
  2738. tcb->reseq = nil;
  2739. tcb->nreseq = 0;
  2740. tcb->reseqlen = 0;
  2741. return -1;
  2742. }
  2743. static void
  2744. logreseq(Fs *f, Reseq *r, uint32_t n)
  2745. {
  2746. char *s;
  2747. for(; r != nil; r = r->next){
  2748. s = nil;
  2749. if(r->next == nil && r->seg.seq != n)
  2750. s = "hole/end";
  2751. else if(r->next == nil)
  2752. s = "end";
  2753. else if(r->seg.seq != n)
  2754. s = "hole";
  2755. if(s != nil)
  2756. netlog(f, Logtcp, "%s %lu-%lu (%ld) %#x\n", s,
  2757. n, r->seg.seq, r->seg.seq - n, r->seg.flags);
  2758. n = r->seg.seq + r->seg.len;
  2759. }
  2760. }
  2761. static int
  2762. addreseq(Fs *f, Tcpctl *tcb, Tcppriv *tpriv, Tcp *seg, Block *bp, uint16_t length)
  2763. {
  2764. Reseq *rp, **rr;
  2765. int qmax;
  2766. rp = malloc(sizeof *rp);
  2767. if(rp == nil){
  2768. freeblist(bp); /* bp always consumed by addreseq */
  2769. return 0;
  2770. }
  2771. rp->seg = *seg;
  2772. rp->bp = bp;
  2773. rp->length = length;
  2774. tcb->reseqlen += length;
  2775. tcb->nreseq++;
  2776. /* Place on reassembly list sorting by starting seq number */
  2777. for(rr = &tcb->reseq; ; rr = &(*rr)->next)
  2778. if(*rr == nil || seq_lt(seg->seq, (*rr)->seg.seq)){
  2779. rp->next = *rr;
  2780. *rr = rp;
  2781. tpriv->stats[Resequenced]++;
  2782. if(rp->next != nil)
  2783. tpriv->stats[OutOfOrder]++;
  2784. break;
  2785. }
  2786. qmax = tcb->window;
  2787. if(tcb->reseqlen > qmax){
  2788. netlog(f, Logtcp, "tcp: reseq: queue > window: %d > %d; %d packets\n",
  2789. tcb->reseqlen, qmax, tcb->nreseq);
  2790. logreseq(f, tcb->reseq, tcb->rcv.nxt);
  2791. tpriv->stats[ReseqBytelim]++;
  2792. return dumpreseq(tcb);
  2793. }
  2794. qmax = tcb->window / tcb->mss; /* ~190 for qscale=2, 390 for qscale=3 */
  2795. if(tcb->nreseq > qmax){
  2796. netlog(f, Logtcp, "resequence queue > packets: %d %d; %d bytes\n",
  2797. tcb->nreseq, qmax, tcb->reseqlen);
  2798. logreseq(f, tcb->reseq, tcb->rcv.nxt);
  2799. tpriv->stats[ReseqPktlim]++;
  2800. return dumpreseq(tcb);
  2801. }
  2802. return 0;
  2803. }
  2804. static void
  2805. getreseq(Tcpctl *tcb, Tcp *seg, Block **bp, uint16_t *length)
  2806. {
  2807. Reseq *rp;
  2808. rp = tcb->reseq;
  2809. if(rp == nil)
  2810. return;
  2811. tcb->reseq = rp->next;
  2812. *seg = rp->seg;
  2813. *bp = rp->bp;
  2814. *length = rp->length;
  2815. tcb->nreseq--;
  2816. tcb->reseqlen -= rp->length;
  2817. free(rp);
  2818. }
  2819. static int
  2820. tcptrim(Tcpctl *tcb, Tcp *seg, Block **bp, uint16_t *length)
  2821. {
  2822. uint16_t len;
  2823. uint8_t accept;
  2824. int dupcnt, excess;
  2825. accept = 0;
  2826. len = *length;
  2827. if(seg->flags & SYN)
  2828. len++;
  2829. if(seg->flags & FIN)
  2830. len++;
  2831. if(tcb->rcv.wnd == 0) {
  2832. if(len == 0 && seg->seq == tcb->rcv.nxt)
  2833. return 0;
  2834. }
  2835. else {
  2836. /* Some part of the segment should be in the window */
  2837. if(inwindow(tcb,seg->seq))
  2838. accept++;
  2839. else
  2840. if(len != 0) {
  2841. if(inwindow(tcb, seg->seq+len-1) ||
  2842. seq_within(tcb->rcv.nxt, seg->seq,seg->seq+len-1))
  2843. accept++;
  2844. }
  2845. }
  2846. if(!accept) {
  2847. freeblist(*bp);
  2848. return -1;
  2849. }
  2850. dupcnt = tcb->rcv.nxt - seg->seq;
  2851. if(dupcnt > 0){
  2852. tcb->rerecv += dupcnt;
  2853. if(seg->flags & SYN){
  2854. seg->flags &= ~SYN;
  2855. seg->seq++;
  2856. if(seg->urg > 1)
  2857. seg->urg--;
  2858. else
  2859. seg->flags &= ~URG;
  2860. dupcnt--;
  2861. }
  2862. if(dupcnt > 0){
  2863. pullblock(bp, (uint16_t)dupcnt);
  2864. seg->seq += dupcnt;
  2865. *length -= dupcnt;
  2866. if(seg->urg > dupcnt)
  2867. seg->urg -= dupcnt;
  2868. else {
  2869. seg->flags &= ~URG;
  2870. seg->urg = 0;
  2871. }
  2872. }
  2873. }
  2874. excess = seg->seq + *length - (tcb->rcv.nxt + tcb->rcv.wnd);
  2875. if(excess > 0) {
  2876. tcb->rerecv += excess;
  2877. *length -= excess;
  2878. *bp = trimblock(*bp, 0, *length);
  2879. if(*bp == nil)
  2880. panic("presotto is a boofhead");
  2881. seg->flags &= ~FIN;
  2882. }
  2883. return 0;
  2884. }
  2885. static void
  2886. tcpadvise(Proto *tcp, Block *bp, char *msg)
  2887. {
  2888. Tcp4hdr *h4;
  2889. Tcp6hdr *h6;
  2890. Tcpctl *tcb;
  2891. uint8_t source[IPaddrlen];
  2892. uint8_t dest[IPaddrlen];
  2893. uint16_t psource, pdest;
  2894. Conv *s, **p;
  2895. h4 = (Tcp4hdr*)(bp->rp);
  2896. h6 = (Tcp6hdr*)(bp->rp);
  2897. if((h4->vihl&0xF0)==IP_VER4) {
  2898. v4tov6(dest, h4->tcpdst);
  2899. v4tov6(source, h4->tcpsrc);
  2900. psource = nhgets(h4->tcpsport);
  2901. pdest = nhgets(h4->tcpdport);
  2902. }
  2903. else {
  2904. ipmove(dest, h6->tcpdst);
  2905. ipmove(source, h6->tcpsrc);
  2906. psource = nhgets(h6->tcpsport);
  2907. pdest = nhgets(h6->tcpdport);
  2908. }
  2909. /* Look for a connection */
  2910. qlock(&tcp->ql);
  2911. for(p = tcp->conv; *p; p++) {
  2912. s = *p;
  2913. tcb = (Tcpctl*)s->ptcl;
  2914. if(s->rport == pdest)
  2915. if(s->lport == psource)
  2916. if(tcb->state != Closed)
  2917. if(ipcmp(s->raddr, dest) == 0)
  2918. if(ipcmp(s->laddr, source) == 0){
  2919. qlock(&s->ql);
  2920. qunlock(&tcp->ql);
  2921. switch(tcb->state){
  2922. case Syn_sent:
  2923. localclose(s, msg);
  2924. break;
  2925. }
  2926. qunlock(&s->ql);
  2927. freeblist(bp);
  2928. return;
  2929. }
  2930. }
  2931. qunlock(&tcp->ql);
  2932. freeblist(bp);
  2933. }
  2934. static char*
  2935. tcpporthogdefensectl(char *val)
  2936. {
  2937. if(strcmp(val, "on") == 0)
  2938. tcpporthogdefense = 1;
  2939. else if(strcmp(val, "off") == 0)
  2940. tcpporthogdefense = 0;
  2941. else
  2942. return "unknown value for tcpporthogdefense";
  2943. return nil;
  2944. }
  2945. /* called with c qlocked */
  2946. static char*
  2947. tcpctl(Conv* c, char** f, int n)
  2948. {
  2949. if(n == 1 && strcmp(f[0], "hangup") == 0)
  2950. return tcphangup(c);
  2951. if(n >= 1 && strcmp(f[0], "keepalive") == 0)
  2952. return tcpstartka(c, f, n);
  2953. if(n >= 1 && strcmp(f[0], "checksum") == 0)
  2954. return tcpsetchecksum(c, f, n);
  2955. if(n >= 1 && strcmp(f[0], "tcpporthogdefense") == 0)
  2956. return tcpporthogdefensectl(f[1]);
  2957. return "unknown control request";
  2958. }
  2959. static int
  2960. tcpstats(Proto *tcp, char *buf, int len)
  2961. {
  2962. Tcppriv *priv;
  2963. char *p, *e;
  2964. int i;
  2965. priv = tcp->priv;
  2966. p = buf;
  2967. e = p+len;
  2968. for(i = 0; i < Nstats; i++)
  2969. p = seprint(p, e, "%s: %llu\n", statnames[i], priv->stats[i]);
  2970. return p - buf;
  2971. }
  2972. /*
  2973. * garbage collect any stale conversations:
  2974. * - SYN received but no SYN-ACK after 5 seconds (could be the SYN attack)
  2975. * - Finwait2 after 5 minutes
  2976. *
  2977. * this is called whenever we run out of channels. Both checks are
  2978. * of questionable validity so we try to use them only when we're
  2979. * up against the wall.
  2980. */
  2981. static int
  2982. tcpgc(Proto *tcp)
  2983. {
  2984. Conv *c, **pp, **ep;
  2985. int n;
  2986. Tcpctl *tcb;
  2987. n = 0;
  2988. ep = &tcp->conv[tcp->nc];
  2989. for(pp = tcp->conv; pp < ep; pp++) {
  2990. c = *pp;
  2991. if(c == nil)
  2992. break;
  2993. if(!canqlock(&c->ql))
  2994. continue;
  2995. tcb = (Tcpctl*)c->ptcl;
  2996. switch(tcb->state){
  2997. case Syn_received:
  2998. if(NOW - tcb->time > 5000){
  2999. localclose(c, Etimedout);
  3000. n++;
  3001. }
  3002. break;
  3003. case Finwait2:
  3004. if(NOW - tcb->time > 5*60*1000){
  3005. localclose(c, Etimedout);
  3006. n++;
  3007. }
  3008. break;
  3009. }
  3010. qunlock(&c->ql);
  3011. }
  3012. return n;
  3013. }
  3014. static void
  3015. tcpsettimer(Tcpctl *tcb)
  3016. {
  3017. int x;
  3018. /* round trip dependency */
  3019. x = backoff(tcb->backoff) *
  3020. (tcb->mdev + (tcb->srtt>>LOGAGAIN) + MSPTICK) / MSPTICK;
  3021. /* bounded twixt 0.3 and 64 seconds */
  3022. if(x < 300/MSPTICK)
  3023. x = 300/MSPTICK;
  3024. else if(x > (64000/MSPTICK))
  3025. x = 64000/MSPTICK;
  3026. tcb->timer.start = x;
  3027. }
  3028. void
  3029. tcpinit(Fs *fs)
  3030. {
  3031. Proto *tcp;
  3032. Tcppriv *tpriv;
  3033. tcp = smalloc(sizeof(Proto));
  3034. tpriv = tcp->priv = smalloc(sizeof(Tcppriv));
  3035. tcp->name = "tcp";
  3036. tcp->connect = tcpconnect;
  3037. tcp->announce = tcpannounce;
  3038. tcp->ctl = tcpctl;
  3039. tcp->state = tcpstate;
  3040. tcp->create = tcpcreate;
  3041. tcp->close = tcpclose;
  3042. tcp->rcv = tcpiput;
  3043. tcp->advise = tcpadvise;
  3044. tcp->stats = tcpstats;
  3045. tcp->inuse = tcpinuse;
  3046. tcp->gc = tcpgc;
  3047. tcp->ipproto = IP_TCPPROTO;
  3048. tcp->nc = scalednconv();
  3049. tcp->ptclsize = sizeof(Tcpctl);
  3050. tpriv->stats[MaxConn] = tcp->nc;
  3051. Fsproto(fs, tcp);
  3052. }
  3053. static void
  3054. tcpsetscale(Conv *s, Tcpctl *tcb, uint16_t rcvscale, uint16_t sndscale)
  3055. {
  3056. /*
  3057. * guess at reasonable queue sizes. there's no current way
  3058. * to know how many nic receive buffers we can safely tie up in the
  3059. * tcp stack, and we don't adjust our queues to maximize throughput
  3060. * and minimize bufferbloat. n.b. the offer (rcvscale) needs to be
  3061. * respected, but we still control our own buffer commitment by
  3062. * keeping a seperate qscale.
  3063. */
  3064. tcb->rcv.scale = rcvscale & 0xff;
  3065. tcb->snd.scale = sndscale & 0xff;
  3066. tcb->qscale = rcvscale & 0xff;
  3067. if(rcvscale > Maxqscale)
  3068. tcb->qscale = Maxqscale;
  3069. if(rcvscale != tcb->rcv.scale)
  3070. netlog(s->p->f, Logtcp, "tcpsetscale: window %lu "
  3071. "qlen %d >> window %u lport %d\n",
  3072. tcb->window, qlen(s->rq), QMAX<<tcb->qscale, s->lport);
  3073. tcb->window = QMAX << tcb->qscale;
  3074. tcb->ssthresh = tcb->window;
  3075. /*
  3076. * it's important to set wq large enough to cover the full
  3077. * bandwidth-delay product. it's possible to be in loss
  3078. * recovery with a big window, and we need to keep sending
  3079. * into the inflated window. the difference can be huge
  3080. * for even modest (70ms) ping times.
  3081. */
  3082. qsetlimit(s->rq, tcb->window);
  3083. qsetlimit(s->wq, tcb->window);
  3084. tcprcvwin(s);
  3085. }