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