keep USETRAILERS from SIOCSARP

[unix-history] / usr / src / sys / netinet / tcp_input.c

diff --git a/usr/src/sys/netinet/tcp_input.c b/usr/src/sys/netinet/tcp_input.c
index 5d28f8c..109b790 100644 (file)
--- a/usr/src/sys/netinet/tcp_input.c
+++ b/usr/src/sys/netinet/tcp_input.c
@@ -3,7 +3,7 @@
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  *
  * All rights reserved.  The Berkeley software License Agreement
  * specifies the terms and conditions for redistribution.
  *

- *     @(#)tcp_input.c 7.4 (Berkeley) %G%
+ *     @(#)tcp_input.c 7.12 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"


@@ -32,6 +32,7 @@
 
 int    tcpprintfs = 0;
 int    tcpcksum = 1;
 
 int    tcpprintfs = 0;
 int    tcpcksum = 1;

+int    tcprexmtthresh = 3;

 struct tcpiphdr tcp_saveti;
 extern tcpnodelack;
 
 struct tcpiphdr tcp_saveti;
 extern tcpnodelack;
 


@@ -178,7 +179,7 @@ tcp_input(m0)
        register struct tcpcb *tp = 0;
        register int tiflags;
        struct socket *so;
        register struct tcpcb *tp = 0;
        register int tiflags;
        struct socket *so;

-       int todrop, acked, needoutput = 0;
+       int todrop, acked, ourfinisacked, needoutput = 0;

        short ostate;
        struct in_addr laddr;
        int dropsocket = 0;
        short ostate;
        struct in_addr laddr;
        int dropsocket = 0;


@@ -278,12 +279,16 @@ findpcb:
        /*
         * If the state is CLOSED (i.e., TCB does not exist) then
         * all data in the incoming segment is discarded.
        /*
         * If the state is CLOSED (i.e., TCB does not exist) then
         * all data in the incoming segment is discarded.

+        * If the TCB exists but is in CLOSED state, it is embryonic,
+        * but should either do a listen or a connect soon.

         */
        if (inp == 0)
                goto dropwithreset;
        tp = intotcpcb(inp);
        if (tp == 0)
                goto dropwithreset;
         */
        if (inp == 0)
                goto dropwithreset;
        tp = intotcpcb(inp);
        if (tp == 0)
                goto dropwithreset;

+       if (tp->t_state == TCPS_CLOSED)
+               goto drop;

        so = inp->inp_socket;
        if (so->so_options & SO_DEBUG) {
                ostate = tp->t_state;
        so = inp->inp_socket;
        if (so->so_options & SO_DEBUG) {
                ostate = tp->t_state;


@@ -452,6 +457,18 @@ findpcb:
                        tp->t_state = TCPS_ESTABLISHED;
                        tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
                        (void) tcp_reass(tp, (struct tcpiphdr *)0);
                        tp->t_state = TCPS_ESTABLISHED;
                        tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
                        (void) tcp_reass(tp, (struct tcpiphdr *)0);

+                       /*
+                        * if we didn't have to retransmit the SYN,
+                        * use its rtt as our initial srtt & rtt var.
+                        */
+                       if (tp->t_rtt) {
+                               tp->t_srtt = tp->t_rtt << 3;
+                               tp->t_rttvar = tp->t_rtt << 1;
+                               TCPT_RANGESET(tp->t_rxtcur, 
+                                   ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
+                                   TCPTV_MIN, TCPTV_REXMTMAX);
+                               tp->t_rtt = 0;
+                       }

                } else
                        tp->t_state = TCPS_SYN_RECEIVED;
 
                } else
                        tp->t_state = TCPS_SYN_RECEIVED;
 


@@ -494,12 +511,22 @@ trimthenstep6:
                }
                if (todrop > ti->ti_len ||
                    todrop == ti->ti_len && (tiflags&TH_FIN) == 0) {
                }
                if (todrop > ti->ti_len ||
                    todrop == ti->ti_len && (tiflags&TH_FIN) == 0) {

+#ifdef TCP_COMPAT_42
+                       /*
+                        * Don't toss RST in response to 4.2-style keepalive.
+                        */
+                       if (ti->ti_seq == tp->rcv_nxt - 1 && tiflags & TH_RST)
+                               goto do_rst;
+#endif

                        tcpstat.tcps_rcvduppack++;
                        tcpstat.tcps_rcvdupbyte += ti->ti_len;
                        tcpstat.tcps_rcvduppack++;
                        tcpstat.tcps_rcvdupbyte += ti->ti_len;

-                       goto dropafterack;
+                       todrop = ti->ti_len;
+                       tiflags &= ~TH_FIN;
+                       tp->t_flags |= TF_ACKNOW;
+               } else {
+                       tcpstat.tcps_rcvpartduppack++;
+                       tcpstat.tcps_rcvpartdupbyte += todrop;

                }
                }

-               tcpstat.tcps_rcvpartduppack++;
-               tcpstat.tcps_rcvpartdupbyte += todrop;

                m_adj(m, todrop);
                ti->ti_seq += todrop;
                ti->ti_len -= todrop;
                m_adj(m, todrop);
                ti->ti_seq += todrop;
                ti->ti_len -= todrop;


@@ -579,6 +606,9 @@ trimthenstep6:
                }
        }
 
                }
        }
 

+#ifdef TCP_COMPAT_42
+do_rst:
+#endif

        /*
         * If the RST bit is set examine the state:
         *    SYN_RECEIVED STATE:
        /*
         * If the RST bit is set examine the state:
         *    SYN_RECEIVED STATE:


@@ -631,17 +661,13 @@ trimthenstep6:
 
        /*
         * In SYN_RECEIVED state if the ack ACKs our SYN then enter
 
        /*
         * In SYN_RECEIVED state if the ack ACKs our SYN then enter

-        * ESTABLISHED state and continue processing, othewise
+        * ESTABLISHED state and continue processing, otherwise

         * send an RST.
         */
        case TCPS_SYN_RECEIVED:
                if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
                    SEQ_GT(ti->ti_ack, tp->snd_max))
                        goto dropwithreset;
         * send an RST.
         */
        case TCPS_SYN_RECEIVED:
                if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
                    SEQ_GT(ti->ti_ack, tp->snd_max))
                        goto dropwithreset;

-               tp->snd_una++;                  /* SYN acked */
-               if (SEQ_LT(tp->snd_nxt, tp->snd_una))
-                       tp->snd_nxt = tp->snd_una;
-               tp->t_timer[TCPT_REXMT] = 0;

                tcpstat.tcps_connects++;
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;
                tcpstat.tcps_connects++;
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;


@@ -667,10 +693,60 @@ trimthenstep6:
        case TCPS_TIME_WAIT:
 
                if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
        case TCPS_TIME_WAIT:
 
                if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {

-                       if (ti->ti_len == 0)
+                       if (ti->ti_len == 0 && ti->ti_win == tp->snd_wnd) {

                                tcpstat.tcps_rcvdupack++;
                                tcpstat.tcps_rcvdupack++;

+                               /*
+                                * If we have outstanding data (not a
+                                * window probe), this is a completely
+                                * duplicate ack (ie, window info didn't
+                                * change), the ack is the biggest we've
+                                * seen and we've seen exactly our rexmt
+                                * threshhold of them, assume a packet
+                                * has been dropped and retransmit it.
+                                * Kludge snd_nxt & the congestion
+                                * window so we send only this one
+                                * packet.  If this packet fills the
+                                * only hole in the receiver's seq.
+                                * space, the next real ack will fully
+                                * open our window.  This means we
+                                * have to do the usual slow-start to
+                                * not overwhelm an intermediate gateway
+                                * with a burst of packets.  Leave
+                                * here with the congestion window set
+                                * to allow 2 packets on the next real
+                                * ack and the exp-to-linear thresh
+                                * set for half the current window
+                                * size (since we know we're losing at
+                                * the current window size).
+                                */
+                               if (tp->t_timer[TCPT_REXMT] == 0 ||
+                                   ti->ti_ack != tp->snd_una)
+                                       tp->t_dupacks = 0;
+                               else if (++tp->t_dupacks == tcprexmtthresh) {
+                                       tcp_seq onxt = tp->snd_nxt;
+                                       u_int win =
+                                           MIN(tp->snd_wnd, tp->snd_cwnd) / 2 /
+                                               tp->t_maxseg;
+
+                                       if (win < 2)
+                                               win = 2;
+                                       tp->snd_ssthresh = win * tp->t_maxseg;
+
+                                       tp->t_timer[TCPT_REXMT] = 0;
+                                       tp->t_rtt = 0;
+                                       tp->snd_nxt = ti->ti_ack;
+                                       tp->snd_cwnd = tp->t_maxseg;
+                                       (void) tcp_output(tp);
+
+                                       if (SEQ_GT(onxt, tp->snd_nxt))
+                                               tp->snd_nxt = onxt;
+                                       goto drop;
+                               }
+                       } else
+                               tp->t_dupacks = 0;

                        break;
                }
                        break;
                }

+               tp->t_dupacks = 0;

                if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
                        tcpstat.tcps_rcvacktoomuch++;
                        goto dropafterack;
                if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
                        tcpstat.tcps_rcvacktoomuch++;
                        goto dropafterack;


@@ -682,45 +758,96 @@ trimthenstep6:
                /*
                 * If transmit timer is running and timed sequence
                 * number was acked, update smoothed round trip time.
                /*
                 * If transmit timer is running and timed sequence
                 * number was acked, update smoothed round trip time.

+                * Since we now have an rtt measurement, cancel the
+                * timer backoff (cf., Phil Karn's retransmit alg.).
+                * Recompute the initial retransmit timer.

                 */
                if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq)) {
                        tcpstat.tcps_rttupdated++;
                 */
                if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq)) {
                        tcpstat.tcps_rttupdated++;

-                       if (tp->t_srtt == 0)
-                               tp->t_srtt = tp->t_rtt;
-                       else
-                               tp->t_srtt =
-                                   tcp_alpha * tp->t_srtt +
-                                   (1 - tcp_alpha) * tp->t_rtt;
+                       if (tp->t_srtt != 0) {
+                               register short delta;
+
+                               /*
+                                * srtt is stored as fixed point with 3 bits
+                                * after the binary point (i.e., scaled by 8).
+                                * The following magic is equivalent
+                                * to the smoothing algorithm in rfc793
+                                * with an alpha of .875
+                                * (srtt = rtt/8 + srtt*7/8 in fixed point).
+                                * Adjust t_rtt to origin 0.
+                                */
+                               tp->t_rtt--;
+                               delta = tp->t_rtt - (tp->t_srtt >> 3);
+                               if ((tp->t_srtt += delta) <= 0)
+                                       tp->t_srtt = 1;
+                               /*
+                                * We accumulate a smoothed rtt variance
+                                * (actually, a smoothed mean difference),
+                                * then set the retransmit timer to smoothed
+                                * rtt + 2 times the smoothed variance.
+                                * rttvar is stored as fixed point
+                                * with 2 bits after the binary point
+                                * (scaled by 4).  The following is equivalent
+                                * to rfc793 smoothing with an alpha of .75
+                                * (rttvar = rttvar*3/4 + |delta| / 4).
+                                * This replaces rfc793's wired-in beta.
+                                */
+                               if (delta < 0)
+                                       delta = -delta;
+                               delta -= (tp->t_rttvar >> 2);
+                               if ((tp->t_rttvar += delta) <= 0)
+                                       tp->t_rttvar = 1;
+                       } else {
+                               /* 
+                                * No rtt measurement yet - use the
+                                * unsmoothed rtt.  Set the variance
+                                * to half the rtt (so our first
+                                * retransmit happens at 2*rtt)
+                                */
+                               tp->t_srtt = tp->t_rtt << 3;
+                               tp->t_rttvar = tp->t_rtt << 1;
+                       }

                        tp->t_rtt = 0;
                        tp->t_rtt = 0;

+                       tp->t_rxtshift = 0;
+                       TCPT_RANGESET(tp->t_rxtcur, 
+                           ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
+                           TCPTV_MIN, TCPTV_REXMTMAX);

                }
 
                /*
                 * If all outstanding data is acked, stop retransmit
                 * timer and remember to restart (more output or persist).
                 * If there is more data to be acked, restart retransmit
                }
 
                /*
                 * If all outstanding data is acked, stop retransmit
                 * timer and remember to restart (more output or persist).
                 * If there is more data to be acked, restart retransmit

-                * timer.
+                * timer, using current (possibly backed-off) value.

                 */
                if (ti->ti_ack == tp->snd_max) {
                        tp->t_timer[TCPT_REXMT] = 0;
                        needoutput = 1;
                 */
                if (ti->ti_ack == tp->snd_max) {
                        tp->t_timer[TCPT_REXMT] = 0;
                        needoutput = 1;

-               } else if (tp->t_timer[TCPT_PERSIST] == 0) {
-                       TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
-                           tcp_beta * tp->t_srtt, TCPTV_MIN, TCPTV_MAX);
-                       tp->t_rxtshift = 0;
-               }
+               } else if (tp->t_timer[TCPT_PERSIST] == 0)
+                       tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;

                /*
                /*

-                * When new data is acked, open the congestion window
-                * by one max sized segment.
+                * When new data is acked, open the congestion window.
+                * If the window gives us less than ssthresh packets
+                * in flight, open exponentially (maxseg per packet).
+                * Otherwise open linearly (maxseg per window,
+                * or maxseg^2 / cwnd per packet).

                 */
                 */

-               tp->snd_cwnd = MIN(tp->snd_cwnd + tp->t_maxseg, 65535);
+               {
+               u_int incr = tp->t_maxseg;
+
+               if (tp->snd_cwnd > tp->snd_ssthresh)
+                       incr = MAX(incr * incr / tp->snd_cwnd, 1);
+
+               tp->snd_cwnd = MIN(tp->snd_cwnd + incr, 65535); /* XXX */
+               }

                if (acked > so->so_snd.sb_cc) {
                        tp->snd_wnd -= so->so_snd.sb_cc;
                        sbdrop(&so->so_snd, (int)so->so_snd.sb_cc);
                if (acked > so->so_snd.sb_cc) {
                        tp->snd_wnd -= so->so_snd.sb_cc;
                        sbdrop(&so->so_snd, (int)so->so_snd.sb_cc);

-#define        ourfinisacked   (acked > 0)
+                       ourfinisacked = 1;

                } else {
                        sbdrop(&so->so_snd, acked);
                        tp->snd_wnd -= acked;
                } else {
                        sbdrop(&so->so_snd, acked);
                        tp->snd_wnd -= acked;

-                       acked = 0;
+                       ourfinisacked = 0;

                }
                if ((so->so_snd.sb_flags & SB_WAIT) || so->so_snd.sb_sel)
                        sowwakeup(so);
                }
                if ((so->so_snd.sb_flags & SB_WAIT) || so->so_snd.sb_sel)
                        sowwakeup(so);


@@ -768,15 +895,17 @@ trimthenstep6:
                        break;
 
                /*
                        break;
 
                /*

-                * The only thing that can arrive in  LAST_ACK state
-                * is an acknowledgment of our FIN.  If our FIN is now
-                * acknowledged, delete the TCB, enter the closed state
-                * and return.
+                * In LAST_ACK, we may still be waiting for data to drain
+                * and/or to be acked, as well as for the ack of our FIN.
+                * If our FIN is now acknowledged, delete the TCB,
+                * enter the closed state and return.

                 */
                case TCPS_LAST_ACK:
                 */
                case TCPS_LAST_ACK:

-                       if (ourfinisacked)
+                       if (ourfinisacked) {

                                tp = tcp_close(tp);
                                tp = tcp_close(tp);

-                       goto drop;
+                               goto drop;
+                       }
+                       break;

 
                /*
                 * In TIME_WAIT state the only thing that should arrive
 
                /*
                 * In TIME_WAIT state the only thing that should arrive


@@ -787,7 +916,6 @@ trimthenstep6:
                        tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
                        goto dropafterack;
                }
                        tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
                        goto dropafterack;
                }

-#undef ourfinisacked

        }
 
 step6:
        }
 
 step6:


@@ -801,10 +929,8 @@ step6:
             tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd))) {
                /* keep track of pure window updates */
                if (ti->ti_len == 0 &&
             tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd))) {
                /* keep track of pure window updates */
                if (ti->ti_len == 0 &&

-                   tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd) {
+                   tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd)

                        tcpstat.tcps_rcvwinupd++;
                        tcpstat.tcps_rcvwinupd++;

-                       tcpstat.tcps_rcvdupack--;
-               }

                tp->snd_wnd = ti->ti_win;
                tp->snd_wl1 = ti->ti_seq;
                tp->snd_wl2 = ti->ti_ack;
                tp->snd_wnd = ti->ti_win;
                tp->snd_wl1 = ti->ti_seq;
                tp->snd_wl2 = ti->ti_ack;


@@ -891,7 +1017,7 @@ dodata:                                                    /* XXX */
                 * our window, in order to estimate the sender's
                 * buffer size.
                 */
                 * our window, in order to estimate the sender's
                 * buffer size.
                 */

-               len = so->so_rcv.sb_hiwat - (tp->rcv_nxt - tp->rcv_adv);
+               len = so->so_rcv.sb_hiwat - (tp->rcv_adv - tp->rcv_nxt);

                if (len > tp->max_rcvd)
                        tp->max_rcvd = len;
        } else {
                if (len > tp->max_rcvd)
                        tp->max_rcvd = len;
        } else {


@@ -965,9 +1091,9 @@ dropafterack:
         */
        if (tiflags & TH_RST)
                goto drop;
         */
        if (tiflags & TH_RST)
                goto drop;

-       if (tp->t_inpcb->inp_socket->so_options & SO_DEBUG)
-               tcp_trace(TA_RESPOND, ostate, tp, &tcp_saveti, 0);
-       tcp_respond(tp, ti, tp->rcv_nxt, tp->snd_nxt, TH_ACK);
+       m_freem(m);
+       tp->t_flags |= TF_ACKNOW;
+       (void) tcp_output(tp);

        return;
 
 dropwithreset:
        return;
 
 dropwithreset:


@@ -1087,12 +1213,15 @@ tcp_pulloutofband(so, ti)
  *  Determine a reasonable value for maxseg size.
  *  If the route is known, use one that can be handled
  *  on the given interface without forcing IP to fragment.
  *  Determine a reasonable value for maxseg size.
  *  If the route is known, use one that can be handled
  *  on the given interface without forcing IP to fragment.

- *  If bigger than a page (CLBYTES), round down to nearest pagesize
- *  to utilize pagesize mbufs.
+ *  If bigger than an mbuf cluster (MCLBYTES), round down to nearest size
+ *  to utilize large mbufs.

  *  If interface pointer is unavailable, or the destination isn't local,
  *  use a conservative size (512 or the default IP max size, but no more
  *  than the mtu of the interface through which we route),
  *  as we can't discover anything about intervening gateways or networks.
  *  If interface pointer is unavailable, or the destination isn't local,
  *  use a conservative size (512 or the default IP max size, but no more
  *  than the mtu of the interface through which we route),
  *  as we can't discover anything about intervening gateways or networks.

+ *  We also initialize the congestion/slow start window to be a single
+ *  segment if the destination isn't local; this information should
+ *  probably all be saved with the routing entry at the transport level.

  *
  *  This is ugly, and doesn't belong at this level, but has to happen somehow.
  */
  *
  *  This is ugly, and doesn't belong at this level, but has to happen somehow.
  */


@@ -1120,14 +1249,17 @@ tcp_mss(tp)
        }
 
        mss = ifp->if_mtu - sizeof(struct tcpiphdr);
        }
 
        mss = ifp->if_mtu - sizeof(struct tcpiphdr);

-#if    (CLBYTES & (CLBYTES - 1)) == 0
-       if (mss > CLBYTES)
-               mss &= ~(CLBYTES-1);
+#if    (MCLBYTES & (MCLBYTES - 1)) == 0
+       if (mss > MCLBYTES)
+               mss &= ~(MCLBYTES-1);

 #else
 #else

-       if (mss > CLBYTES)
-               mss = mss / CLBYTES * CLBYTES;
+       if (mss > MCLBYTES)
+               mss = mss / MCLBYTES * MCLBYTES;

 #endif
        if (in_localaddr(inp->inp_faddr))
                return (mss);
 #endif
        if (in_localaddr(inp->inp_faddr))
                return (mss);

-       return (MIN(mss, TCP_MSS));
+
+       mss = MIN(mss, TCP_MSS);
+       tp->snd_cwnd = mss;
+       return (mss);

 }
 }