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 e072a09..109b790 100644 (file)
--- a/usr/src/sys/netinet/tcp_input.c
+++ b/usr/src/sys/netinet/tcp_input.c
@@ -1,9 +1,9 @@
 /*
 /*

- * Copyright (c) 1982 Regents of the University of California.
+ * Copyright (c) 1982, 1986 Regents of the University of California.

  * 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 6.23 (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;
 


@@ -51,6 +52,8 @@ struct        tcpcb *tcp_newtcpcb();
            (tp)->t_state == TCPS_ESTABLISHED) { \
                (tp)->rcv_nxt += (ti)->ti_len; \
                flags = (ti)->ti_flags & TH_FIN; \
            (tp)->t_state == TCPS_ESTABLISHED) { \
                (tp)->rcv_nxt += (ti)->ti_len; \
                flags = (ti)->ti_flags & TH_FIN; \

+               tcpstat.tcps_rcvpack++;\
+               tcpstat.tcps_rcvbyte += (ti)->ti_len;\

                sbappend(&(so)->so_rcv, (m)); \
                sorwakeup(so); \
        } else \
                sbappend(&(so)->so_rcv, (m)); \
                sorwakeup(so); \
        } else \


@@ -92,14 +95,19 @@ tcp_reass(tp, ti)
                /* conversion to int (in i) handles seq wraparound */
                i = q->ti_seq + q->ti_len - ti->ti_seq;
                if (i > 0) {
                /* conversion to int (in i) handles seq wraparound */
                i = q->ti_seq + q->ti_len - ti->ti_seq;
                if (i > 0) {

-                       if (i >= ti->ti_len)
+                       if (i >= ti->ti_len) {
+                               tcpstat.tcps_rcvduppack++;
+                               tcpstat.tcps_rcvdupbyte += ti->ti_len;

                                goto drop;
                                goto drop;

+                       }

                        m_adj(dtom(ti), i);
                        ti->ti_len -= i;
                        ti->ti_seq += i;
                }
                q = (struct tcpiphdr *)(q->ti_next);
        }
                        m_adj(dtom(ti), i);
                        ti->ti_len -= i;
                        ti->ti_seq += i;
                }
                q = (struct tcpiphdr *)(q->ti_next);
        }

+       tcpstat.tcps_rcvoopack++;
+       tcpstat.tcps_rcvoobyte += ti->ti_len;

 
        /*
         * While we overlap succeeding segments trim them or,
 
        /*
         * While we overlap succeeding segments trim them or,


@@ -171,11 +179,13 @@ 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;

+       int iss = 0;

 
 

+       tcpstat.tcps_rcvtotal++;

        /*
         * Get IP and TCP header together in first mbuf.
         * Note: IP leaves IP header in first mbuf.
        /*
         * Get IP and TCP header together in first mbuf.
         * Note: IP leaves IP header in first mbuf.


@@ -186,7 +196,7 @@ tcp_input(m0)
                ip_stripoptions((struct ip *)ti, (struct mbuf *)0);
        if (m->m_off > MMAXOFF || m->m_len < sizeof (struct tcpiphdr)) {
                if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {
                ip_stripoptions((struct ip *)ti, (struct mbuf *)0);
        if (m->m_off > MMAXOFF || m->m_len < sizeof (struct tcpiphdr)) {
                if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {

-                       tcpstat.tcps_hdrops++;
+                       tcpstat.tcps_rcvshort++;

                        return;
                }
                ti = mtod(m, struct tcpiphdr *);
                        return;
                }
                ti = mtod(m, struct tcpiphdr *);


@@ -205,7 +215,7 @@ tcp_input(m0)
                if (ti->ti_sum = in_cksum(m, len)) {
                        if (tcpprintfs)
                                printf("tcp sum: src %x\n", ti->ti_src);
                if (ti->ti_sum = in_cksum(m, len)) {
                        if (tcpprintfs)
                                printf("tcp sum: src %x\n", ti->ti_src);

-                       tcpstat.tcps_badsum++;
+                       tcpstat.tcps_rcvbadsum++;

                        goto drop;
                }
        }
                        goto drop;
                }
        }


@@ -218,7 +228,7 @@ tcp_input(m0)
        if (off < sizeof (struct tcphdr) || off > tlen) {
                if (tcpprintfs)
                        printf("tcp off: src %x off %d\n", ti->ti_src, off);
        if (off < sizeof (struct tcphdr) || off > tlen) {
                if (tcpprintfs)
                        printf("tcp off: src %x off %d\n", ti->ti_src, off);

-               tcpstat.tcps_badoff++;
+               tcpstat.tcps_rcvbadoff++;

                goto drop;
        }
        tlen -= off;
                goto drop;
        }
        tlen -= off;


@@ -226,7 +236,7 @@ tcp_input(m0)
        if (off > sizeof (struct tcphdr)) {
                if (m->m_len < sizeof(struct ip) + off) {
                        if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {
        if (off > sizeof (struct tcphdr)) {
                if (m->m_len < sizeof(struct ip) + off) {
                        if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {

-                               tcpstat.tcps_hdrops++;
+                               tcpstat.tcps_rcvshort++;

                                return;
                        }
                        ti = mtod(m, struct tcpiphdr *);
                                return;
                        }
                        ti = mtod(m, struct tcpiphdr *);


@@ -261,6 +271,7 @@ tcp_input(m0)
        /*
         * Locate pcb for segment.
         */
        /*
         * Locate pcb for segment.
         */

+findpcb:

        inp = in_pcblookup
                (&tcb, ti->ti_src, ti->ti_sport, ti->ti_dst, ti->ti_dport,
                INPLOOKUP_WILDCARD);
        inp = in_pcblookup
                (&tcb, ti->ti_src, ti->ti_sport, ti->ti_dst, ti->ti_dport,
                INPLOOKUP_WILDCARD);


@@ -268,12 +279,16 @@ tcp_input(m0)
        /*
         * 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;


@@ -387,7 +402,11 @@ tcp_input(m0)
                        tcp_dooptions(tp, om, ti);
                        om = 0;
                }
                        tcp_dooptions(tp, om, ti);
                        om = 0;
                }

-               tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
+               if (iss)
+                       tp->iss = iss;
+               else
+                       tp->iss = tcp_iss;
+               tcp_iss += TCP_ISSINCR/2;

                tp->irs = ti->ti_seq;
                tcp_sendseqinit(tp);
                tcp_rcvseqinit(tp);
                tp->irs = ti->ti_seq;
                tcp_sendseqinit(tp);
                tcp_rcvseqinit(tp);


@@ -395,6 +414,7 @@ tcp_input(m0)
                tp->t_state = TCPS_SYN_RECEIVED;
                tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
                dropsocket = 0;         /* committed to socket */
                tp->t_state = TCPS_SYN_RECEIVED;
                tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
                dropsocket = 0;         /* committed to socket */

+               tcpstat.tcps_accepts++;

                goto trimthenstep6;
                }
 
                goto trimthenstep6;
                }
 


@@ -422,21 +442,35 @@ tcp_input(m0)
                }
                if ((tiflags & TH_SYN) == 0)
                        goto drop;
                }
                if ((tiflags & TH_SYN) == 0)
                        goto drop;

-               tp->snd_una = ti->ti_ack;
-               if (SEQ_LT(tp->snd_nxt, tp->snd_una))
-                       tp->snd_nxt = tp->snd_una;
+               if (tiflags & TH_ACK) {
+                       tp->snd_una = ti->ti_ack;
+                       if (SEQ_LT(tp->snd_nxt, tp->snd_una))
+                               tp->snd_nxt = tp->snd_una;
+               }

                tp->t_timer[TCPT_REXMT] = 0;
                tp->irs = ti->ti_seq;
                tcp_rcvseqinit(tp);
                tp->t_flags |= TF_ACKNOW;
                tp->t_timer[TCPT_REXMT] = 0;
                tp->irs = ti->ti_seq;
                tcp_rcvseqinit(tp);
                tp->t_flags |= TF_ACKNOW;

-               if (SEQ_GT(tp->snd_una, tp->iss)) {
+               if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
+                       tcpstat.tcps_connects++;

                        soisconnected(so);
                        tp->t_state = TCPS_ESTABLISHED;
                        tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
                        (void) tcp_reass(tp, (struct tcpiphdr *)0);
                        soisconnected(so);
                        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;

-               goto trimthenstep6;

 
 trimthenstep6:
                /*
 
 trimthenstep6:
                /*


@@ -450,83 +484,131 @@ trimthenstep6:
                        m_adj(m, -todrop);
                        ti->ti_len = tp->rcv_wnd;
                        tiflags &= ~TH_FIN;
                        m_adj(m, -todrop);
                        ti->ti_len = tp->rcv_wnd;
                        tiflags &= ~TH_FIN;

+                       tcpstat.tcps_rcvpackafterwin++;
+                       tcpstat.tcps_rcvbyteafterwin += todrop;

                }
                tp->snd_wl1 = ti->ti_seq - 1;
                tp->rcv_up = ti->ti_seq;
                goto step6;
        }
 
                }
                tp->snd_wl1 = ti->ti_seq - 1;
                tp->rcv_up = ti->ti_seq;
                goto step6;
        }
 

-       /*
-        * If data is received on a connection after the
-        * user processes are gone, then RST the other end.
-        */
-       if ((so->so_state & SS_NOFDREF) && tp->t_state > TCPS_CLOSE_WAIT &&
-           ti->ti_len) {
-               tp = tcp_close(tp);
-               goto dropwithreset;
-       }
-

        /*
         * States other than LISTEN or SYN_SENT.
         * First check that at least some bytes of segment are within 
        /*
         * States other than LISTEN or SYN_SENT.
         * First check that at least some bytes of segment are within 

-        * receive window.
+        * receive window.  If segment begins before rcv_nxt,
+        * drop leading data (and SYN); if nothing left, just ack.

         */
         */

+       todrop = tp->rcv_nxt - ti->ti_seq;
+       if (todrop > 0) {
+               if (tiflags & TH_SYN) {
+                       tiflags &= ~TH_SYN;
+                       ti->ti_seq++;
+                       if (ti->ti_urp > 1) 
+                               ti->ti_urp--;
+                       else
+                               tiflags &= ~TH_URG;
+                       todrop--;
+               }
+               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;
+                       todrop = ti->ti_len;
+                       tiflags &= ~TH_FIN;
+                       tp->t_flags |= TF_ACKNOW;
+               } else {
+                       tcpstat.tcps_rcvpartduppack++;
+                       tcpstat.tcps_rcvpartdupbyte += todrop;
+               }
+               m_adj(m, todrop);
+               ti->ti_seq += todrop;
+               ti->ti_len -= todrop;
+               if (ti->ti_urp > todrop)
+                       ti->ti_urp -= todrop;
+               else {
+                       tiflags &= ~TH_URG;
+                       ti->ti_urp = 0;
+               }
+       }
+

        if (tp->rcv_wnd == 0) {
                /*
                 * If window is closed can only take segments at
                 * window edge, and have to drop data and PUSH from
                 * incoming segments.
        if (tp->rcv_wnd == 0) {
                /*
                 * If window is closed can only take segments at
                 * window edge, and have to drop data and PUSH from
                 * incoming segments.

+                *
+                * If new data is received on a connection after the
+                * user processes are gone, then RST the other end.

                 */
                 */

-               if (tp->rcv_nxt != ti->ti_seq)
+               if ((so->so_state & SS_NOFDREF) &&
+                   tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
+                       tp = tcp_close(tp);
+                       tcpstat.tcps_rcvafterclose++;
+                       goto dropwithreset;
+               }
+               if (tp->rcv_nxt != ti->ti_seq) {
+                       tcpstat.tcps_rcvpackafterwin++;
+                       tcpstat.tcps_rcvbyteafterwin += ti->ti_len;

                        goto dropafterack;
                        goto dropafterack;

+               }

                if (ti->ti_len > 0) {
                if (ti->ti_len > 0) {

+                       if (ti->ti_len == 1) 
+                               tcpstat.tcps_rcvwinprobe++;
+                       else {
+                               tcpstat.tcps_rcvpackafterwin++;
+                               tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
+                       }

                        m_adj(m, ti->ti_len);
                        ti->ti_len = 0;
                        tiflags &= ~(TH_PUSH|TH_FIN);
                }
        } else {
                        m_adj(m, ti->ti_len);
                        ti->ti_len = 0;
                        tiflags &= ~(TH_PUSH|TH_FIN);
                }
        } else {

-               /*
-                * If segment begins before rcv_nxt, drop leading
-                * data (and SYN); if nothing left, just ack.
-                */
-               todrop = tp->rcv_nxt - ti->ti_seq;
-               if (todrop > 0) {
-                       if (tiflags & TH_SYN) {
-                               tiflags &= ~TH_SYN;
-                               ti->ti_seq++;
-                               if (ti->ti_urp > 1) 
-                                       ti->ti_urp--;
-                               else
-                                       tiflags &= ~TH_URG;
-                               todrop--;
-                       }
-                       if (todrop > ti->ti_len ||
-                           todrop == ti->ti_len && (tiflags&TH_FIN) == 0)
-                               goto dropafterack;
-                       m_adj(m, todrop);
-                       ti->ti_seq += todrop;
-                       ti->ti_len -= todrop;
-                       if (ti->ti_urp > todrop)
-                               ti->ti_urp -= todrop;
-                       else {
-                               tiflags &= ~TH_URG;
-                               ti->ti_urp = 0;
-                       }
-               }

                /*
                 * If segment ends after window, drop trailing data
                 * (and PUSH and FIN); if nothing left, just ACK.
                 */
                todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
                if (todrop > 0) {
                /*
                 * If segment ends after window, drop trailing data
                 * (and PUSH and FIN); if nothing left, just ACK.
                 */
                todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
                if (todrop > 0) {

-                       if (todrop >= ti->ti_len)
+                       if (todrop >= ti->ti_len) {
+                               /*
+                                * If a new connection request is received
+                                * while in TIME_WAIT, drop the old connection
+                                * and start over if the sequence numbers
+                                * are above the previous ones.
+                                */
+                               if (tiflags & TH_SYN &&
+                                   tp->t_state == TCPS_TIME_WAIT &&
+                                   SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
+                                       iss = tp->rcv_nxt + TCP_ISSINCR;
+                                       (void) tcp_close(tp);
+                                       goto findpcb;
+                               }
+                               if (todrop == 1) 
+                                       tcpstat.tcps_rcvwinprobe++;
+                               else {
+                                       tcpstat.tcps_rcvpackafterwin++;
+                                       tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
+                               }

                                goto dropafterack;
                                goto dropafterack;

+                       }
+                       tcpstat.tcps_rcvpackafterwin++;
+                       tcpstat.tcps_rcvbyteafterwin += todrop;

                        m_adj(m, -todrop);
                        ti->ti_len -= todrop;
                        tiflags &= ~(TH_PUSH|TH_FIN);
                }
        }
 
                        m_adj(m, -todrop);
                        ti->ti_len -= todrop;
                        tiflags &= ~(TH_PUSH|TH_FIN);
                }
        }
 

+#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:


@@ -579,17 +661,14 @@ 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;
                tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;
                tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));


@@ -612,54 +691,163 @@ trimthenstep6:
        case TCPS_CLOSING:
        case TCPS_LAST_ACK:
        case TCPS_TIME_WAIT:
        case TCPS_CLOSING:
        case TCPS_LAST_ACK:
        case TCPS_TIME_WAIT:

-#define        ourfinisacked   (acked > 0)

 
 

-               if (SEQ_LEQ(ti->ti_ack, tp->snd_una))
+               if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
+                       if (ti->ti_len == 0 && ti->ti_win == tp->snd_wnd) {
+                               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;

-               if (SEQ_GT(ti->ti_ack, tp->snd_max))
+               }
+               tp->t_dupacks = 0;
+               if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
+                       tcpstat.tcps_rcvacktoomuch++;

                        goto dropafterack;
                        goto dropafterack;

+               }

                acked = ti->ti_ack - tp->snd_una;
                acked = ti->ti_ack - tp->snd_una;

+               tcpstat.tcps_rcvackpack++;
+               tcpstat.tcps_rcvackbyte += acked;

 
                /*
                 * 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)) {
                 */
                if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq)) {

-                       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;
+                       tcpstat.tcps_rttupdated++;
+                       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 a bit.
+                * 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).

                 */
                 */

-               if (acked > 0)
-                       tp->snd_cwnd = MIN(11 * tp->snd_cwnd / 10, 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);

+                       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);


@@ -707,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


@@ -726,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:


@@ -738,6 +927,10 @@ step6:
            (SEQ_LT(tp->snd_wl1, ti->ti_seq) || tp->snd_wl1 == ti->ti_seq &&
            (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
             tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd))) {
            (SEQ_LT(tp->snd_wl1, ti->ti_seq) || tp->snd_wl1 == ti->ti_seq &&
            (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
             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)
+                       tcpstat.tcps_rcvwinupd++;

                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;


@@ -824,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 {


@@ -898,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:


@@ -1020,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.
  */


@@ -1053,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);

 }
 }