![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcpinput.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to tcpinput.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "../port/error.h"
7: #include "arp.h"
8: #include "../port/ipdat.h"
9:
10: int tcpdbg = 0;
11: ushort tcp_mss = DEF_MSS; /* Maximum segment size to be sent with SYN */
12: int tcp_irtt = DEF_RTT; /* Initial guess at round trip time */
13:
14: #define DPRINT if(tcpdbg) print
15: #define LPRINT if(tcpdbg) print
16:
17: char *tcpstate[] =
18: {
19: "Closed", "Listen", "Syn_sent", "Syn_received",
20: "Established", "Finwait1", "Finwait2", "Close_wait",
21: "Closing", "Last_ack", "Time_wait"
22: };
23:
24: void
25: sndrst(Ipaddr source, Ipaddr dest, ushort length, Tcp *seg)
26: {
27: Block *hbp;
28: Port tmp;
29: char rflags;
30: Tcphdr ph;
31:
32: if(seg->flags & RST)
33: return;
34:
35: hnputl(ph.tcpsrc, dest);
36: hnputl(ph.tcpdst, source);
37: ph.proto = IP_TCPPROTO;
38: hnputs(ph.tcplen, TCP_HDRSIZE);
39:
40: /* Swap port numbers */
41: tmp = seg->dest;
42: seg->dest = seg->source;
43: seg->source = tmp;
44:
45: rflags = RST;
46:
47: /* convince the other end that this reset is in band */
48: if(seg->flags & ACK) {
49: seg->seq = seg->ack;
50: seg->ack = 0;
51: }
52: else {
53: rflags |= ACK;
54: seg->ack = seg->seq;
55: seg->seq = 0;
56: if(seg->flags & SYN)
57: seg->ack++;
58: seg->ack += length;
59: if(seg->flags & FIN)
60: seg->ack++;
61: }
62: seg->flags = rflags;
63: seg->wnd = 0;
64: seg->up = 0;
65: seg->mss = 0;
66: if((hbp = htontcp(seg, 0, &ph)) == 0)
67: return;
68:
69: ipmuxoput(0, hbp);
70: }
71:
72: /*
73: * flush an incoming call; send a reset to the remote side and close the
74: * conversation
75: */
76: void
77: tcpflushincoming(Ipconv *s)
78: {
79: Tcp seg;
80: Tcpctl *tcb;
81: uchar dst[4];
82:
83: tcb = &s->tcpctl;
84: seg.source = s->pdst;
85: seg.dest = s->psrc;
86: seg.flags = ACK;
87: seg.seq = tcb->snd.ptr;
88: tcb->last_ack = tcb->rcv.nxt;
89: seg.ack = tcb->rcv.nxt;
90:
91: if(s->src == 0){
92: hnputl(dst, s->dst);
93: s->src = ipgetsrc(dst);
94: }
95: sndrst(s->dst, s->src, 0, &seg);
96: localclose(s, 0);
97: }
98:
99: static void
100: tcpmove(struct Tctl *to, struct Tctl *from)
101: {
102: memmove(to, from, sizeof(struct Tctl));
103: }
104:
105: Ipconv*
106: tcpincoming(Ipifc *ifc, Ipconv *s, Tcp *segp, Ipaddr source, Ipaddr dest)
107: {
108: Ipconv *new;
109:
110: qlock(s);
111: if(s->curlog >= s->backlog){
112: qunlock(s);
113: return 0;
114: }
115:
116: new = ipincoming(ifc, s);
117: if(new == 0){
118: qunlock(s);
119: return 0;
120: }
121:
122: s->curlog++;
123: qunlock(s);
124: new->psrc = segp->dest;
125: new->pdst = segp->source;
126: new->dst = source;
127: new->src = dest;
128: tcpmove(&new->tcpctl, &s->tcpctl);
129: new->tcpctl.flags &= ~CLONE;
130: new->tcpctl.timer.arg = new;
131: new->tcpctl.timer.state = TimerOFF;
132: new->tcpctl.acktimer.arg = new;
133: new->tcpctl.acktimer.state = TimerOFF;
134: new->newcon = s;
135:
136: wakeup(&s->listenr);
137: return new;
138: }
139:
140: void
141: tcpinput(Ipifc *ifc, Block *bp)
142: {
143: Tcp seg;
144: char tos;
145: Tcphdr *h;
146: int hdrlen;
147: Tcpctl *tcb;
148: ushort length;
149: Ipconv *spec, *gen;
150: Ipaddr source, dest;
151: Ipconv *s, **p, **etab;
152:
153: h = (Tcphdr *)(bp->rptr);
154: dest = nhgetl(h->tcpdst);
155: source = nhgetl(h->tcpsrc);
156:
157: tos = h->tos;
158: length = nhgets(h->length);
159:
160: h->Unused = 0;
161: hnputs(h->tcplen, length - (TCP_IPLEN+TCP_PHDRSIZE));
162: if(ptcl_csum(bp, TCP_EHSIZE+TCP_IPLEN, length - TCP_IPLEN)) {
163: freeb(bp);
164: return;
165: }
166:
167: if((hdrlen = ntohtcp(&seg, &bp)) < 0)
168: return;
169:
170: /* trim the packet to the size claimed by the datagram */
171: length -= (hdrlen+TCP_IPLEN+TCP_PHDRSIZE);
172: bp = btrim(bp, hdrlen+TCP_PKT, length);
173: if(bp == 0)
174: return;
175:
176: /* Look for a connection. failing that look for a listener. */
177: s = ip_conn(ifc, seg.dest, seg.source, source);
178: if(s && s->tcpctl.state == Listen)
179: s = 0; /* can't talk directly to a listener */
180:
181: if (s == 0) {
182: if(seg.flags & SYN){
183: /*
184: * dump packets with bogus flags
185: */
186: if(seg.flags & RST){
187: freeb(bp);
188: return;
189: }
190: if(seg.flags & ACK) {
191: freeb(bp);
192: sndrst(source, dest, length, &seg);
193: return;
194: }
195:
196: /*
197: * find a listener specific to this port (spec) or,
198: * failing that, a general one (gen)
199: */
200: spec = 0;
201: gen = 0;
202: etab = &ifc->conv[Nipconv];
203: for(p = ifc->conv; p < etab && *p; p++) {
204: s = *p;
205: if(s->tcpctl.state == Listen)
206: if(s->pdst == 0)
207: if(s->dst == 0) {
208: if(s->psrc == seg.dest){
209: spec = s;
210: break;
211: }
212: if(s->psrc == 0)
213: gen = s;
214: }
215: }
216: if(spec)
217: s = tcpincoming(ifc, spec, &seg, source, dest);
218: else if(gen)
219: s = tcpincoming(ifc, gen, &seg, source, dest);
220: else
221: s = 0;
222: }
223: if(s == 0){
224: freeb(bp);
225: sndrst(source, dest, length, &seg);
226: return;
227: }
228: }
229:
230: /* The rest of the input state machine is run with the control block
231: * locked and implements the state machine directly out of the RFC
232: * Out-of-band data is ignored - it was always a bad idea.
233: */
234: tcb = &s->tcpctl;
235: qlock(tcb);
236:
237: switch(tcb->state) {
238: case Closed:
239: freeb(bp);
240: sndrst(source, dest, length, &seg);
241: goto done;
242: case Listen:
243: if((seg.flags & (SYN|RST|ACK)) != SYN) {
244: /* ignore bogus packets */
245: print("packet to channel in listen state %d <- %d\n", s->psrc, s->pdst);
246: freeb(bp);
247: goto done;
248: }
249:
250: proc_syn(s, tos, &seg);
251: tcpsndsyn(tcb);
252: tcpsetstate(s, Syn_received);
253: if(length != 0 || (seg.flags & FIN))
254: break;
255: freeb(bp);
256: goto output;
257: case Syn_sent:
258: if(seg.flags & ACK) {
259: if(!seq_within(seg.ack, tcb->iss+1, tcb->snd.nxt)) {
260: freeb(bp);
261: sndrst(source, dest, length, &seg);
262: goto done;
263: }
264: }
265: if(seg.flags & RST) {
266: if(seg.flags & ACK)
267: localclose(s, Econrefused);
268: freeb(bp);
269: goto done;
270: }
271:
272: if(seg.flags & ACK)
273: if(PREC(tos) != PREC(tcb->tos)){
274: freeb(bp);
275: sndrst(source, dest, length, &seg);
276: goto done;
277: }
278:
279: if(seg.flags & SYN) {
280: proc_syn(s, tos, &seg);
281: if(seg.flags & ACK){
282: update(s, &seg);
283: tcpsetstate(s, Established);
284: }
285: else
286: tcpsetstate(s, Syn_received);
287:
288: if(length != 0 || (seg.flags & FIN))
289: break;
290:
291: freeb(bp);
292: goto output;
293: }
294: else
295: freeb(bp);
296: goto done;
297: }
298:
299: /* Cut the data to fit the receive window */
300: if(trim(tcb, &seg, &bp, &length) == -1) {
301: if(!(seg.flags & RST)) {
302: tcb->flags |= FORCE;
303: goto output;
304: }
305: goto done;
306: }
307:
308: /* Cannot accept so answer with a rst */
309: if(length)
310: if(s->readq == 0)
311: if(tcb->state == Closed) {
312: freeb(bp);
313: sndrst(source, dest, length, &seg);
314: goto done;
315: }
316:
317: /* The segment is beyond the current receive pointer so
318: * queue the data in the resequence queue
319: */
320: if(seg.seq != tcb->rcv.nxt)
321: if(length != 0 || (seg.flags & (SYN|FIN))) {
322: add_reseq(tcb, tos, &seg, bp, length);
323: tcb->flags |= FORCE;
324: goto output;
325: }
326:
327: /*
328: * keep looping till we've processed this packet plus any
329: * adjacent packets in the resequence queue
330: */
331: for(;;) {
332: if(seg.flags & RST) {
333: localclose(s, Econrefused);
334:
335: freeb(bp);
336: goto done;
337: }
338:
339: /* This tos stuff should be removed */
340: if(PREC(tos) != PREC(tcb->tos) || (seg.flags & SYN)){
341: freeb(bp);
342: sndrst(source, dest, length, &seg);
343: goto done;
344: }
345:
346: if(!(seg.flags & ACK)) {
347: freeb(bp);
348: goto done;
349: }
350:
351: switch(tcb->state) {
352: case Syn_received:
353: if(!seq_within(seg.ack, tcb->snd.una+1, tcb->snd.nxt)){
354: freeb(bp);
355: sndrst(source, dest, length, &seg);
356: goto done;
357: }
358: update(s, &seg);
359: tcpsetstate(s, Established);
360: case Established:
361: case Close_wait:
362: update(s, &seg);
363: break;
364: case Finwait1:
365: update(s, &seg);
366: if(tcb->sndcnt == 0){
367: tcb->kacounter = MAXBACKOFF;
368: tcpsetstate(s, Finwait2);
369: tcb->timer.start = MSL2 * (1000 / MSPTICK);
370: tcpgo(&tcb->timer);
371: }
372: break;
373: case Finwait2:
374: update(s, &seg);
375: break;
376: case Closing:
377: update(s, &seg);
378: if(tcb->sndcnt == 0) {
379: tcpsetstate(s, Time_wait);
380: tcb->timer.start = MSL2 * (1000 / MSPTICK);
381: tcpgo(&tcb->timer);
382: }
383: break;
384: case Last_ack:
385: update(s, &seg);
386: if(tcb->sndcnt == 0) {
387: freeb(bp);
388: localclose(s, 0);
389: goto done;
390: }
391: case Time_wait:
392: tcb->flags |= FORCE;
393: tcpgo(&tcb->timer);
394: }
395:
396: if((seg.flags&URG) && seg.up) {
397: if(seq_gt(seg.up + seg.seq, tcb->rcv.up)) {
398: tcb->rcv.up = seg.up + seg.seq;
399: pullb(&bp, seg.up);
400: }
401: }
402: else if(seq_gt(tcb->rcv.nxt, tcb->rcv.up))
403: tcb->rcv.up = tcb->rcv.nxt;
404:
405: if(length == 0){
406: if(bp)
407: freeb(bp);
408: }
409: else {
410: switch(tcb->state){
411: default:
412: /* Ignore segment text */
413: if(bp)
414: freeb(bp);
415: break;
416:
417: case Syn_received:
418: case Established:
419: case Finwait1:
420: /* If we still have some data place on receive queue */
421: tcb->rcvcnt += blen(bp);
422: if(bp){
423: if(s->readq)
424: PUTNEXT(s->readq, bp);
425: else
426: putb(&tcb->rcvq, bp);
427: bp = 0;
428: }
429: tcb->rcv.nxt += length;
430:
431: tcprcvwin(s);
432:
433: if(tcb->acktimer.state != TimerON)
434: tcpgo(&tcb->acktimer);
435:
436: if(tcb->rcv.nxt-tcb->last_ack > Streamhi/2)
437: tcb->flags |= FORCE;
438:
439: break;
440: case Finwait2:
441: /* no process to read the data, send a reset */
442: if(bp)
443: freeb(bp);
444: sndrst(source, dest, length, &seg);
445: goto done;
446: }
447: }
448:
449: if(seg.flags & FIN) {
450: tcb->flags |= FORCE;
451:
452: switch(tcb->state) {
453: case Syn_received:
454: case Established:
455: tcb->rcv.nxt++;
456: tcpsetstate(s, Close_wait);
457: break;
458: case Finwait1:
459: tcb->rcv.nxt++;
460: if(tcb->sndcnt == 0) {
461: tcpsetstate(s, Time_wait);
462: tcb->timer.start = MSL2 * (1000/MSPTICK);
463: tcpgo(&tcb->timer);
464: }
465: else
466: tcpsetstate(s, Closing);
467: break;
468: case Finwait2:
469: tcb->rcv.nxt++;
470: tcpsetstate(s, Time_wait);
471: tcb->timer.start = MSL2 * (1000/MSPTICK);
472: tcpgo(&tcb->timer);
473: break;
474: case Close_wait:
475: case Closing:
476: case Last_ack:
477: break;
478: case Time_wait:
479: tcpgo(&tcb->timer);
480: break;
481: }
482: }
483:
484: /*
485: * get next adjacent segment from the requence queue.
486: * dump/trim any overlapping segments
487: */
488: for(;;) {
489: if(tcb->reseq == 0)
490: goto output;
491:
492: if(seq_ge(tcb->rcv.nxt, tcb->reseq->seg.seq) == 0)
493: goto output;
494:
495: get_reseq(tcb, &tos, &seg, &bp, &length);
496:
497: if(trim(tcb, &seg, &bp, &length) == 0)
498: break;
499: }
500: }
501: output:
502: tcpoutput(s);
503: done:
504: qunlock(tcb);
505: }
506:
507: void
508: update(Ipconv *s, Tcp *seg)
509: {
510: int rtt;
511: ushort acked;
512: ushort expand;
513: Tcpctl *tcb = &s->tcpctl;
514:
515: tcb->kacounter = MAXBACKOFF; /* keep alive count down */
516:
517: if(seq_gt(seg->ack, tcb->snd.nxt)) {
518: tcb->flags |= FORCE;
519: return;
520: }
521:
522: if(seq_ge(seg->ack,tcb->snd.wl2))
523: if(seq_gt(seg->seq,tcb->snd.wl1) || (seg->seq == tcb->snd.wl1)) {
524: if(seg->wnd != 0)
525: if(tcb->snd.wnd == 0)
526: tcb->snd.ptr = tcb->snd.una;
527:
528: tcb->snd.wnd = seg->wnd;
529: tcb->snd.wl1 = seg->seq;
530: tcb->snd.wl2 = seg->ack;
531: }
532:
533: if(!seq_gt(seg->ack, tcb->snd.una))
534: return;
535:
536: /* Compute the new send window size */
537: acked = seg->ack - tcb->snd.una;
538: if(tcb->cwind < tcb->snd.wnd) {
539: if(tcb->cwind < tcb->ssthresh)
540: expand = MIN(acked,tcb->mss);
541: else
542: expand = ((long)tcb->mss * tcb->mss) / tcb->cwind;
543:
544: if(tcb->cwind + expand < tcb->cwind)
545: expand = 65535 - tcb->cwind;
546: if(tcb->cwind + expand > tcb->snd.wnd)
547: expand = tcb->snd.wnd - tcb->cwind;
548: if(expand != 0)
549: tcb->cwind += expand;
550: }
551:
552: /* Adjust the timers acorrding to the round trip time */
553: if(run_timer(&tcb->rtt_timer))
554: if(seq_ge(seg->ack, tcb->rttseq)) {
555: tcphalt(&tcb->rtt_timer);
556: if((tcb->flags&RETRAN) == 0) {
557: tcb->backoff = 0;
558: rtt = tcb->rtt_timer.start - tcb->rtt_timer.count;
559: rtt *= MSPTICK;
560: if(rtt > tcb->srtt &&
561: (tcb->state == Syn_sent || tcb->state == Syn_received))
562: tcb->srtt = rtt;
563: else {
564: tcb->srtt = ((AGAIN-1)*tcb->srtt + rtt) / AGAIN;
565: rtt = abs(rtt - tcb->srtt);
566: tcb->mdev = ((DGAIN-1)*tcb->mdev + rtt) / DGAIN;
567: }
568: }
569: }
570:
571: if((tcb->flags & SYNACK) == 0){
572: tcb->flags |= SYNACK;
573: acked--;
574: tcb->sndcnt--;
575: }
576:
577: pullb(&tcb->sndq, acked);
578:
579: tcb->sndcnt -= acked;
580: tcb->snd.una = seg->ack;
581: if(seq_gt(seg->ack, tcb->snd.up))
582: tcb->snd.up = seg->ack;
583:
584: tcphalt(&tcb->timer);
585: if(tcb->snd.una != tcb->snd.nxt)
586: tcpgo(&tcb->timer);
587:
588: if(seq_lt(tcb->snd.ptr, tcb->snd.una))
589: tcb->snd.ptr = tcb->snd.una;
590:
591: tcb->flags &= ~RETRAN;
592: tcb->backoff = 0;
593:
594: if(tcb->sndfull && tcb->sndcnt < Streamhi/2){
595: wakeup(&tcb->sndr);
596: tcb->sndfull = 0;
597: }
598: }
599:
600: int
601: in_window(Tcpctl *tcb, int seq)
602: {
603: return seq_within(seq, tcb->rcv.nxt, tcb->rcv.nxt+tcb->rcv.wnd-1);
604: }
605:
606: void
607: proc_syn(Ipconv *s, char tos, Tcp *seg)
608: {
609: Tcpctl *tcb = &s->tcpctl;
610: ushort mtu;
611:
612:
613: tcb->flags |= FORCE;
614:
615: if(PREC(tos) > PREC(tcb->tos))
616: tcb->tos = tos;
617:
618: tcb->rcv.up = tcb->rcv.nxt = seg->seq + 1;
619: tcb->snd.wl1 = tcb->irs = seg->seq;
620: tcb->snd.wnd = seg->wnd;
621:
622: if(seg->mss != 0)
623: tcb->mss = seg->mss;
624:
625: tcb->max_snd = seg->wnd;
626: /* FIX MTU!!! */
627: if((mtu = 1500) != 0) {
628: mtu -= TCP_HDRSIZE + TCP_EHSIZE + TCP_PHDRSIZE;
629: tcb->cwind = tcb->mss = MIN(mtu, tcb->mss);
630: }
631: }
632:
633: /* Generate an initial sequence number and put a SYN on the send queue */
634: void
635: tcpsndsyn(Tcpctl *tcb)
636: {
637: static int start;
638:
639: if(start == 0)
640: start = rtctime();
641: else
642: start += 250000;
643: tcb->iss = start;
644: tcb->rttseq = tcb->iss;
645: tcb->snd.wl2 = tcb->iss;
646: tcb->snd.una = tcb->iss;
647: tcb->snd.ptr = tcb->snd.nxt = tcb->rttseq;
648: tcb->sndcnt++;
649: tcb->flags |= FORCE;
650: }
651:
652: void
653: add_reseq(Tcpctl *tcb, char tos, Tcp *seg, Block *bp, ushort length)
654: {
655: Reseq *rp, *rp1;
656:
657: rp = malloc(sizeof(Reseq));
658: if(rp == 0){
659: freeb(bp); /* bp always consumed by add_reseq */
660: return;
661: }
662:
663: rp->seg = *seg;
664: rp->tos = tos;
665: rp->bp = bp;
666: rp->length = length;
667:
668: /* Place on reassembly list sorting by starting seq number */
669: rp1 = tcb->reseq;
670: if(rp1 == 0 || seq_lt(seg->seq, rp1->seg.seq)) {
671: rp->next = rp1;
672: tcb->reseq = rp;
673: return;
674: }
675:
676: for(;;) {
677: if(rp1->next == 0 || seq_lt(seg->seq, rp1->next->seg.seq)) {
678: rp->next = rp1->next;
679: rp1->next = rp;
680: break;
681: }
682: rp1 = rp1->next;
683: }
684: }
685:
686: void
687: get_reseq(Tcpctl *tcb, char *tos, Tcp *seg, Block **bp, ushort *length)
688: {
689: Reseq *rp;
690:
691: rp = tcb->reseq;
692: if(rp == 0)
693: return;
694:
695: tcb->reseq = rp->next;
696:
697: *tos = rp->tos;
698: *seg = rp->seg;
699: *bp = rp->bp;
700: *length = rp->length;
701:
702: free(rp);
703: }
704:
705: int
706: trim(Tcpctl *tcb, Tcp *seg, Block **bp, ushort *length)
707: {
708: Block *nbp;
709: long dupcnt;
710: long excess;
711: ushort len;
712: char accept;
713:
714: accept = 0;
715: len = *length;
716: if(seg->flags & SYN)
717: len++;
718: if(seg->flags & FIN)
719: len++;
720:
721: if(tcb->rcv.wnd == 0) {
722: if(len == 0)
723: if(seg->seq == tcb->rcv.nxt)
724: return 0;
725: }
726: else {
727: /* Some part of the segment should be in the window */
728: if(in_window(tcb,seg->seq))
729: accept++;
730: else
731: if(len != 0) {
732: if(in_window(tcb, seg->seq+len-1) ||
733: seq_within(tcb->rcv.nxt, seg->seq,seg->seq+len-1))
734: accept++;
735: }
736: }
737: if(!accept) {
738: freeb(*bp);
739: return -1;
740: }
741: dupcnt = tcb->rcv.nxt - seg->seq;
742: if(dupcnt > 0){
743: tcb->rerecv += dupcnt;
744: if(seg->flags & SYN){
745: seg->flags &= ~SYN;
746: seg->seq++;
747:
748: if (seg->up > 1)
749: seg->up--;
750: else
751: seg->flags &= ~URG;
752: dupcnt--;
753: }
754: if(dupcnt > 0){
755: pullb(bp, (ushort)dupcnt);
756: seg->seq += dupcnt;
757: *length -= dupcnt;
758:
759: if (seg->up > dupcnt)
760: seg->up -= dupcnt;
761: else {
762: seg->flags &= ~URG;
763: seg->up = 0;
764: }
765: }
766: }
767: excess = seg->seq + *length - (tcb->rcv.nxt + tcb->rcv.wnd);
768: if(excess > 0) {
769: tcb->rerecv += excess;
770: *length -= excess;
771: nbp = copyb(*bp, *length);
772: freeb(*bp);
773: *bp = nbp;
774: seg->flags &= ~FIN;
775: }
776: return 0;
777: }
778:
779: int
780: pullb(Block **bph, int count)
781: {
782: int n, bytes;
783: Block *bp;
784:
785: bytes = 0;
786: if(bph == 0)
787: return 0;
788:
789: while(*bph && count != 0) {
790: bp = *bph;
791: n = MIN(count, BLEN(bp));
792: bytes += n;
793: count -= n;
794: bp->rptr += n;
795: if(BLEN(bp) == 0) {
796: *bph = bp->next;
797: bp->next = 0;
798: freeb(bp);
799: }
800: }
801: return bytes;
802: }
803:
804: int
805: dupb(Block **hp, Block *bp, int offset, int count)
806: {
807: int i, blen, bytes = 0;
808: uchar *addr;
809:
810: *hp = allocb(count);
811: if(*hp == 0)
812: return 0;
813:
814: /* Correct to front of data area */
815: while(bp && offset && offset >= BLEN(bp)) {
816: offset -= BLEN(bp);
817: bp = bp->next;
818: }
819: if(bp == 0)
820: return 0;
821:
822: addr = bp->rptr + offset;
823: blen = BLEN(bp) - offset;
824:
825: while(count) {
826: i = MIN(count, blen);
827: memmove((*hp)->wptr, addr, i);
828: (*hp)->wptr += i;
829: bytes += i;
830: count -= i;
831: bp = bp->next;
832: if(!bp)
833: break;
834: blen = BLEN(bp);
835: addr = bp->rptr;
836: }
837:
838: return bytes;
839: }
840:
841: static void
842: cleartcp(struct Tctl *a)
843: {
844: memset(a, 0, sizeof(struct Tctl));
845: }
846:
847: void
848: init_tcpctl(Ipconv *s)
849: {
850:
851: Tcpctl *tcb = &s->tcpctl;
852:
853: cleartcp(tcb);
854:
855: tcb->cwind = tcb->mss = tcp_mss;
856: tcb->ssthresh = 65535;
857: tcb->srtt = tcp_irtt;
858:
859: tcb->timer.start = tcb->srtt / MSPTICK;
860: tcb->timer.func = tcptimeout;
861: tcb->timer.arg = s;
862: tcb->rtt_timer.start = MAX_TIME;
863: tcb->acktimer.start = TCP_ACK / MSPTICK;
864: tcb->acktimer.func = tcpacktimer;
865: tcb->acktimer.arg = s;
866: }
867:
868: /*
869: * called with tcb locked
870: */
871: void
872: localclose(Ipconv *s, char *reason)
873: {
874: Reseq *rp,*rp1;
875: Tcpctl *tcb = &s->tcpctl;
876: Block *bp;
877:
878: tcphalt(&tcb->timer);
879: tcphalt(&tcb->rtt_timer);
880: s->err = reason;
881:
882: /* flush receive queue */
883: while(bp = getb(&tcb->rcvq))
884: freeb(bp);
885:
886: /* Flush reassembly queue; nothing more can arrive */
887: for(rp = tcb->reseq;rp != 0;rp = rp1){
888: rp1 = rp->next;
889: freeb(rp->bp);
890: free(rp);
891: }
892:
893: tcb->reseq = 0;
894: s->err = reason;
895: if(tcb->sndq != 0){
896: freeb(tcb->sndq);
897: tcb->sndq = 0;
898: }
899: tcpsetstate(s, Closed);
900: }
901:
902: int
903: seq_within(ulong x, ulong low, ulong high)
904: {
905: if(low <= high){
906: if(low <= x && x <= high)
907: return 1;
908: }
909: else {
910: if(low >= x && x >= high)
911: return 1;
912: }
913: return 0;
914: }
915:
916: int
917: seq_lt(ulong x, ulong y)
918: {
919: return x < y;
920: }
921:
922: int
923: seq_le(ulong x, ulong y)
924: {
925: return x <= y;
926: }
927:
928: int
929: seq_gt(ulong x, ulong y)
930: {
931: return x > y;
932: }
933:
934: int
935: seq_ge(ulong x, ulong y)
936: {
937: return x >= y;
938: }
939:
940: void
941: tcpsetstate(Ipconv *s, char newstate)
942: {
943: Tcpctl *tcb;
944: char oldstate;
945:
946: tcb = &s->tcpctl;
947:
948: oldstate = tcb->state;
949: tcb->state = newstate;
950: tcpxstate(s, oldstate, newstate);
951: }
952:
953: Block *
954: htontcp(Tcp *tcph, Block *data, Tcphdr *ph)
955: {
956: int dlen;
957: Tcphdr *h;
958: Block *bp;
959: ushort csum;
960: ushort hdrlen;
961:
962: hdrlen = TCP_HDRSIZE;
963: if(tcph->mss)
964: hdrlen += MSS_LENGTH;
965:
966: if(data) {
967: dlen = blen(data);
968: data = padb(data, hdrlen + TCP_PKT);
969: if(data == 0)
970: return 0;
971: /* If we collected blocks delimit the end of the chain */
972: for(bp = data; bp->next; bp = bp->next)
973: bp->flags &= ~S_DELIM;
974: bp->flags |= S_DELIM;
975: }
976: else {
977: dlen = 0;
978: data = allocb(hdrlen + TCP_PKT);
979: if(data == 0)
980: return 0;
981: data->wptr += hdrlen + TCP_PKT;
982: data->flags |= S_DELIM;
983: }
984:
985:
986: memmove(data->rptr, ph, TCP_PKT);
987:
988: h = (Tcphdr *)(data->rptr);
989: h->proto = IP_TCPPROTO;
990: h->frag[0] = 0;
991: h->frag[1] = 0;
992: hnputs(h->tcplen, hdrlen + dlen);
993: hnputs(h->tcpsport, tcph->source);
994: hnputs(h->tcpdport, tcph->dest);
995: hnputl(h->tcpseq, tcph->seq);
996: hnputl(h->tcpack, tcph->ack);
997: hnputs(h->tcpflag, (hdrlen<<10) | tcph->flags);
998: hnputs(h->tcpwin, tcph->wnd);
999: h->tcpcksum[0] = 0;
1000: h->tcpcksum[1] = 0;
1001: h->Unused = 0;
1002: hnputs(h->tcpurg, tcph->up);
1003:
1004: if(tcph->mss != 0){
1005: h->tcpopt[0] = MSS_KIND;
1006: h->tcpopt[1] = MSS_LENGTH;
1007: hnputs(h->tcpmss, tcph->mss);
1008: }
1009: csum = ptcl_csum(data, TCP_EHSIZE+TCP_IPLEN, hdrlen+dlen+TCP_PHDRSIZE);
1010: hnputs(h->tcpcksum, csum);
1011:
1012: return data;
1013: }
1014:
1015: int
1016: ntohtcp(Tcp *tcph, Block **bpp)
1017: {
1018: ushort hdrlen;
1019: ushort i, optlen;
1020: Tcphdr *h;
1021: uchar *optr;
1022:
1023: *bpp = pullup(*bpp, TCP_PKT+TCP_HDRSIZE);
1024: if(*bpp == 0)
1025: return -1;
1026:
1027: h = (Tcphdr *)((*bpp)->rptr);
1028: tcph->source = nhgets(h->tcpsport);
1029: tcph->dest = nhgets(h->tcpdport);
1030: tcph->seq = nhgetl(h->tcpseq);
1031: tcph->ack = nhgetl(h->tcpack);
1032:
1033: hdrlen = (h->tcpflag[0] & 0xf0) >> 2;
1034: if(hdrlen < TCP_HDRSIZE) {
1035: freeb(*bpp);
1036: return -1;
1037: }
1038:
1039: tcph->flags = h->tcpflag[1];
1040: tcph->wnd = nhgets(h->tcpwin);
1041: tcph->up = nhgets(h->tcpurg);
1042: tcph->mss = 0;
1043:
1044: *bpp = pullup(*bpp, hdrlen+TCP_PKT);
1045: if(!*bpp)
1046: return -1;
1047:
1048: optr = h->tcpopt;
1049: for(i = TCP_HDRSIZE; i < hdrlen;) {
1050: switch(*optr++){
1051: case EOL_KIND:
1052: return hdrlen;
1053: case NOOP_KIND:
1054: i++;
1055: break;
1056: case MSS_KIND:
1057: optlen = *optr++;
1058: if(optlen == MSS_LENGTH)
1059: tcph->mss = nhgets(optr);
1060: i += optlen;
1061: break;
1062: }
1063: }
1064: return hdrlen;
1065: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.