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