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