fix autoconf, move code to isa.c, remove debugging, drop redundant tlbflushes, macros...
[unix-history] / usr / src / sys / netinet / tcp_input.c
index e5ec4c8..18477ae 100644 (file)
@@ -1,13 +1,15 @@
 /*
 /*
- * 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, 1990 Regents of the University of California.
+ * All rights reserved.
  *
  *
- *     @(#)tcp_input.c 7.13 (Berkeley) %G%
+ * %sccs.include.redist.c%
+ *
+ *     @(#)tcp_input.c 7.25 (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"
@@ -18,9 +20,9 @@
 #include "../net/route.h"
 
 #include "in.h"
 #include "../net/route.h"
 
 #include "in.h"
-#include "in_pcb.h"
 #include "in_systm.h"
 #include "ip.h"
 #include "in_systm.h"
 #include "ip.h"
+#include "in_pcb.h"
 #include "ip_var.h"
 #include "tcp.h"
 #include "tcp_fsm.h"
 #include "ip_var.h"
 #include "tcp.h"
 #include "tcp_fsm.h"
 #include "tcpip.h"
 #include "tcp_debug.h"
 
 #include "tcpip.h"
 #include "tcp_debug.h"
 
-int    tcpprintfs = 0;
-int    tcpcksum = 1;
 int    tcprexmtthresh = 3;
 int    tcprexmtthresh = 3;
+int    tcppredack;     /* XXX debugging: times hdr predict ok for acks */
+int    tcppreddat;     /* XXX # times header prediction ok for data packets */
+int    tcppcbcachemiss;
 struct tcpiphdr tcp_saveti;
 struct tcpiphdr tcp_saveti;
-extern tcpnodelack;
+struct inpcb *tcp_last_inpcb = &tcb;
 
 struct tcpcb *tcp_newtcpcb();
 
 
 struct tcpcb *tcp_newtcpcb();
 
@@ -45,28 +48,33 @@ 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 \
-               (flags) = tcp_reass((tp), (ti)); \
+       } else { \
+               (flags) = tcp_reass((tp), (ti), (m)); \
+               tp->t_flags |= TF_ACKNOW; \
+       } \
 }
 
 }
 
-tcp_reass(tp, ti)
+tcp_reass(tp, ti, m)
        register struct tcpcb *tp;
        register struct tcpiphdr *ti;
        register struct tcpcb *tp;
        register struct tcpiphdr *ti;
+       struct mbuf *m;
 {
        register struct tcpiphdr *q;
        struct socket *so = tp->t_inpcb->inp_socket;
 {
        register struct tcpiphdr *q;
        struct socket *so = tp->t_inpcb->inp_socket;
-       struct mbuf *m;
        int flags;
 
        /*
        int flags;
 
        /*
@@ -98,9 +106,10 @@ tcp_reass(tp, ti)
                        if (i >= ti->ti_len) {
                                tcpstat.tcps_rcvduppack++;
                                tcpstat.tcps_rcvdupbyte += ti->ti_len;
                        if (i >= ti->ti_len) {
                                tcpstat.tcps_rcvduppack++;
                                tcpstat.tcps_rcvdupbyte += ti->ti_len;
-                               goto drop;
+                               m_freem(m);
+                               return (0);
                        }
                        }
-                       m_adj(dtom(ti), i);
+                       m_adj(m, i);
                        ti->ti_len -= i;
                        ti->ti_seq += i;
                }
                        ti->ti_len -= i;
                        ti->ti_seq += i;
                }
@@ -108,6 +117,7 @@ tcp_reass(tp, ti)
        }
        tcpstat.tcps_rcvoopack++;
        tcpstat.tcps_rcvoobyte += ti->ti_len;
        }
        tcpstat.tcps_rcvoopack++;
        tcpstat.tcps_rcvoobyte += ti->ti_len;
+       REASS_MBUF(ti) = m;             /* XXX */
 
        /*
         * While we overlap succeeding segments trim them or,
 
        /*
         * While we overlap succeeding segments trim them or,
@@ -120,11 +130,11 @@ tcp_reass(tp, ti)
                if (i < q->ti_len) {
                        q->ti_seq += i;
                        q->ti_len -= i;
                if (i < q->ti_len) {
                        q->ti_seq += i;
                        q->ti_len -= i;
-                       m_adj(dtom(q), i);
+                       m_adj(REASS_MBUF(q), i);
                        break;
                }
                q = (struct tcpiphdr *)q->ti_next;
                        break;
                }
                q = (struct tcpiphdr *)q->ti_next;
-               m = dtom(q->ti_prev);
+               m = REASS_MBUF((struct tcpiphdr *)q->ti_prev);
                remque(q->ti_prev);
                m_freem(m);
        }
                remque(q->ti_prev);
                m_freem(m);
        }
@@ -150,7 +160,7 @@ present:
                tp->rcv_nxt += ti->ti_len;
                flags = ti->ti_flags & TH_FIN;
                remque(ti);
                tp->rcv_nxt += ti->ti_len;
                flags = ti->ti_flags & TH_FIN;
                remque(ti);
-               m = dtom(ti);
+               m = REASS_MBUF(ti);
                ti = (struct tcpiphdr *)ti->ti_next;
                if (so->so_state & SS_CANTRCVMORE)
                        m_freem(m);
                ti = (struct tcpiphdr *)ti->ti_next;
                if (so->so_state & SS_CANTRCVMORE)
                        m_freem(m);
@@ -159,21 +169,18 @@ present:
        } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
        sorwakeup(so);
        return (flags);
        } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
        sorwakeup(so);
        return (flags);
-drop:
-       m_freem(dtom(ti));
-       return (0);
 }
 
 /*
  * 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;
 {
        register struct tcpiphdr *ti;
-       struct inpcb *inp;
-       register struct mbuf *m;
+       register struct inpcb *inp;
        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;
@@ -190,11 +197,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_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;
@@ -207,27 +213,21 @@ 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;
+       HTONS(ti->ti_len);
+       if (ti->ti_sum = in_cksum(m, len)) {
+               tcpstat.tcps_rcvbadsum++;
+               goto drop;
        }
 
        /*
         * Check that TCP offset makes sense,
        }
 
        /*
         * Check that TCP offset makes sense,
-        * pull out TCP options and adjust length.
+        * pull out TCP options and adjust length.              XXX
         */
        off = ti->ti_off << 2;
        if (off < sizeof (struct tcphdr) || off > tlen) {
         */
        off = ti->ti_off << 2;
        if (off < sizeof (struct tcphdr) || off > tlen) {
-               if (tcpprintfs)
-                       printf("tcp off: src %x off %d\n", ti->ti_src, off);
                tcpstat.tcps_rcvbadoff++;
                goto drop;
        }
                tcpstat.tcps_rcvbadoff++;
                goto drop;
        }
@@ -248,33 +248,36 @@ 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)));
                }
        }
        tiflags = ti->ti_flags;
 
                  bcopy(op+om->m_len, op,
                   (unsigned)(m->m_len-sizeof (struct tcpiphdr)));
                }
        }
        tiflags = ti->ti_flags;
 
-       /*
-        * Drop TCP and IP headers; TCP options were dropped above.
-        */
-       m->m_off += sizeof(struct tcpiphdr);
-       m->m_len -= sizeof(struct tcpiphdr);
-
        /*
         * Convert TCP protocol specific fields to host format.
         */
        /*
         * Convert TCP protocol specific fields to host format.
         */
-       ti->ti_seq = ntohl(ti->ti_seq);
-       ti->ti_ack = ntohl(ti->ti_ack);
-       ti->ti_win = ntohs(ti->ti_win);
-       ti->ti_urp = ntohs(ti->ti_urp);
+       NTOHL(ti->ti_seq);
+       NTOHL(ti->ti_ack);
+       NTOHS(ti->ti_win);
+       NTOHS(ti->ti_urp);
 
        /*
         * Locate pcb for segment.
         */
 findpcb:
 
        /*
         * Locate pcb for segment.
         */
 findpcb:
-       inp = in_pcblookup
-               (&tcb, ti->ti_src, ti->ti_sport, ti->ti_dst, ti->ti_dport,
-               INPLOOKUP_WILDCARD);
+       inp = tcp_last_inpcb;
+       if (inp->inp_lport != ti->ti_dport ||
+           inp->inp_fport != ti->ti_sport ||
+           inp->inp_faddr.s_addr != ti->ti_src.s_addr ||
+           inp->inp_laddr.s_addr != ti->ti_dst.s_addr) {
+               inp = in_pcblookup(&tcb, ti->ti_src, ti->ti_sport,
+                   ti->ti_dst, ti->ti_dport, INPLOOKUP_WILDCARD);
+               if (inp)
+                       tcp_last_inpcb = inp;
+               ++tcppcbcachemiss;
+       }
 
        /*
         * If the state is CLOSED (i.e., TCB does not exist) then
 
        /*
         * If the state is CLOSED (i.e., TCB does not exist) then
@@ -290,32 +293,36 @@ findpcb:
        if (tp->t_state == TCPS_CLOSED)
                goto drop;
        so = inp->inp_socket;
        if (tp->t_state == TCPS_CLOSED)
                goto drop;
        so = inp->inp_socket;
-       if (so->so_options & SO_DEBUG) {
-               ostate = tp->t_state;
-               tcp_saveti = *ti;
-       }
-       if (so->so_options & SO_ACCEPTCONN) {
-               so = sonewconn(so);
-               if (so == 0)
-                       goto drop;
-               /*
-                * This is ugly, but ....
-                *
-                * Mark socket as temporary until we're
-                * committed to keeping it.  The code at
-                * ``drop'' and ``dropwithreset'' check the
-                * flag dropsocket to see if the temporary
-                * socket created here should be discarded.
-                * We mark the socket as discardable until
-                * we're committed to it below in TCPS_LISTEN.
-                */
-               dropsocket++;
-               inp = (struct inpcb *)so->so_pcb;
-               inp->inp_laddr = ti->ti_dst;
-               inp->inp_lport = ti->ti_dport;
-               inp->inp_options = ip_srcroute();
-               tp = intotcpcb(inp);
-               tp->t_state = TCPS_LISTEN;
+       if (so->so_options & (SO_DEBUG|SO_ACCEPTCONN)) {
+               if (so->so_options & SO_DEBUG) {
+                       ostate = tp->t_state;
+                       tcp_saveti = *ti;
+               }
+               if (so->so_options & SO_ACCEPTCONN) {
+                       so = sonewconn(so, 0);
+                       if (so == 0)
+                               goto drop;
+                       /*
+                        * This is ugly, but ....
+                        *
+                        * Mark socket as temporary until we're
+                        * committed to keeping it.  The code at
+                        * ``drop'' and ``dropwithreset'' check the
+                        * flag dropsocket to see if the temporary
+                        * socket created here should be discarded.
+                        * We mark the socket as discardable until
+                        * we're committed to it below in TCPS_LISTEN.
+                        */
+                       dropsocket++;
+                       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();
+#endif
+                       tp = intotcpcb(inp);
+                       tp->t_state = TCPS_LISTEN;
+               }
        }
 
        /*
        }
 
        /*
@@ -323,7 +330,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,
@@ -333,6 +340,92 @@ findpcb:
                tcp_dooptions(tp, om, ti);
                om = 0;
        }
                tcp_dooptions(tp, om, ti);
                om = 0;
        }
+       /* 
+        * Header prediction: check for the two common cases
+        * of a uni-directional data xfer.  If the packet has
+        * no control flags, is in-sequence, the window didn't
+        * change and we're not retransmitting, it's a
+        * candidate.  If the length is zero and the ack moved
+        * forward, we're the sender side of the xfer.  Just
+        * free the data acked & wake any higher level process
+        * that was blocked waiting for space.  If the length
+        * is non-zero and the ack didn't move, we're the
+        * receiver side.  If we're getting packets in-order
+        * (the reassembly queue is empty), add the data to
+        * the socket buffer and note that we need a delayed ack.
+        */
+       if (tp->t_state == TCPS_ESTABLISHED &&
+           (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
+           ti->ti_seq == tp->rcv_nxt &&
+           ti->ti_win && ti->ti_win == tp->snd_wnd &&
+           tp->snd_nxt == tp->snd_max) {
+               if (ti->ti_len == 0) {
+                       if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
+                           SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
+                           tp->snd_cwnd >= tp->snd_wnd) {
+                               /*
+                                * this is a pure ack for outstanding data.
+                                */
+                               ++tcppredack;
+                               if (tp->t_rtt && SEQ_GT(ti->ti_ack,tp->t_rtseq))
+                                       tcp_xmit_timer(tp);
+                               acked = ti->ti_ack - tp->snd_una;
+                               tcpstat.tcps_rcvackpack++;
+                               tcpstat.tcps_rcvackbyte += acked;
+                               sbdrop(&so->so_snd, acked);
+                               tp->snd_una = ti->ti_ack;
+                               m_freem(m);
+
+                               /*
+                                * If all outstanding data are acked, stop
+                                * retransmit timer, otherwise restart timer
+                                * using current (possibly backed-off) value.
+                                * If process is waiting for space,
+                                * wakeup/selwakeup/signal.  If data
+                                * are ready to send, let tcp_output
+                                * decide between more output or persist.
+                                */
+                               if (tp->snd_una == tp->snd_max)
+                                       tp->t_timer[TCPT_REXMT] = 0;
+                               else if (tp->t_timer[TCPT_PERSIST] == 0)
+                                       tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
+
+                               if (so->so_snd.sb_flags & SB_NOTIFY)
+                                       sowwakeup(so);
+                               if (so->so_snd.sb_cc)
+                                       (void) tcp_output(tp);
+                               return;
+                       }
+               } else if (ti->ti_ack == tp->snd_una &&
+                   tp->seg_next == (struct tcpiphdr *)tp &&
+                   ti->ti_len <= sbspace(&so->so_rcv)) {
+                       /*
+                        * this is a pure, in-sequence data packet
+                        * with nothing on the reassembly queue and
+                        * we have enough buffer space to take it.
+                        */
+                       ++tcppreddat;
+                       tp->rcv_nxt += ti->ti_len;
+                       tcpstat.tcps_rcvpack++;
+                       tcpstat.tcps_rcvbyte += ti->ti_len;
+                       /*
+                        * Drop TCP and IP headers then add data
+                        * to socket buffer
+                        */
+                       m->m_data += sizeof(struct tcpiphdr);
+                       m->m_len -= sizeof(struct tcpiphdr);
+                       sbappend(&so->so_rcv, m);
+                       sorwakeup(so);
+                       tp->t_flags |= TF_DELACK;
+                       return;
+               }
+       }
+
+       /*
+        * Drop TCP and IP headers; TCP options were dropped above.
+        */
+       m->m_data += sizeof(struct tcpiphdr);
+       m->m_len -= sizeof(struct tcpiphdr);
 
        /*
         * Calculate amount of space in receive window,
 
        /*
         * Calculate amount of space in receive window,
@@ -345,7 +438,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) {
@@ -373,14 +466,15 @@ 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;
                        goto drop;
-               am = m_get(M_DONTWAIT, MT_SONAME);
+               am = m_get(M_DONTWAIT, MT_SONAME);      /* XXX */
                if (am == NULL)
                        goto drop;
                am->m_len = sizeof (struct sockaddr_in);
                sin = mtod(am, struct sockaddr_in *);
                sin->sin_family = AF_INET;
                if (am == NULL)
                        goto drop;
                am->m_len = sizeof (struct sockaddr_in);
                sin = mtod(am, struct sockaddr_in *);
                sin->sin_family = AF_INET;
+               sin->sin_len = sizeof(*sin);
                sin->sin_addr = ti->ti_src;
                sin->sin_port = ti->ti_sport;
                laddr = inp->inp_laddr;
                sin->sin_addr = ti->ti_src;
                sin->sin_port = ti->ti_sport;
                laddr = inp->inp_laddr;
@@ -412,7 +506,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;
@@ -455,20 +549,14 @@ 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));
-                       (void) tcp_reass(tp, (struct tcpiphdr *)0);
+                       (void) tcp_reass(tp, (struct tcpiphdr *)0,
+                               (struct mbuf *)0);
                        /*
                         * if we didn't have to retransmit the SYN,
                         * use its rtt as our initial srtt & rtt var.
                         */
                        /*
                         * 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;
-                       }
+                       if (tp->t_rtt)
+                               tcp_xmit_timer(tp);
                } else
                        tp->t_state = TCPS_SYN_RECEIVED;
 
                } else
                        tp->t_state = TCPS_SYN_RECEIVED;
 
@@ -481,7 +569,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++;
@@ -511,18 +609,28 @@ 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;
-                       todrop = ti->ti_len;
-                       tiflags &= ~TH_FIN;
-                       tp->t_flags |= TF_ACKNOW;
+                          ) {
+                               todrop = ti->ti_len;
+                               tiflags &= ~TH_FIN;
+                               tp->t_flags |= TF_ACKNOW;
+                       } else
+                               goto dropafterack;
                } else {
                        tcpstat.tcps_rcvpartduppack++;
                        tcpstat.tcps_rcvpartdupbyte += todrop;
                } else {
                        tcpstat.tcps_rcvpartduppack++;
                        tcpstat.tcps_rcvpartdupbyte += todrop;
@@ -539,7 +647,7 @@ trimthenstep6:
        }
 
        /*
        }
 
        /*
-        * If new data is received on a connection after the
+        * 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) &&
         * user processes are gone, then RST the other end.
         */
        if ((so->so_state & SS_NOFDREF) &&
@@ -549,68 +657,57 @@ trimthenstep6:
                goto dropwithreset;
        }
 
                goto dropwithreset;
        }
 
-       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_nxt != ti->ti_seq) {
-                       tcpstat.tcps_rcvpackafterwin++;
+       /*
+        * 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;
+                               tp = 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:
@@ -624,14 +721,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:
@@ -673,8 +774,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));
-               (void) tcp_reass(tp, (struct tcpiphdr *)0);
+               (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
                tp->snd_wl1 = ti->ti_seq - 1;
                /* fall into ... */
 
                tp->snd_wl1 = ti->ti_seq - 1;
                /* fall into ... */
 
@@ -698,8 +798,8 @@ do_rst:
                        if (ti->ti_len == 0 && ti->ti_win == tp->snd_wnd) {
                                tcpstat.tcps_rcvdupack++;
                                /*
                        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
+                                * If we have outstanding data (other than
+                                * 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
                                 * duplicate ack (ie, window info didn't
                                 * change), the ack is the biggest we've
                                 * seen and we've seen exactly our rexmt
@@ -707,19 +807,19 @@ do_rst:
                                 * has been dropped and retransmit it.
                                 * Kludge snd_nxt & the congestion
                                 * window so we send only this one
                                 * 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).
+                                * packet.
+                                *
+                                * We know we're losing at the current
+                                * window size so do congestion avoidance
+                                * (set ssthresh to half the current window
+                                * and pull our congestion window back to
+                                * the new ssthresh).
+                                *
+                                * Dup acks mean that packets have left the
+                                * network (they're now cached at the receiver) 
+                                * so bump cwnd by the amount in the receiver
+                                * to keep a constant cwnd packets in the
+                                * network.
                                 */
                                if (tp->t_timer[TCPT_REXMT] == 0 ||
                                    ti->ti_ack != tp->snd_una)
                                 */
                                if (tp->t_timer[TCPT_REXMT] == 0 ||
                                    ti->ti_ack != tp->snd_una)
@@ -727,27 +827,38 @@ do_rst:
                                else if (++tp->t_dupacks == tcprexmtthresh) {
                                        tcp_seq onxt = tp->snd_nxt;
                                        u_int win =
                                else if (++tp->t_dupacks == tcprexmtthresh) {
                                        tcp_seq onxt = tp->snd_nxt;
                                        u_int win =
-                                           MIN(tp->snd_wnd, tp->snd_cwnd) / 2 /
+                                           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_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);
                                        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);
-
+                                       tp->snd_cwnd = tp->snd_ssthresh +
+                                              tp->t_maxseg * tp->t_dupacks;
                                        if (SEQ_GT(onxt, tp->snd_nxt))
                                                tp->snd_nxt = onxt;
                                        goto drop;
                                        if (SEQ_GT(onxt, tp->snd_nxt))
                                                tp->snd_nxt = onxt;
                                        goto drop;
+                               } else if (tp->t_dupacks > tcprexmtthresh) {
+                                       tp->snd_cwnd += tp->t_maxseg;
+                                       (void) tcp_output(tp);
+                                       goto drop;
                                }
                        } else
                                tp->t_dupacks = 0;
                        break;
                }
                                }
                        } else
                                tp->t_dupacks = 0;
                        break;
                }
+               /*
+                * If the congestion window was inflated to account
+                * for the other side's cached packets, retract it.
+                */
+               if (tp->t_dupacks > tcprexmtthresh &&
+                   tp->snd_cwnd > tp->snd_ssthresh)
+                       tp->snd_cwnd = tp->snd_ssthresh;
                tp->t_dupacks = 0;
                if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
                        tcpstat.tcps_rcvacktoomuch++;
                tp->t_dupacks = 0;
                if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
                        tcpstat.tcps_rcvacktoomuch++;
@@ -764,57 +875,8 @@ do_rst:
                 * timer backoff (cf., Phil Karn's retransmit alg.).
                 * Recompute the initial retransmit timer.
                 */
                 * 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_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_rxtshift = 0;
-                       TCPT_RANGESET(tp->t_rxtcur, 
-                           ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
-                           TCPTV_MIN, TCPTV_REXMTMAX);
-               }
+               if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
+                       tcp_xmit_timer(tp);
 
                /*
                 * If all outstanding data is acked, stop retransmit
 
                /*
                 * If all outstanding data is acked, stop retransmit
@@ -831,16 +893,18 @@ do_rst:
                 * 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).
                 * 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).
+                * Otherwise open linearly: maxseg per window
+                * (maxseg^2 / cwnd per packet), plus a constant
+                * fraction of a packet (maxseg/8) to help larger windows
+                * open quickly enough.
                 */
                {
                 */
                {
-               u_int incr = tp->t_maxseg;
-
-               if (tp->snd_cwnd > tp->snd_ssthresh)
-                       incr = MAX(incr * incr / tp->snd_cwnd, 1);
+               register u_int cw = tp->snd_cwnd;
+               register u_int incr = tp->t_maxseg;
 
 
-               tp->snd_cwnd = MIN(tp->snd_cwnd + incr, 65535); /* XXX */
+               if (cw > tp->snd_ssthresh)
+                       incr = incr * incr / cw + incr / 8;
+               tp->snd_cwnd = min(cw + incr, TCP_MAXWIN);
                }
                if (acked > so->so_snd.sb_cc) {
                        tp->snd_wnd -= so->so_snd.sb_cc;
                }
                if (acked > so->so_snd.sb_cc) {
                        tp->snd_wnd -= so->so_snd.sb_cc;
@@ -851,7 +915,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)
+               if (so->so_snd.sb_flags & SB_NOTIFY)
                        sowwakeup(so);
                tp->snd_una = ti->ti_ack;
                if (SEQ_LT(tp->snd_nxt, tp->snd_una))
                        sowwakeup(so);
                tp->snd_una = ti->ti_ack;
                if (SEQ_LT(tp->snd_nxt, tp->snd_una))
@@ -875,7 +939,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;
                        }
@@ -968,8 +1032,8 @@ step6:
                 * the urgent pointer points to the last octet
                 * of urgent data.  We continue, however,
                 * to consider it to indicate the first octet
                 * the urgent pointer points to the last octet
                 * of urgent data.  We continue, however,
                 * to consider it to indicate the first octet
-                * of data past the urgent section
-                * as the original spec states.
+                * of data past the urgent section as the original 
+                * spec states (in one of two places).
                 */
                if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
                        tp->rcv_up = ti->ti_seq + ti->ti_urp;
                 */
                if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
                        tp->rcv_up = ti->ti_seq + ti->ti_urp;
@@ -986,9 +1050,12 @@ 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)
-                       tcp_pulloutofband(so, ti);
+               if (ti->ti_urp <= ti->ti_len
+#ifdef SO_OOBINLINE
+                    && (so->so_options & SO_OOBINLINE) == 0
+#endif
+                    )
+                       tcp_pulloutofband(so, ti, m);
        } else
                /*
                 * If no out of band data is expected,
        } else
                /*
                 * If no out of band data is expected,
@@ -1010,18 +1077,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.
                 */
                len = so->so_rcv.sb_hiwat - (tp->rcv_adv - tp->rcv_nxt);
                /*
                 * 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_adv - tp->rcv_nxt);
-               if (len > tp->max_rcvd)
-                       tp->max_rcvd = len;
        } else {
                m_freem(m);
                tiflags &= ~TH_FIN;
        } else {
                m_freem(m);
                tiflags &= ~TH_FIN;
@@ -1108,14 +1169,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 */
@@ -1144,6 +1205,7 @@ tcp_dooptions(tp, om, ti)
        struct tcpiphdr *ti;
 {
        register u_char *cp;
        struct tcpiphdr *ti;
 {
        register u_char *cp;
+       u_short mss;
        int opt, optlen, cnt;
 
        cp = mtod(om, u_char *);
        int opt, optlen, cnt;
 
        cp = mtod(om, u_char *);
@@ -1162,16 +1224,16 @@ tcp_dooptions(tp, om, ti)
                switch (opt) {
 
                default:
                switch (opt) {
 
                default:
-                       break;
+                       continue;
 
                case TCPOPT_MAXSEG:
                        if (optlen != 4)
                                continue;
                        if (!(ti->ti_flags & TH_SYN))
                                continue;
 
                case TCPOPT_MAXSEG:
                        if (optlen != 4)
                                continue;
                        if (!(ti->ti_flags & TH_SYN))
                                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));
+                       bcopy((char *) cp + 2, (char *) &mss, sizeof(mss));
+                       NTOHS(mss);
+                       (void) tcp_mss(tp, mss);        /* sets t_maxseg */
                        break;
                }
        }
                        break;
                }
        }
@@ -1184,14 +1246,13 @@ tcp_dooptions(tp, om, ti)
  * It is still reflected in the segment length for
  * sequencing purposes.
  */
  * It is still reflected in the segment length for
  * sequencing purposes.
  */
-tcp_pulloutofband(so, ti)
+tcp_pulloutofband(so, ti, m)
        struct socket *so;
        struct tcpiphdr *ti;
        struct socket *so;
        struct tcpiphdr *ti;
-{
        register struct mbuf *m;
        register struct mbuf *m;
+{
        int cnt = ti->ti_urp - 1;
        
        int cnt = ti->ti_urp - 1;
        
-       m = dtom(ti);
        while (cnt >= 0) {
                if (m->m_len > cnt) {
                        char *cp = mtod(m, caddr_t) + cnt;
        while (cnt >= 0) {
                if (m->m_len > cnt) {
                        char *cp = mtod(m, caddr_t) + cnt;
@@ -1212,56 +1273,246 @@ 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.
- *  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.
- *  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.
+ * Collect new round-trip time estimate
+ * and update averages and current timeout.
+ */
+tcp_xmit_timer(tp)
+       register struct tcpcb *tp;
+{
+       register short delta;
+
+       tcpstat.tcps_rttupdated++;
+       if (tp->t_srtt != 0) {
+               /*
+                * 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.
+                */
+               delta = tp->t_rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
+               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 + 4 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 >> TCP_RTTVAR_SHIFT);
+               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 << TCP_RTT_SHIFT;
+               tp->t_rttvar = tp->t_rtt << (TCP_RTTVAR_SHIFT - 1);
+       }
+       tp->t_rtt = 0;
+       tp->t_rxtshift = 0;
+
+       /*
+        * the retransmit should happen at rtt + 4 * rttvar.
+        * Because of the way we do the smoothing, srtt and rttvar
+        * will each average +1/2 tick of bias.  When we compute
+        * the retransmit timer, we want 1/2 tick of rounding and
+        * 1 extra tick because of +-1/2 tick uncertainty in the
+        * firing of the timer.  The bias will give us exactly the
+        * 1.5 tick we need.  But, because the bias is
+        * statistical, we have to test that we don't drop below
+        * the minimum feasible timer (which is 2 ticks).
+        */
+       TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
+           tp->t_rttmin, TCPTV_REXMTMAX);
+       
+       /*
+        * We received an ack for a packet that wasn't retransmitted;
+        * it is probably safe to discard any error indications we've
+        * received recently.  This isn't quite right, but close enough
+        * for now (a route might have failed after we sent a segment,
+        * and the return path might not be symmetrical).
+        */
+       tp->t_softerror = 0;
+}
+
+/*
+ * Determine a reasonable value for maxseg size.
+ * If the route is known, check route for mtu.
+ * If none, use an mss that can be handled on the outgoing
+ * interface without forcing IP to fragment; if bigger than
+ * an mbuf cluster (MCLBYTES), round down to nearest multiple of MCLBYTES
+ * to utilize large mbufs.  If no route is found, route has no mtu,
+ * or the destination isn't local, use a default, hopefully conservative
+ * size (usually 512 or the default IP max size, but no more than the mtu
+ * of the interface), 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.
+ * While looking at the routing entry, we also initialize other path-dependent
+ * parameters from pre-set or cached values in the routing entry.
  */
  */
-tcp_mss(tp)
+
+tcp_mss(tp, offer)
        register struct tcpcb *tp;
        register struct tcpcb *tp;
+       u_short offer;
 {
        struct route *ro;
 {
        struct route *ro;
+       register struct rtentry *rt;
        struct ifnet *ifp;
        struct ifnet *ifp;
-       int mss;
+       register int rtt, mss;
+       u_long bufsize;
        struct inpcb *inp;
        struct inpcb *inp;
+       struct socket *so;
+       extern int tcp_mssdflt, tcp_rttdflt;
 
        inp = tp->t_inpcb;
        ro = &inp->inp_route;
 
        inp = tp->t_inpcb;
        ro = &inp->inp_route;
-       if ((ro->ro_rt == (struct rtentry *)0) ||
-           (ifp = ro->ro_rt->rt_ifp) == (struct ifnet *)0) {
+
+       if ((rt = ro->ro_rt) == (struct rtentry *)0) {
                /* No route yet, so try to acquire one */
                if (inp->inp_faddr.s_addr != INADDR_ANY) {
                        ro->ro_dst.sa_family = AF_INET;
                /* No route yet, so try to acquire one */
                if (inp->inp_faddr.s_addr != INADDR_ANY) {
                        ro->ro_dst.sa_family = AF_INET;
+                       ro->ro_dst.sa_len = sizeof(ro->ro_dst);
                        ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
                                inp->inp_faddr;
                        rtalloc(ro);
                }
                        ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
                                inp->inp_faddr;
                        rtalloc(ro);
                }
-               if ((ro->ro_rt == 0) || (ifp = ro->ro_rt->rt_ifp) == 0)
-                       return (TCP_MSS);
+               if ((rt = ro->ro_rt) == (struct rtentry *)0)
+                       return (tcp_mssdflt);
        }
        }
+       ifp = rt->rt_ifp;
+       so = inp->inp_socket;
 
 
-       mss = ifp->if_mtu - sizeof(struct tcpiphdr);
+#ifdef RTV_MTU /* if route characteristics exist ... */
+       /*
+        * While we're here, check if there's an initial rtt
+        * or rttvar.  Convert from the route-table units
+        * to scaled multiples of the slow timeout timer.
+        */
+       if (tp->t_srtt == 0 && (rtt = rt->rt_rmx.rmx_rtt)) {
+               if (rt->rt_rmx.rmx_locks & RTV_MTU)
+                       tp->t_rttmin = rtt / (RTM_RTTUNIT / PR_SLOWHZ);
+               tp->t_srtt = rtt / (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTT_SCALE));
+               if (rt->rt_rmx.rmx_rttvar)
+                       tp->t_rttvar = rt->rt_rmx.rmx_rttvar /
+                           (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTTVAR_SCALE));
+               else
+                       /* default variation is +- 1 rtt */
+                       tp->t_rttvar =
+                           tp->t_srtt * TCP_RTTVAR_SCALE / TCP_RTT_SCALE;
+               TCPT_RANGESET(tp->t_rxtcur,
+                   ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
+                   tp->t_rttmin, TCPTV_REXMTMAX);
+       }
+       /*
+        * if there's an mtu associated with the route, use it
+        */
+       if (rt->rt_rmx.rmx_mtu)
+               mss = rt->rt_rmx.rmx_mtu - sizeof(struct tcpiphdr);
+       else
+#endif /* RTV_MTU */
+       {
+               mss = ifp->if_mtu - sizeof(struct tcpiphdr);
 #if    (MCLBYTES & (MCLBYTES - 1)) == 0
 #if    (MCLBYTES & (MCLBYTES - 1)) == 0
-       if (mss > MCLBYTES)
-               mss &= ~(MCLBYTES-1);
+               if (mss > MCLBYTES)
+                       mss &= ~(MCLBYTES-1);
 #else
 #else
-       if (mss > MCLBYTES)
-               mss = mss / MCLBYTES * MCLBYTES;
+               if (mss > MCLBYTES)
+                       mss = mss / MCLBYTES * MCLBYTES;
 #endif
 #endif
-       if (in_localaddr(inp->inp_faddr))
-               return (mss);
+               if (!in_localaddr(inp->inp_faddr))
+                       mss = min(mss, tcp_mssdflt);
+       }
+       /*
+        * The current mss, t_maxseg, is initialized to the default value.
+        * If we compute a smaller value, reduce the current mss.
+        * If we compute a larger value, return it for use in sending
+        * a max seg size option, but don't store it for use
+        * unless we received an offer at least that large from peer.
+        * However, do not accept offers under 32 bytes.
+        */
+       if (offer)
+               mss = min(mss, offer);
+       mss = max(mss, 32);             /* sanity */
+       if (mss < tp->t_maxseg || offer != 0) {
+               /*
+                * If there's a pipesize, change the socket buffer
+                * to that size.  Make the socket buffers an integral
+                * number of mss units; if the mss is larger than
+                * the socket buffer, decrease the mss.
+                */
+#ifdef RTV_SPIPE
+               if ((bufsize = rt->rt_rmx.rmx_sendpipe) == 0)
+#endif
+                       bufsize = so->so_snd.sb_hiwat;
+               if (bufsize < mss)
+                       mss = bufsize;
+               else {
+                       bufsize = min(bufsize, SB_MAX) / mss * mss;
+                       (void) sbreserve(&so->so_snd, bufsize);
+               }
+               tp->t_maxseg = mss;
 
 
-       mss = MIN(mss, TCP_MSS);
+#ifdef RTV_RPIPE
+               if ((bufsize = rt->rt_rmx.rmx_recvpipe) == 0)
+#endif
+                       bufsize = so->so_rcv.sb_hiwat;
+               if (bufsize > mss) {
+                       bufsize = min(bufsize, SB_MAX) / mss * mss;
+                       (void) sbreserve(&so->so_rcv, bufsize);
+               }
+       }
        tp->snd_cwnd = mss;
        tp->snd_cwnd = mss;
+
+#ifdef RTV_SSTHRESH
+       if (rt->rt_rmx.rmx_ssthresh) {
+               /*
+                * There's some sort of gateway or interface
+                * buffer limit on the path.  Use this to set
+                * the slow start threshhold, but set the
+                * threshold to no less than 2*mss.
+                */
+               tp->snd_ssthresh = max(2 * mss, rt->rt_rmx.rmx_ssthresh);
+       }
+#endif /* RTV_MTU */
        return (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