add crontab entry

[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 c043ad0..a54439c 100644 (file)
--- a/usr/src/sys/netinet/tcp_input.c
+++ b/usr/src/sys/netinet/tcp_input.c
@@ -1,13 +1,25 @@
 /*
 /*

- * 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.
+ * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
+ * All rights reserved.

  *
  *

- *     @(#)tcp_input.c 7.9 (Berkeley) %G%
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *     @(#)tcp_input.c 7.20 (Berkeley) %G%

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

+#include "malloc.h"

 #include "mbuf.h"
 #include "protosw.h"
 #include "socket.h"
 #include "mbuf.h"
 #include "protosw.h"
 #include "socket.h"


@@ -31,9 +43,8 @@
 #include "tcp_debug.h"
 
 int    tcpprintfs = 0;
 #include "tcp_debug.h"
 
 int    tcpprintfs = 0;

-int    tcpcksum = 1;
+int    tcprexmtthresh = 3;

 struct tcpiphdr tcp_saveti;
 struct tcpiphdr tcp_saveti;

-extern tcpnodelack;

 
 struct tcpcb *tcp_newtcpcb();
 
 
 struct tcpcb *tcp_newtcpcb();
 


@@ -44,19 +55,24 @@ struct      tcpcb *tcp_newtcpcb();
  * (segment is the next to be received on an established connection,
  * and the queue is empty), avoiding linkage into and removal
  * from the queue and repetition of various conversions.
  * (segment is the next to be received on an established connection,
  * and the queue is empty), avoiding linkage into and removal
  * from the queue and repetition of various conversions.

+ * Set DELACK for segments received in order, but ack immediately
+ * when segments are out of order (so fast retransmit can work).

  */
 #define        TCP_REASS(tp, ti, m, so, flags) { \
        if ((ti)->ti_seq == (tp)->rcv_nxt && \
            (tp)->seg_next == (struct tcpiphdr *)(tp) && \
            (tp)->t_state == TCPS_ESTABLISHED) { \
  */
 #define        TCP_REASS(tp, ti, m, so, flags) { \
        if ((ti)->ti_seq == (tp)->rcv_nxt && \
            (tp)->seg_next == (struct tcpiphdr *)(tp) && \
            (tp)->t_state == TCPS_ESTABLISHED) { \

+               tp->t_flags |= TF_DELACK; \

                (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); \
                (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 \
+       } else { \

                (flags) = tcp_reass((tp), (ti)); \
                (flags) = tcp_reass((tp), (ti)); \

+               tp->t_flags |= TF_ACKNOW; \
+       } \

 }
 
 tcp_reass(tp, ti)
 }
 
 tcp_reass(tp, ti)


@@ -167,12 +183,12 @@ drop:
  * TCP input routine, follows pages 65-76 of the
  * protocol specification dated September, 1981 very closely.
  */
  * TCP input routine, follows pages 65-76 of the
  * protocol specification dated September, 1981 very closely.
  */

-tcp_input(m0)
-       struct mbuf *m0;
+tcp_input(m, iphlen)
+       register struct mbuf *m;
+       int iphlen;

 {
        register struct tcpiphdr *ti;
        struct inpcb *inp;
 {
        register struct tcpiphdr *ti;
        struct inpcb *inp;

-       register struct mbuf *m;

        struct mbuf *om = 0;
        int len, tlen, off;
        register struct tcpcb *tp = 0;
        struct mbuf *om = 0;
        int len, tlen, off;
        register struct tcpcb *tp = 0;


@@ -189,11 +205,10 @@ tcp_input(m0)
         * 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.
         */

-       m = m0;

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

-       if (((struct ip *)ti)->ip_hl > (sizeof (struct ip) >> 2))
-               ip_stripoptions((struct ip *)ti, (struct mbuf *)0);
-       if (m->m_off > MMAXOFF || m->m_len < sizeof (struct tcpiphdr)) {
+       if (iphlen > sizeof (struct ip))
+               ip_stripoptions(m, (struct mbuf *)0);
+       if (m->m_flags & M_EXT || m->m_len < sizeof (struct tcpiphdr)) {

                if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {
                        tcpstat.tcps_rcvshort++;
                        return;
                if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {
                        tcpstat.tcps_rcvshort++;
                        return;


@@ -206,17 +221,15 @@ tcp_input(m0)
         */
        tlen = ((struct ip *)ti)->ip_len;
        len = sizeof (struct ip) + tlen;
         */
        tlen = ((struct ip *)ti)->ip_len;
        len = sizeof (struct ip) + tlen;

-       if (tcpcksum) {
-               ti->ti_next = ti->ti_prev = 0;
-               ti->ti_x1 = 0;
-               ti->ti_len = (u_short)tlen;
-               ti->ti_len = htons((u_short)ti->ti_len);
-               if (ti->ti_sum = in_cksum(m, len)) {
-                       if (tcpprintfs)
-                               printf("tcp sum: src %x\n", ti->ti_src);
-                       tcpstat.tcps_rcvbadsum++;
-                       goto drop;
-               }
+       ti->ti_next = ti->ti_prev = 0;
+       ti->ti_x1 = 0;
+       ti->ti_len = (u_short)tlen;
+       ti->ti_len = htons((u_short)ti->ti_len);
+       if (ti->ti_sum = in_cksum(m, len)) {
+               if (tcpprintfs)
+                       printf("tcp sum: src %x\n", ti->ti_src);
+               tcpstat.tcps_rcvbadsum++;
+               goto drop;

        }
 
        /*
        }
 
        /*


@@ -247,6 +260,7 @@ tcp_input(m0)
                { caddr_t op = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
                  bcopy(op, mtod(om, caddr_t), (unsigned)om->m_len);
                  m->m_len -= om->m_len;
                { caddr_t op = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
                  bcopy(op, mtod(om, caddr_t), (unsigned)om->m_len);
                  m->m_len -= om->m_len;

+                 m->m_pkthdr.len -= om->m_len;

                  bcopy(op+om->m_len, op,
                   (unsigned)(m->m_len-sizeof (struct tcpiphdr)));
                }
                  bcopy(op+om->m_len, op,
                   (unsigned)(m->m_len-sizeof (struct tcpiphdr)));
                }


@@ -256,8 +270,9 @@ tcp_input(m0)
        /*
         * Drop TCP and IP headers; TCP options were dropped above.
         */
        /*
         * Drop TCP and IP headers; TCP options were dropped above.
         */

-       m->m_off += sizeof(struct tcpiphdr);
+       m->m_data += sizeof(struct tcpiphdr);

        m->m_len -= sizeof(struct tcpiphdr);
        m->m_len -= sizeof(struct tcpiphdr);

+       m->m_pkthdr.len -= sizeof(struct tcpiphdr);

 
        /*
         * Convert TCP protocol specific fields to host format.
 
        /*
         * Convert TCP protocol specific fields to host format.


@@ -278,12 +293,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;


@@ -308,7 +327,9 @@ findpcb:
                inp = (struct inpcb *)so->so_pcb;
                inp->inp_laddr = ti->ti_dst;
                inp->inp_lport = ti->ti_dport;
                inp = (struct inpcb *)so->so_pcb;
                inp->inp_laddr = ti->ti_dst;
                inp->inp_lport = ti->ti_dport;

+#if BSD>=43

                inp->inp_options = ip_srcroute();
                inp->inp_options = ip_srcroute();

+#endif

                tp = intotcpcb(inp);
                tp->t_state = TCPS_LISTEN;
        }
                tp = intotcpcb(inp);
                tp->t_state = TCPS_LISTEN;
        }


@@ -318,7 +339,7 @@ findpcb:
         * Reset idle time and keep-alive timer.
         */
        tp->t_idle = 0;
         * Reset idle time and keep-alive timer.
         */
        tp->t_idle = 0;

-       tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
+       tp->t_timer[TCPT_KEEP] = tcp_keepidle;

 
        /*
         * Process options if not in LISTEN state,
 
        /*
         * Process options if not in LISTEN state,


@@ -340,7 +361,7 @@ findpcb:
        win = sbspace(&so->so_rcv);
        if (win < 0)
                win = 0;
        win = sbspace(&so->so_rcv);
        if (win < 0)
                win = 0;

-       tp->rcv_wnd = MAX(win, (int)(tp->rcv_adv - tp->rcv_nxt));
+       tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));

        }
 
        switch (tp->t_state) {
        }
 
        switch (tp->t_state) {


@@ -368,7 +389,7 @@ findpcb:
                        goto dropwithreset;
                if ((tiflags & TH_SYN) == 0)
                        goto drop;
                        goto dropwithreset;
                if ((tiflags & TH_SYN) == 0)
                        goto drop;

-               if (in_broadcast(ti->ti_dst))
+               if (m->m_flags & M_BCAST)

                        goto drop;
                am = m_get(M_DONTWAIT, MT_SONAME);
                if (am == NULL)
                        goto drop;
                am = m_get(M_DONTWAIT, MT_SONAME);
                if (am == NULL)


@@ -407,7 +428,7 @@ findpcb:
                tcp_rcvseqinit(tp);
                tp->t_flags |= TF_ACKNOW;
                tp->t_state = TCPS_SYN_RECEIVED;
                tcp_rcvseqinit(tp);
                tp->t_flags |= TF_ACKNOW;
                tp->t_state = TCPS_SYN_RECEIVED;

-               tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
+               tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;

                dropsocket = 0;         /* committed to socket */
                tcpstat.tcps_accepts++;
                goto trimthenstep6;
                dropsocket = 0;         /* committed to socket */
                tcpstat.tcps_accepts++;
                goto trimthenstep6;


@@ -450,8 +471,20 @@ findpcb:
                        tcpstat.tcps_connects++;
                        soisconnected(so);
                        tp->t_state = TCPS_ESTABLISHED;
                        tcpstat.tcps_connects++;
                        soisconnected(so);
                        tp->t_state = TCPS_ESTABLISHED;

-                       tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
+                       tp->t_maxseg = min(tp->t_maxseg, tcp_mss(tp));

                        (void) tcp_reass(tp, (struct tcpiphdr *)0);
                        (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;
 


@@ -464,7 +497,17 @@ trimthenstep6:
                ti->ti_seq++;
                if (ti->ti_len > tp->rcv_wnd) {
                        todrop = ti->ti_len - tp->rcv_wnd;
                ti->ti_seq++;
                if (ti->ti_len > tp->rcv_wnd) {
                        todrop = ti->ti_len - tp->rcv_wnd;

+#if BSD>=43

                        m_adj(m, -todrop);
                        m_adj(m, -todrop);

+#else
+                       /* XXX work around 4.2 m_adj bug */
+                       if (m->m_len) {
+                               m_adj(m, -todrop);
+                       } else {
+                               /* skip tcp/ip header in first mbuf */
+                               m_adj(m->m_next, -todrop);
+                       }
+#endif

                        ti->ti_len = tp->rcv_wnd;
                        tiflags &= ~TH_FIN;
                        tcpstat.tcps_rcvpackafterwin++;
                        ti->ti_len = tp->rcv_wnd;
                        tiflags &= ~TH_FIN;
                        tcpstat.tcps_rcvpackafterwin++;


@@ -494,19 +537,32 @@ 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
+                       tcpstat.tcps_rcvduppack++;
+                       tcpstat.tcps_rcvdupbyte += ti->ti_len;

                        /*
                        /*

-                        * Don't toss RST in response to 4.2-style keepalive.
+                        * If segment is just one to the left of the window,
+                        * check two special cases:
+                        * 1. Don't toss RST in response to 4.2-style keepalive.
+                        * 2. If the only thing to drop is a FIN, we can drop
+                        *    it, but check the ACK or we will get into FIN
+                        *    wars if our FINs crossed (both CLOSING).
+                        * In either case, send ACK to resynchronize,
+                        * but keep on processing for RST or ACK.

                         */
                         */

-                       if (ti->ti_seq == tp->rcv_nxt - 1 && tiflags & TH_RST)
-                               goto do_rst;
+                       if ((tiflags & TH_FIN && todrop == ti->ti_len + 1)
+#ifdef TCP_COMPAT_42
+                         || (tiflags & TH_RST && ti->ti_seq == tp->rcv_nxt - 1)

 #endif
 #endif

-                       tcpstat.tcps_rcvduppack++;
-                       tcpstat.tcps_rcvdupbyte += ti->ti_len;
-                       goto dropafterack;
+                          ) {
+                               todrop = ti->ti_len;
+                               tiflags &= ~TH_FIN;
+                               tp->t_flags |= TF_ACKNOW;
+                       } else
+                               goto dropafterack;
+               } 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;


@@ -518,77 +574,68 @@ trimthenstep6:
                }
        }
 
                }
        }
 

-       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 ((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++;
+       /*
+        * If new data are 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);
+               tcpstat.tcps_rcvafterclose++;
+               goto dropwithreset;
+       }
+
+       /*
+        * 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) {
+               tcpstat.tcps_rcvpackafterwin++;
+               if (todrop >= ti->ti_len) {

                        tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
                        tcpstat.tcps_rcvbyteafterwin += ti->ti_len;

-                       goto dropafterack;
-               }
-               if (ti->ti_len > 0) {
-                       if (ti->ti_len == 1) 
-                               tcpstat.tcps_rcvwinprobe++;
-                       else {
-                               tcpstat.tcps_rcvpackafterwin++;
-                               tcpstat.tcps_rcvbyteafterwin += 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;

                        }
                        }

-                       m_adj(m, ti->ti_len);
-                       ti->ti_len = 0;
-                       tiflags &= ~(TH_PUSH|TH_FIN);
-               }
-       } else {
-               /*
-                * 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 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;
-                               }
+                       /*
+                        * If window is closed can only take segments at
+                        * window edge, and have to drop data and PUSH from
+                        * incoming segments.  Continue processing, but
+                        * remember to ack.  Otherwise, drop segment
+                        * and ack.
+                        */
+                       if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
+                               tp->t_flags |= TF_ACKNOW;
+                               tcpstat.tcps_rcvwinprobe++;
+                       } else

                                goto dropafterack;
                                goto dropafterack;

-                       }
-                       tcpstat.tcps_rcvpackafterwin++;
+               } else

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

+#if BSD>=43
+               m_adj(m, -todrop);
+#else
+               /* XXX work around m_adj bug */
+               if (m->m_len) {

                        m_adj(m, -todrop);
                        m_adj(m, -todrop);

-                       ti->ti_len -= todrop;
-                       tiflags &= ~(TH_PUSH|TH_FIN);
+               } else {
+                       /* skip tcp/ip header in first mbuf */
+                       m_adj(m->m_next, -todrop);

                }
                }

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


@@ -602,14 +649,18 @@ do_rst:
        if (tiflags&TH_RST) switch (tp->t_state) {
 
        case TCPS_SYN_RECEIVED:
        if (tiflags&TH_RST) switch (tp->t_state) {
 
        case TCPS_SYN_RECEIVED:

-               tp = tcp_drop(tp, ECONNREFUSED);
-               goto drop;
+               so->so_error = ECONNREFUSED;
+               goto close;

 
        case TCPS_ESTABLISHED:
        case TCPS_FIN_WAIT_1:
        case TCPS_FIN_WAIT_2:
        case TCPS_CLOSE_WAIT:
 
        case TCPS_ESTABLISHED:
        case TCPS_FIN_WAIT_1:
        case TCPS_FIN_WAIT_2:
        case TCPS_CLOSE_WAIT:

-               tp = tcp_drop(tp, ECONNRESET);
+               so->so_error = ECONNRESET;
+       close:
+               tp->t_state = TCPS_CLOSED;
+               tcpstat.tcps_drops++;
+               tp = tcp_close(tp);

                goto drop;
 
        case TCPS_CLOSING:
                goto drop;
 
        case TCPS_CLOSING:


@@ -651,7 +702,7 @@ do_rst:
                tcpstat.tcps_connects++;
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;
                tcpstat.tcps_connects++;
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;

-               tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
+               tp->t_maxseg = min(tp->t_maxseg, tcp_mss(tp));

                (void) tcp_reass(tp, (struct tcpiphdr *)0);
                tp->snd_wl1 = ti->ti_seq - 1;
                /* fall into ... */
                (void) tcp_reass(tp, (struct tcpiphdr *)0);
                tp->snd_wl1 = ti->ti_seq - 1;
                /* fall into ... */


@@ -673,10 +724,60 @@ do_rst:
        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;


@@ -688,6 +789,9 @@ do_rst:
                /*
                 * 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++;


@@ -701,15 +805,17 @@ do_rst:
                                 * to the smoothing algorithm in rfc793
                                 * with an alpha of .875
                                 * (srtt = rtt/8 + srtt*7/8 in fixed point).
                                 * 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.

                                 */
                                 */

-                               delta = tp->t_rtt - (tp->t_srtt >> 3);
+                               delta = tp->t_rtt - 1 - (tp->t_srtt >> 3);

                                if ((tp->t_srtt += delta) <= 0)
                                        tp->t_srtt = 1;
                                /*
                                if ((tp->t_srtt += delta) <= 0)
                                        tp->t_srtt = 1;
                                /*

-                                * We accumulate a smoothed rtt variance,
+                                * We accumulate a smoothed rtt variance
+                                * (actually, a smoothed mean difference),

                                 * then set the retransmit timer to smoothed
                                 * rtt + 2 times the smoothed variance.
                                 * then set the retransmit timer to smoothed
                                 * rtt + 2 times the smoothed variance.

-                                * rttvar is strored as fixed point
+                                * 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
                                 * with 2 bits after the binary point
                                 * (scaled by 4).  The following is equivalent
                                 * to rfc793 smoothing with an alpha of .75


@@ -732,28 +838,38 @@ do_rst:
                                tp->t_rttvar = tp->t_rtt << 1;
                        }
                        tp->t_rtt = 0;
                                tp->t_rttvar = tp->t_rtt << 1;
                        }
                        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; set to smoothed rtt + 2*rttvar.
+                * 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],
-                           ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
-                           TCPTV_MIN, TCPTV_REXMTMAX);
-                       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, USHRT_MAX); /* 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);


@@ -763,8 +879,7 @@ do_rst:
                        tp->snd_wnd -= acked;
                        ourfinisacked = 0;
                }
                        tp->snd_wnd -= acked;
                        ourfinisacked = 0;
                }

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

                tp->snd_una = ti->ti_ack;
                if (SEQ_LT(tp->snd_nxt, tp->snd_una))
                        tp->snd_nxt = tp->snd_una;
                tp->snd_una = ti->ti_ack;
                if (SEQ_LT(tp->snd_nxt, tp->snd_una))
                        tp->snd_nxt = tp->snd_una;


@@ -787,7 +902,7 @@ do_rst:
                                 */
                                if (so->so_state & SS_CANTRCVMORE) {
                                        soisdisconnected(so);
                                 */
                                if (so->so_state & SS_CANTRCVMORE) {
                                        soisdisconnected(so);

-                                       tp->t_timer[TCPT_2MSL] = TCPTV_MAXIDLE;
+                                       tp->t_timer[TCPT_2MSL] = tcp_maxidle;

                                }
                                tp->t_state = TCPS_FIN_WAIT_2;
                        }
                                }
                                tp->t_state = TCPS_FIN_WAIT_2;
                        }


@@ -843,10 +958,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;


@@ -900,8 +1013,11 @@ step6:
                 * but if two URG's are pending at once, some out-of-band
                 * data may creep in... ick.
                 */
                 * but if two URG's are pending at once, some out-of-band
                 * data may creep in... ick.
                 */

-               if (ti->ti_urp <= ti->ti_len &&
-                   (so->so_options & SO_OOBINLINE) == 0)
+               if (ti->ti_urp <= ti->ti_len
+#ifdef SO_OOBINLINE
+                    && (so->so_options & SO_OOBINLINE) == 0
+#endif
+                                                          )

                        tcp_pulloutofband(so, ti);
        } else
                /*
                        tcp_pulloutofband(so, ti);
        } else
                /*


@@ -924,16 +1040,12 @@ dodata:                                                  /* XXX */
        if ((ti->ti_len || (tiflags&TH_FIN)) &&
            TCPS_HAVERCVDFIN(tp->t_state) == 0) {
                TCP_REASS(tp, ti, m, so, tiflags);
        if ((ti->ti_len || (tiflags&TH_FIN)) &&
            TCPS_HAVERCVDFIN(tp->t_state) == 0) {
                TCP_REASS(tp, ti, m, so, tiflags);

-               if (tcpnodelack == 0)
-                       tp->t_flags |= TF_DELACK;
-               else
-                       tp->t_flags |= TF_ACKNOW;

                /*
                 * Note the amount of data that peer has sent into
                 * our window, in order to estimate the sender's
                 * buffer size.
                 */
                /*
                 * Note the amount of data that peer has sent into
                 * 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 {


@@ -1022,14 +1134,14 @@ dropwithreset:
         * Make ACK acceptable to originator of segment.
         * Don't bother to respond if destination was broadcast.
         */
         * Make ACK acceptable to originator of segment.
         * Don't bother to respond if destination was broadcast.
         */

-       if ((tiflags & TH_RST) || in_broadcast(ti->ti_dst))
+       if ((tiflags & TH_RST) || m->m_flags & M_BCAST)

                goto drop;
        if (tiflags & TH_ACK)
                goto drop;
        if (tiflags & TH_ACK)

-               tcp_respond(tp, ti, (tcp_seq)0, ti->ti_ack, TH_RST);
+               tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST);

        else {
                if (tiflags & TH_SYN)
                        ti->ti_len++;
        else {
                if (tiflags & TH_SYN)
                        ti->ti_len++;

-               tcp_respond(tp, ti, ti->ti_seq+ti->ti_len, (tcp_seq)0,
+               tcp_respond(tp, ti, m, ti->ti_seq+ti->ti_len, (tcp_seq)0,

                    TH_RST|TH_ACK);
        }
        /* destroy temporarily created socket */
                    TH_RST|TH_ACK);
        }
        /* destroy temporarily created socket */


@@ -1085,7 +1197,7 @@ tcp_dooptions(tp, om, ti)
                                continue;
                        tp->t_maxseg = *(u_short *)(cp + 2);
                        tp->t_maxseg = ntohs((u_short)tp->t_maxseg);
                                continue;
                        tp->t_maxseg = *(u_short *)(cp + 2);
                        tp->t_maxseg = ntohs((u_short)tp->t_maxseg);

-                       tp->t_maxseg = MIN(tp->t_maxseg, tcp_mss(tp));
+                       tp->t_maxseg = min(tp->t_maxseg, tcp_mss(tp));

                        break;
                }
        }
                        break;
                }
        }


@@ -1135,6 +1247,9 @@ tcp_pulloutofband(so, ti)
  *  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.
  *  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.
  */


@@ -1171,5 +1286,39 @@ tcp_mss(tp)
 #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);
+}
+
+#if BSD<43
+/* XXX this belongs in netinet/in.c */
+in_localaddr(in)
+       struct in_addr in;
+{
+       register u_long i = ntohl(in.s_addr);
+       register struct ifnet *ifp;
+       register struct sockaddr_in *sin;
+       register u_long mask;
+
+       if (IN_CLASSA(i))
+               mask = IN_CLASSA_NET;
+       else if (IN_CLASSB(i))
+               mask = IN_CLASSB_NET;
+       else if (IN_CLASSC(i))
+               mask = IN_CLASSC_NET;
+       else
+               return (0);
+
+       i &= mask;
+       for (ifp = ifnet; ifp; ifp = ifp->if_next) {
+               if (ifp->if_addr.sa_family != AF_INET)
+                       continue;
+               sin = (struct sockaddr_in *)&ifp->if_addr;
+               if ((sin->sin_addr.s_addr & mask) == i)
+                       return (1);
+       }
+       return (0);

 }
 }

+#endif