![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / inet|
Return to tcp_input.c CVS log | Up to [Research Unix] / researchv10no / sys / inet |
1.1 root 1: /* tcp_input.c 6.1 83/07/29 */
2:
3: #include "sys/param.h"
4: #include "sys/stream.h"
5:
6: #include "sys/inet/in.h"
7: #include "sys/inet/ip.h"
8: #include "sys/inet/ip_var.h"
9: #include "sys/inet/tcp.h"
10: #include "sys/inet/tcp_fsm.h"
11: #include "sys/inet/tcp_seq.h"
12: #include "sys/inet/tcp_timer.h"
13: #include "sys/inet/tcp_var.h"
14: #include "sys/inet/tcpip.h"
15:
16: int tcpprintfs = 0;
17: int itcpcksum = 0;
18: int tcp_dropcode = 0;
19: extern tcpnodelack;
20: extern int tcp_maxseg;
21:
22: /*
23: * TCP input routine, follows pages 65-76 of the
24: * protocol specification dated September, 1981 very closely.
25: */
26: tcp_input(tibp0)
27: struct block *tibp0;
28: {
29: register struct tcpiphdr *ti;
30: register struct block *tibp;
31: struct block *otibp = 0;
32: int len, tlen, off;
33: register struct tcpcb *tp = 0;
34: register int tiflags;
35: int todrop, acked;
36: int droptcpcb=0;
37:
38: /*
39: * Get IP and TCP header together in first block.
40: * Note: IP leaves IP header in first block.
41: */
42: tibp = tibp0;
43: ti = (struct tcpiphdr *)tibp->rptr;
44: if (((struct ip *)ti)->ip_hl > (sizeof (struct ip) >> 2))
45: ip_stripoptions(tibp, (struct block *)0);
46: if (BLEN(tibp) < sizeof (struct tcpiphdr)) {
47: if ((tibp = bp_pullup(tibp, sizeof (struct tcpiphdr))) == 0) {
48: tcpstat.tcps_hdrops++;
49: return;
50: }
51: ti = (struct tcpiphdr *)tibp->rptr;
52: }
53:
54: /*
55: * Checksum extended TCP header and data.
56: */
57: tlen = ((struct ip *)ti)->ip_len;
58: len = sizeof (struct ip) + tlen;
59: ti->ti_src = htonl(ti->ti_src);
60: ti->ti_dst = htonl(ti->ti_dst);
61: ti->ti_len = (u_short)tlen;
62: ti->ti_len = htons((u_short)ti->ti_len);
63: ti->ti_next = 0;
64: ti->ti_x1 = 0;
65: ti->ti_bp = 0;
66: tcp_debug(ti, 0);
67: if (itcpcksum) {
68: if (ti->ti_sum = in_cksum(tibp, len)) {
69: if (tcpprintfs)
70: printf("tcp sum: src %x, len %d\n", ti->ti_src, len);
71: tcpstat.tcps_badsum++;
72: goto drop;
73: }
74: }
75: ti->ti_bp = tibp;
76:
77: /*
78: * Check that TCP offset makes sense,
79: * pull out TCP options and adjust length.
80: */
81: off = ti->ti_off << 2;
82: if (off < sizeof (struct tcphdr) || off > tlen) {
83: if (tcpprintfs)
84: printf("tcp off: src %x off %d\n", ti->ti_src, off);
85: tcpstat.tcps_badoff++;
86: goto drop;
87: }
88: tlen -= off;
89: ti->ti_len = tlen;
90: if (off > sizeof (struct tcphdr)) {
91: if ((tibp = bp_pullup(tibp, sizeof (struct ip) + off)) == 0) {
92: tcpstat.tcps_hdrops++;
93: return;
94: }
95: ti = (struct tcpiphdr *)tibp->rptr;
96: ti->ti_bp = tibp;
97: otibp = bp_get();
98: if (otibp == 0)
99: goto drop;
100: otibp->next = 0;
101: otibp->wptr += off - sizeof (struct tcphdr);
102: { caddr_t op = (caddr_t)tibp->rptr + sizeof (struct tcpiphdr);
103: bcopy(op, (caddr_t)otibp->rptr, (unsigned)BLEN(otibp));
104: tibp->wptr -= BLEN(otibp);
105: bcopy(op+BLEN(otibp), op,
106: (unsigned)(BLEN(tibp)-sizeof (struct tcpiphdr)));
107: }
108: }
109: tiflags = ti->ti_flags;
110:
111: /*
112: * Drop TCP and IP headers.
113: */
114: tibp->rptr += sizeof(struct tcpiphdr);
115:
116: /*
117: * Convert TCP protocol specific fields to host format.
118: */
119: ti->ti_seq = ntohl(ti->ti_seq);
120: ti->ti_ack = ntohl(ti->ti_ack);
121: ti->ti_win = ntohs(ti->ti_win);
122: ti->ti_urp = ntohs(ti->ti_urp);
123: ti->ti_src = ntohl(ti->ti_src);
124: ti->ti_dst = ntohl(ti->ti_dst);
125: ti->ti_sport = ntohs(ti->ti_sport);
126: ti->ti_dport = ntohs(ti->ti_dport);
127:
128: /*
129: * Locate pcb for segment.
130: * If the state is CLOSED (i.e., TCB does not exist) then
131: * all data in the incoming segment is discarded.
132: */
133: tp = tcpcb_lookup(ti->ti_src, ti->ti_sport, ti->ti_dst, ti->ti_dport);
134: if(tp == 0) {
135: tcp_dropcode = 2;
136: goto dropwithreset;
137: }
138:
139: if (tp->so_options & SO_ACCEPTCONN) {
140: tp = tcp_newconn(tp);
141: if (tp == 0){
142: if (tcpprintfs) printf("tcp_newconn returns 0\n");
143: goto drop;
144: }
145: droptcpcb = 1;
146: if (tcpprintfs) printf("tcpcb[%d]\n", tp->so_dev);
147: tp->so_laddr = ti->ti_dst;
148: tp->so_lport = ti->ti_dport;
149: tp->so_faddr = ti->ti_src;
150: tp->so_fport = ti->ti_sport;
151: tcp_template(tp);
152: if (tp->t_template == 0){
153: if (tcpprintfs) printf("tp->t_template == 0\n");
154: goto drop;
155: }
156: tp->so_options &= ~SO_ACCEPTCONN;
157: tp->so_state = SS_PLEASEOPEN;
158: /* simulate PRU_ATTACH */
159: tp->t_state = TCPS_LISTEN;
160: }
161:
162: /*
163: * If the RST bit is set examine the state:
164: * SYN_RECEIVED STATE:
165: * If passive open, return to LISTEN state.
166: * If active open, inform user that connection was refused.
167: * ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
168: * Inform user that connection was reset, and close tcb.
169: * CLOSING, LAST_ACK, TIME_WAIT STATES
170: * Close the tcb.
171: */
172: if (tiflags&TH_RST) switch (tp->t_state) {
173: case TCPS_LISTEN:
174: goto drop;
175:
176: case TCPS_SYN_RECEIVED:
177: tp = tcp_drop(tp);
178: goto drop;
179:
180: case TCPS_ESTABLISHED:
181: case TCPS_FIN_WAIT_1:
182: case TCPS_FIN_WAIT_2:
183: case TCPS_CLOSE_WAIT:
184: tp = tcp_drop(tp);
185: goto drop;
186:
187: case TCPS_CLOSING:
188: case TCPS_LAST_ACK:
189: case TCPS_TIME_WAIT:
190: tp = tcp_close(tp);
191: goto drop;
192: }
193:
194: /*
195: * Segment received on connection.
196: * Reset idle time and keep-alive timer.
197: */
198: tp->t_idle = 0;
199: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
200:
201: /*
202: * Process options.
203: */
204: if (otibp) {
205: tcp_dooptions(tp, otibp);
206: otibp = 0;
207: }
208:
209: /*
210: * Calculate amount of space in receive window,
211: * and then do TCP input processing.
212: */
213: tp->rcv_wnd = sbrcvspace(tp);
214: if (tp->rcv_wnd < 0)
215: tp->rcv_wnd = 0;
216:
217: switch (tp->t_state) {
218:
219: /*
220: * If the state is LISTEN then ignore segment if it contains an RST.
221: * If the segment contains an ACK then it is bad and send a RST.
222: * If it does not contain a SYN then it is not interesting; drop it.
223: * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial
224: * tp->iss, and send a segment:
225: * <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
226: * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.
227: * Fill in remote peer address fields if not previously specified.
228: * Enter SYN_RECEIVED state, and process any other fields of this
229: * segment in this state.
230: */
231: case TCPS_LISTEN:
232: if (tiflags & TH_ACK) {
233: tcp_dropcode = 3;
234: goto dropwithreset;
235: }
236: if ((tiflags & TH_SYN) == 0)
237: goto drop;
238:
239: /* this should be removed */
240: if (tp->t_template == (struct block *)0) {
241: printf("tcpinput: uh oh, no template\n");
242: goto drop;
243: }
244: tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
245: tp->irs = ti->ti_seq;
246: tcp_sendseqinit(tp);
247: tcp_rcvseqinit(tp);
248: tp->t_state = TCPS_SYN_RECEIVED;
249: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
250: droptcpcb = 0; /* committed to control block */
251: goto trimthenstep6;
252:
253: /*
254: * If the state is SYN_SENT:
255: * if seg contains an ACK, but not for our SYN, drop the input.
256: * if seg contains a RST, then drop the connection.
257: * if seg does not contain SYN, then drop it.
258: * Otherwise this is an acceptable SYN segment
259: * initialize tp->rcv_nxt and tp->irs
260: * if seg contains ack then advance tp->snd_una
261: * if SYN has been acked change to ESTABLISHED else SYN_RCVD state
262: * arrange for segment to be acked (eventually)
263: * continue processing rest of data/controls, beginning with URG
264: */
265: case TCPS_SYN_SENT:
266: if ((tiflags & TH_ACK) &&
267: (SEQ_LT(ti->ti_ack, tp->iss) ||
268: SEQ_GT(ti->ti_ack, tp->snd_max))) {
269: tcp_dropcode = 4;
270: goto dropwithreset;
271: }
272: if (tiflags & TH_RST) {
273: if (tiflags & TH_ACK)
274: tp = tcp_drop(tp);
275: goto drop;
276: }
277: if ((tiflags & TH_SYN) == 0)
278: goto drop;
279: tp->snd_una = ti->ti_ack;
280: if (SEQ_LT(tp->snd_nxt, tp->snd_una))
281: tp->snd_nxt = tp->snd_una;
282: tp->t_timer[TCPT_REXMT] = 0;
283: tp->irs = ti->ti_seq;
284: tcp_rcvseqinit(tp);
285: tp->t_flags |= TF_ACKNOW;
286: if (SEQ_GT(tp->snd_una, tp->iss)) {
287: if (tcp_isconnected(tp)<0)
288: goto dropwithreset;
289: tp->t_state = TCPS_ESTABLISHED;
290: (void) tcp_reass(tp, (struct tcpiphdr *)0);
291: } else
292: tp->t_state = TCPS_SYN_RECEIVED;
293: goto trimthenstep6;
294:
295: trimthenstep6:
296: /*
297: * Advance ti->ti_seq to correspond to first data byte.
298: * If data, trim to stay within window,
299: * dropping FIN if necessary.
300: */
301: ti->ti_seq++;
302: if (ti->ti_len > tp->rcv_wnd) {
303: todrop = ti->ti_len - tp->rcv_wnd;
304: bp_adj(tibp, -todrop);
305: ti->ti_len = tp->rcv_wnd;
306: ti->ti_flags &= ~TH_FIN;
307: }
308: tp->snd_wl1 = ti->ti_seq - 1;
309: goto step6;
310: }
311:
312: /*
313: * States other than LISTEN or SYN_SENT.
314: * First check that at least some bytes of segment are within
315: * receive window.
316: */
317: if (tp->rcv_wnd == 0) {
318: /*
319: * If window is closed can only take segments at
320: * window edge, and have to drop data and PUSH from
321: * incoming segments.
322: */
323: if (tp->rcv_nxt != ti->ti_seq)
324: goto dropafterack;
325: if (ti->ti_len > 0) {
326: bp_adj(tibp, ti->ti_len);
327: ti->ti_len = 0;
328: ti->ti_flags &= ~(TH_PUSH|TH_FIN);
329: }
330: } else {
331: /*
332: * If segment begins before rcv_nxt, drop leading
333: * data (and SYN); if nothing left, just ack.
334: */
335: todrop = tp->rcv_nxt - ti->ti_seq;
336: if (todrop > 0) {
337: if (tiflags & TH_SYN) {
338: tiflags &= ~TH_SYN;
339: ti->ti_flags &= ~TH_SYN;
340: ti->ti_seq++;
341: if (ti->ti_urp > 1)
342: ti->ti_urp--;
343: else
344: tiflags &= ~TH_URG;
345: todrop--;
346: }
347: if (todrop > ti->ti_len ||
348: (todrop == ti->ti_len && (tiflags&TH_FIN) == 0))
349: goto dropafterack2;
350: bp_adj(tibp, todrop);
351: ti->ti_seq += todrop;
352: ti->ti_len -= todrop;
353: if (ti->ti_urp > todrop)
354: ti->ti_urp -= todrop;
355: else {
356: tiflags &= ~TH_URG;
357: ti->ti_flags &= ~TH_URG;
358: ti->ti_urp = 0;
359: }
360: }
361: /*
362: * If segment ends after window, drop trailing data
363: * (and PUSH and FIN); if nothing left, just ACK.
364: */
365: todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
366: if (todrop > 0) {
367: if (todrop > ti->ti_len)
368: todrop = ti->ti_len;
369: bp_adj(tibp, -todrop);
370: ti->ti_len -= todrop;
371: ti->ti_flags &= ~(TH_PUSH|TH_FIN);
372: }
373: }
374:
375: /*
376: * If data is received on a connection after the
377: * user processes are gone, then RST the other end.
378: */
379: if ((tp->so_state & SS_OPEN)==0 && tp->t_state > TCPS_CLOSE_WAIT && tlen) {
380: tp = tcp_close(tp);
381: tcp_dropcode = 5;
382: goto dropwithreset;
383: }
384:
385: /*
386: * If a SYN is in the window, then this is an
387: * error and we send an RST and drop the connection.
388: */
389: if (tiflags & TH_SYN) {
390: tp = tcp_drop(tp);
391: tcp_dropcode = 6;
392: goto dropwithreset;
393: }
394:
395: /*
396: * If the ACK bit is off we drop the segment and return.
397: */
398: if ((tiflags & TH_ACK) == 0)
399: goto drop;
400:
401: /*
402: * Ack processing.
403: */
404: switch (tp->t_state) {
405:
406: /*
407: * In SYN_RECEIVED state if the ack ACKs our SYN then enter
408: * ESTABLISHED state and continue processing, othewise
409: * send an RST.
410: */
411: case TCPS_SYN_RECEIVED:
412: if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
413: SEQ_GT(ti->ti_ack, tp->snd_max)) {
414: tcp_dropcode = 7;
415: goto dropwithreset;
416: }
417: tp->snd_una++; /* SYN acked */
418: if (SEQ_LT(tp->snd_nxt, tp->snd_una))
419: tp->snd_nxt = tp->snd_una;
420: tp->t_timer[TCPT_REXMT] = 0;
421: if (tcp_isconnected(tp)<0) {
422: tcp_dropcode = 8;
423: goto dropwithreset;
424: }
425: tp->t_state = TCPS_ESTABLISHED;
426: (void) tcp_reass(tp, (struct tcpiphdr *)0);
427: tp->snd_wl1 = ti->ti_seq - 1;
428: /* fall into ... */
429:
430: /*
431: * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
432: * ACKs. If the ack is in the range
433: * tp->snd_una < ti->ti_ack <= tp->snd_max
434: * then advance tp->snd_una to ti->ti_ack and drop
435: * data from the retransmission queue. If this ACK reflects
436: * more up to date window information we update our window information.
437: */
438: case TCPS_ESTABLISHED:
439: case TCPS_FIN_WAIT_1:
440: case TCPS_FIN_WAIT_2:
441: case TCPS_CLOSE_WAIT:
442: case TCPS_CLOSING:
443: case TCPS_LAST_ACK:
444: case TCPS_TIME_WAIT:
445: #define ourfinisacked (acked > 0)
446:
447: if (SEQ_LEQ(ti->ti_ack, tp->snd_una))
448: break;
449: if (SEQ_GT(ti->ti_ack, tp->snd_max))
450: goto dropafterack;
451: acked = ti->ti_ack - tp->snd_una;
452:
453: /*
454: * If transmit timer is running and timed sequence
455: * number was acked, update smoothed round trip time.
456: */
457: if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq)) {
458: if (tp->t_srtt == 0)
459: tp->t_srtt = tp->t_rtt;
460: else
461: tp->t_srtt =
462: tcp_alpha * tp->t_srtt +
463: (1 - tcp_alpha) * tp->t_rtt;
464: tp->t_rtt = 0;
465: }
466:
467: if (ti->ti_ack == tp->snd_max)
468: tp->t_timer[TCPT_REXMT] = 0;
469: else {
470: TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
471: tcp_beta * tp->t_srtt, TCPTV_MIN, TCPTV_MAX);
472: tp->t_rtt = 1;
473: tp->t_rxtshift = 0;
474: }
475: if (acked > sosndcc(tp)) {
476: tp->snd_wnd -= sosndcc(tp);
477: sbsnddrop(tp, sosndcc(tp));
478: } else {
479: sbsnddrop(tp, acked);
480: tp->snd_wnd -= acked;
481: acked = 0;
482: }
483: tp->snd_una = ti->ti_ack;
484: if (SEQ_LT(tp->snd_nxt, tp->snd_una))
485: tp->snd_nxt = tp->snd_una;
486:
487: switch (tp->t_state) {
488:
489: /*
490: * In FIN_WAIT_1 STATE in addition to the processing
491: * for the ESTABLISHED state if our FIN is now acknowledged
492: * then enter FIN_WAIT_2.
493: */
494: case TCPS_FIN_WAIT_1:
495: if (ourfinisacked) {
496: /*
497: * If we can't receive any more
498: * data, then closing user can proceed,
499: * but don't wait forever.
500: */
501: tp->t_state = TCPS_FIN_WAIT_2;
502: tcp_canceltimers(tp);
503: tp->so_options |= SO_KEEPALIVE;
504: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
505: }
506: break;
507:
508: /*
509: * In CLOSING STATE in addition to the processing for
510: * the ESTABLISHED state if the ACK acknowledges our FIN
511: * then enter the TIME-WAIT state, otherwise ignore
512: * the segment.
513: */
514: case TCPS_CLOSING:
515: if (ourfinisacked) {
516: tp->t_state = TCPS_TIME_WAIT;
517: tcp_canceltimers(tp);
518: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
519: tp->so_state &= ~(SS_PLEASEOPEN|SS_RCVATMARK);
520: if(tp->so_state&SS_OPEN && !(tp->so_state&SS_HUNGUP)) {
521: tp->so_state |= SS_HUNGUP;
522: tcp_hungup(tp);
523: }
524: }
525: break;
526:
527: /*
528: * The only thing that can arrive in LAST_ACK state
529: * is an acknowledgment of our FIN. If our FIN is now
530: * acknowledged, delete the TCB, enter the closed state
531: * and return.
532: */
533: case TCPS_LAST_ACK:
534: if (ourfinisacked)
535: tp = tcp_close(tp);
536: goto drop;
537:
538: /*
539: * In TIME_WAIT state the only thing that should arrive
540: * is a retransmission of the remote FIN. Acknowledge
541: * it and restart the finack timer.
542: */
543: case TCPS_TIME_WAIT:
544: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
545: goto dropafterack;
546: }
547: #undef ourfinisacked
548: }
549:
550: step6:
551: /*
552: * Update window information.
553: */
554: if (SEQ_LT(tp->snd_wl1, ti->ti_seq) || tp->snd_wl1 == ti->ti_seq &&
555: (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
556: tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd)) {
557: tp->snd_wnd = ti->ti_win;
558: tp->snd_wl1 = ti->ti_seq;
559: tp->snd_wl2 = ti->ti_ack;
560: if (tp->snd_wnd != 0)
561: tp->t_timer[TCPT_PERSIST] = 0;
562: }
563:
564: /*
565: * Process segments with URG.
566: */
567: if ((tiflags & TH_URG) && ti->ti_urp &&
568: TCPS_HAVERCVDFIN(tp->t_state) == 0) {
569: /*
570: * This is a kludge, but if we receive accept
571: * random urgent pointers, we'll crash in
572: * soreceive. It's hard to imagine someone
573: * actually wanting to send this much urgent data.
574: */
575: if (ti->ti_urp > tp->t_maxseg) { /* XXX */
576: ti->ti_urp = 0; /* XXX */
577: tiflags &= ~TH_URG; /* XXX */
578: ti->ti_flags &= ~TH_URG; /* XXX */
579: goto badurp; /* XXX */
580: }
581: /*
582: * If this segment advances the known urgent pointer,
583: * then mark the data stream. This should not happen
584: * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since
585: * a FIN has been received from the remote side.
586: * In these states we ignore the URG.
587: */
588: if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
589: /* M_CTL, maybe? looks like it's put in the data stream */
590: tp->rcv_up = ti->ti_seq + ti->ti_urp;
591: tp->so_oobmark = 0 +
592: (tp->rcv_up - tp->rcv_nxt) - 1;
593: if (tp->so_oobmark == 0)
594: tp->so_state |= SS_RCVATMARK;
595: sohasoutofband(tp);
596: tp->t_oobflags &= ~TCPOOB_HAVEDATA;
597: }
598: /*
599: * Remove out of band data so doesn't get presented to user.
600: * This can happen independent of advancing the URG pointer,
601: * but if two URG's are pending at once, some out-of-band
602: * data may creep in... ick.
603: */
604: if (ti->ti_urp <= ti->ti_len)
605: tcp_pulloutofband(tp, ti);
606: }
607: badurp: /* XXX */
608:
609: /*
610: * Process the segment text, merging it into the TCP sequencing queue,
611: * and arranging for acknowledgment of receipt if necessary.
612: * This process logically involves adjusting tp->rcv_wnd as data
613: * is presented to the user (this happens in tcp_usrreq.c,
614: * case PRU_RCVD). If a FIN has already been received on this
615: * connection then we just ignore the text.
616: */
617: if ((ti->ti_len || (tiflags&TH_FIN)) &&
618: TCPS_HAVERCVDFIN(tp->t_state) == 0) {
619: tiflags = tcp_reass(tp, ti);
620: if (tcpnodelack == 0)
621: tp->t_flags |= TF_DELACK;
622: else
623: tp->t_flags |= TF_ACKNOW;
624: } else {
625: bp_free(tibp);
626: tiflags &= ~TH_FIN;
627: }
628:
629: /*
630: * If FIN is received ACK the FIN and let the user know
631: * that the connection is closing.
632: */
633: if (tiflags & TH_FIN) {
634: if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
635: tcp_cantrcvmore(tp);
636: tp->t_flags |= TF_ACKNOW;
637: tp->rcv_nxt++;
638: }
639: switch (tp->t_state) {
640:
641: /*
642: * In SYN_RECEIVED and ESTABLISHED STATES
643: * enter the CLOSE_WAIT state.
644: */
645: case TCPS_SYN_RECEIVED:
646: /* if caller closes before listener opens tcp device,
647: * act as if listener had opened and closed device.
648: */
649: if (tp->so_state & SS_OPEN) {
650: tp->t_state = TCPS_CLOSE_WAIT;
651: tp->so_state &= ~(SS_PLEASEOPEN|SS_RCVATMARK);
652: if(!(tp->so_state&SS_HUNGUP)) {
653: tp->so_state |= SS_HUNGUP;
654: tcp_hungup(tp);
655: }
656: } else {
657: tp->t_state = TCPS_LAST_ACK;
658: tp->so_options |= SO_KEEPALIVE;
659: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
660: }
661: break;
662: case TCPS_ESTABLISHED:
663: /* if caller closes before listener opens tcp device,
664: * act as if listener had opened and closed device.
665: */
666: if (tp->so_state & SS_OPEN)
667: tp->t_state = TCPS_CLOSE_WAIT;
668: else {
669: tp->t_state = TCPS_LAST_ACK;
670: tp->so_options |= SO_KEEPALIVE;
671: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
672: }
673: break;
674:
675: /*
676: * If still in FIN_WAIT_1 STATE FIN has not been acked so
677: * enter the CLOSING state.
678: */
679: case TCPS_FIN_WAIT_1:
680: tp->t_state = TCPS_CLOSING;
681: break;
682:
683: /*
684: * In FIN_WAIT_2 state enter the TIME_WAIT state,
685: * starting the time-wait timer, turning off the other
686: * standard timers.
687: */
688: case TCPS_FIN_WAIT_2:
689: tp->t_state = TCPS_TIME_WAIT;
690: tcp_canceltimers(tp);
691: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
692: tp->so_state &= ~(SS_PLEASEOPEN|SS_RCVATMARK);
693: if(tp->so_state&SS_OPEN && !(tp->so_state&SS_HUNGUP)) {
694: tp->so_state |= SS_HUNGUP;
695: tcp_hungup(tp);
696: }
697: break;
698:
699: /*
700: * In TIME_WAIT state restart the 2 MSL time_wait timer.
701: */
702: case TCPS_TIME_WAIT:
703: tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
704: break;
705: }
706: }
707:
708: /*
709: * Return any desired output.
710: */
711: (void) tcp_output(tp);
712: return;
713:
714: dropafterack:
715: /*
716: * Generate an ACK dropping incoming segment if it occupies
717: * sequence space, where the ACK reflects our state.
718: */
719: if ((tiflags&TH_RST) ||
720: tlen == 0 && (tiflags&(TH_SYN|TH_FIN)) == 0)
721: goto drop;
722: dropafterack2:
723: tcp_respond(tp, ti, tp->rcv_nxt, tp->snd_nxt, TH_ACK);
724: return;
725:
726: dropwithreset:
727: if (otibp) {
728: freeb(otibp);
729: otibp = 0;
730: }
731: /*
732: * Generate a RST, dropping incoming segment.
733: * Make ACK acceptable to originator of segment.
734: */
735: if (tiflags & TH_RST)
736: goto drop;
737: if (tiflags & TH_ACK)
738: tcp_respond(tp, ti, (tcp_seq)0, ti->ti_ack, TH_RST);
739: else {
740: if (tiflags & TH_SYN)
741: ti->ti_len++;
742: tcp_respond(tp, ti, ti->ti_seq+ti->ti_len, (tcp_seq)0,
743: TH_RST|TH_ACK);
744: }
745:
746: /* destroy temporarily created control block */
747: if (droptcpcb)
748: (void) tcp_close(tp);
749: return;
750:
751: drop:
752: /* destroy temporarily created control block */
753: if (droptcpcb)
754: (void) tcp_close(tp);
755: if (otibp)
756: freeb(otibp);
757: /*
758: * Drop space held by incoming segment and return.
759: */
760: bp_free(tibp);
761: return;
762: }
763:
764: tcp_dooptions(tp, om)
765: struct tcpcb *tp;
766: struct block *om;
767: {
768: register u_char *cp;
769: int opt, optlen, cnt;
770:
771: cp = (u_char *)om->rptr;
772: cnt = BLEN(om);
773: for (; cnt > 0; cnt -= optlen, cp += optlen) {
774: opt = cp[0];
775: if (opt == TCPOPT_EOL)
776: break;
777: if (opt == TCPOPT_NOP)
778: optlen = 1;
779: else {
780: optlen = cp[1];
781: if (optlen <= 0)
782: break;
783: }
784: switch (opt) {
785:
786: default:
787: break;
788:
789: case TCPOPT_MAXSEG:
790: if (optlen != 4)
791: continue;
792: tp->t_maxseg = *(u_short *)(cp + 2);
793: tp->t_maxseg = ntohs((u_short)tp->t_maxseg);
794: if (tp->t_maxseg > tcp_maxseg)
795: tp->t_maxseg = tcp_maxseg;
796: break;
797: }
798: }
799: freeb(om);
800: }
801:
802: /*
803: * Pull out of band byte out of a segment so
804: * it doesn't appear in the user's data queue.
805: * It is still reflected in the segment length for
806: * sequencing purposes.
807: */
808: tcp_pulloutofband(tp, ti)
809: struct tcpcb *tp;
810: struct tcpiphdr *ti;
811: {
812: register struct block *bp;
813: int cnt = ti->ti_urp - 1;
814:
815: bp = ti->ti_bp;
816:
817: while (cnt >= 0) {
818: if (BLEN(bp) > cnt) {
819: char *cp = (char *)(bp->rptr) + cnt;
820:
821: tp->t_iobc = *cp;
822: tp->t_oobflags |= TCPOOB_HAVEDATA;
823: bcopy(cp+1, cp, (unsigned)(BLEN(bp) - cnt - 1));
824: bp->wptr--;
825: return;
826: }
827: cnt -= BLEN(bp);
828: bp = bp->next;
829: if (bp == 0)
830: break;
831: }
832: panic("tcp_pulloutofband");
833: }
834:
835: /*
836: * Insert segment ti into reassembly queue of tcp with
837: * control block tp. Return TH_FIN if reassembly now includes
838: * a segment with FIN.
839: */
840: tcp_reass(tp, ti)
841: register struct tcpcb *tp;
842: register struct tcpiphdr *ti;
843: {
844: register struct block *bp; /* for tcpiphdr */
845: register struct tcpiphdr *prevq, *q;
846: int flags;
847:
848: /*
849: * Call with ti==0 after become established to
850: * force pre-ESTABLISHED data up to user socket.
851: */
852: if (ti == 0)
853: goto present;
854:
855: /*
856: * Find a segment which begins after this one does.
857: */
858: for (prevq = (struct tcpiphdr *)0, q = tp->seg_next;
859: q != (struct tcpiphdr *)0; prevq = q, q = q->ti_next) {
860: if (SEQ_GT(q->ti_seq, ti->ti_seq))
861: break;
862: }
863:
864: /*
865: * If there is a preceding segment, it may provide some of
866: * our data already. If so, drop the data from the incoming
867: * segment. If it provides all of our data, drop us.
868: */
869: if (prevq != (struct tcpiphdr *)0) {
870: register int i;
871:
872: q = prevq;
873: /* conversion to int (in i) handles seq wraparound */
874: i = q->ti_seq + q->ti_len - ti->ti_seq;
875: if (i > 0) {
876: tcpstat.tcps_duplicates++;
877: if (i >= ti->ti_len)
878: goto drop;
879: bp_adj(ti->ti_bp, i);
880: ti->ti_len -= i;
881: ti->ti_seq += i;
882: }
883: q = (struct tcpiphdr *) (q->ti_next);
884: }
885:
886: /*
887: * While we overlap succeeding segments trim them or,
888: * if they are completely covered, dequeue them.
889: */
890: while (q != (struct tcpiphdr *)0) {
891: register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
892: if (i <= 0)
893: break;
894: tcpstat.tcps_delayed++;
895: if (i < q->ti_len) {
896: q->ti_seq += i;
897: q->ti_len -= i;
898: bp_adj(q->ti_bp, i);
899: break;
900: }
901: /* dequeue overlapped segment */
902: if (prevq == (struct tcpiphdr *)0)
903: tp->seg_next = q->ti_next;
904: else
905: prevq->ti_next = q->ti_next;
906: bp_free(q->ti_bp);
907: if (prevq == (struct tcpiphdr *)0)
908: q = tp->seg_next;
909: else
910: q = prevq->ti_next;
911: }
912:
913: /*
914: * Stick new segment in its place.
915: */
916: /* insque(ti, prevq); */
917: if (prevq == (struct tcpiphdr *)0)
918: tp->seg_next = ti;
919: else
920: prevq->ti_next = ti;
921: ti->ti_next = q;
922:
923:
924: present:
925: /*
926: * Present data to user, advancing rcv_nxt through
927: * completed sequence space.
928: */
929: if (TCPS_HAVERCVDSYN(tp->t_state) == 0)
930: return (0);
931: if ((ti = tp->seg_next) == (struct tcpiphdr *)0)
932: return (0);
933: if (ti->ti_seq != tp->rcv_nxt)
934: return (0);
935: if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
936: return (0);
937: do {
938: tp->rcv_nxt += ti->ti_len;
939:
940: flags = ti->ti_flags & TH_FIN;
941:
942: /* remque(ti); */
943: tp->seg_next = ti->ti_next;
944: bp = ti->ti_bp;
945: ti = ti->ti_next;
946: if (tp->so_state & SS_OPEN)
947: tcpdrint(bp, tp);
948: else
949: bp_free(bp);
950:
951: } while (ti != (struct tcpiphdr *)0 && ti->ti_seq == tp->rcv_nxt);
952: return (flags);
953: drop:
954: bp_free(ti->ti_bp);
955: return (0);
956: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.