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