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