remove fix for acking window probes: don't ack acks!

[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 ad0a397..c092479 100644 (file)
--- a/usr/src/sys/netinet/tcp_input.c
+++ b/usr/src/sys/netinet/tcp_input.c
@@ -1,26 +1,28 @@
-/*     tcp_input.c     1.82    82/10/30        */
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/mbuf.h"
-#include "../h/protosw.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../netinet/in.h"
-#include "../net/route.h"
-#include "../netinet/in_pcb.h"
-#include "../netinet/in_systm.h"
+/*     tcp_input.c     6.9     85/02/12        */
+
+#include "param.h"
+#include "systm.h"
+#include "mbuf.h"
+#include "protosw.h"
+#include "socket.h"
+#include "socketvar.h"
+#include "errno.h"
+

 #include "../net/if.h"
 #include "../net/if.h"

-#include "../netinet/ip.h"
-#include "../netinet/ip_var.h"
-#include "../netinet/tcp.h"
-#include "../netinet/tcp_fsm.h"
-#include "../netinet/tcp_seq.h"
-#include "../netinet/tcp_timer.h"
-#include "../netinet/tcp_var.h"
-#include "../netinet/tcpip.h"
-#include "../netinet/tcp_debug.h"
-#include <errno.h>
+#include "../net/route.h"
+
+#include "in.h"
+#include "in_pcb.h"
+#include "in_systm.h"
+#include "ip.h"
+#include "ip_var.h"
+#include "tcp.h"
+#include "tcp_fsm.h"
+#include "tcp_seq.h"
+#include "tcp_timer.h"
+#include "tcp_var.h"
+#include "tcpip.h"
+#include "tcp_debug.h"

 
 int    tcpprintfs = 0;
 int    tcpcksum = 1;
 
 int    tcpprintfs = 0;
 int    tcpcksum = 1;


@@ -46,6 +48,7 @@ tcp_input(m0)
        int todrop, acked;
        short ostate;
        struct in_addr laddr;
        int todrop, acked;
        short ostate;
        struct in_addr laddr;

+       int dropsocket = 0;

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


@@ -74,9 +77,9 @@ tcp_input(m0)
                ti->ti_len = (u_short)tlen;
                ti->ti_len = htons((u_short)ti->ti_len);
                if (ti->ti_sum = in_cksum(m, len)) {
                ti->ti_len = (u_short)tlen;
                ti->ti_len = htons((u_short)ti->ti_len);
                if (ti->ti_sum = in_cksum(m, len)) {

-                       tcpstat.tcps_badsum++;

                        if (tcpprintfs)
                        if (tcpprintfs)

-                               printf("tcp cksum %x\n", ti->ti_sum);
+                               printf("tcp sum: src %x\n", ti->ti_src);
+                       tcpstat.tcps_badsum++;

                        goto drop;
                }
        }
                        goto drop;
                }
        }


@@ -87,6 +90,8 @@ tcp_input(m0)
         */
        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_badoff++;
                goto drop;
        }
                tcpstat.tcps_badoff++;
                goto drop;
        }


@@ -95,10 +100,10 @@ tcp_input(m0)
        if (off > sizeof (struct tcphdr)) {
                if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {
                        tcpstat.tcps_hdrops++;
        if (off > sizeof (struct tcphdr)) {
                if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {
                        tcpstat.tcps_hdrops++;

-                       goto drop;
+                       return;

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

-               om = m_get(M_DONTWAIT);
+               om = m_get(M_DONTWAIT, MT_DATA);

                if (om == 0)
                        goto drop;
                om->m_len = off - sizeof (struct tcphdr);
                if (om == 0)
                        goto drop;
                om->m_len = off - sizeof (struct tcphdr);


@@ -151,6 +156,18 @@ tcp_input(m0)
                so = sonewconn(so);
                if (so == 0)
                        goto drop;
                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 = (struct inpcb *)so->so_pcb;
                inp->inp_laddr = ti->ti_dst;
                inp->inp_lport = ti->ti_dport;


@@ -166,10 +183,11 @@ tcp_input(m0)
        tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
 
        /*
        tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
 
        /*

-        * Process options.
+        * Process options if not in LISTEN state,
+        * else do it below (after getting remote address).

         */
         */

-       if (om) {
-               tcp_dooptions(tp, om);
+       if (om && tp->t_state != TCPS_LISTEN) {
+               tcp_dooptions(tp, om, ti);

                om = 0;
        }
 
                om = 0;
        }
 


@@ -196,24 +214,25 @@ tcp_input(m0)
         * segment in this state.
         */
        case TCPS_LISTEN: {
         * segment in this state.
         */
        case TCPS_LISTEN: {

-               struct mbuf *am = m_get(M_DONTWAIT);
+               struct mbuf *am;

                register struct sockaddr_in *sin;
 
                register struct sockaddr_in *sin;
 

-               if (am == 0)
-                       goto drop;
-               am->m_len = sizeof (struct sockaddr_in);

                if (tiflags & TH_RST)
                        goto drop;
                if (tiflags & TH_ACK)
                        goto dropwithreset;
                if ((tiflags & TH_SYN) == 0)
                        goto drop;
                if (tiflags & TH_RST)
                        goto drop;
                if (tiflags & TH_ACK)
                        goto dropwithreset;
                if ((tiflags & TH_SYN) == 0)
                        goto drop;

+               am = m_get(M_DONTWAIT, MT_SONAME);
+               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_addr = ti->ti_src;
                sin->sin_port = ti->ti_sport;
                laddr = inp->inp_laddr;
                sin = mtod(am, struct sockaddr_in *);
                sin->sin_family = AF_INET;
                sin->sin_addr = ti->ti_src;
                sin->sin_port = ti->ti_sport;
                laddr = inp->inp_laddr;

-               if (inp->inp_laddr.s_addr == 0)
+               if (inp->inp_laddr.s_addr == INADDR_ANY)

                        inp->inp_laddr = ti->ti_dst;
                if (in_pcbconnect(inp, am)) {
                        inp->inp_laddr = laddr;
                        inp->inp_laddr = ti->ti_dst;
                if (in_pcbconnect(inp, am)) {
                        inp->inp_laddr = laddr;


@@ -224,16 +243,22 @@ tcp_input(m0)
                tp->t_template = tcp_template(tp);
                if (tp->t_template == 0) {
                        in_pcbdisconnect(inp);
                tp->t_template = tcp_template(tp);
                if (tp->t_template == 0) {
                        in_pcbdisconnect(inp);

+                       dropsocket = 0;         /* socket is already gone */

                        inp->inp_laddr = laddr;
                        tp = 0;
                        goto drop;
                }
                        inp->inp_laddr = laddr;
                        tp = 0;
                        goto drop;
                }

+               if (om) {
+                       tcp_dooptions(tp, om, ti);
+                       om = 0;
+               }

                tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
                tp->irs = ti->ti_seq;
                tcp_sendseqinit(tp);
                tcp_rcvseqinit(tp);
                tp->t_state = TCPS_SYN_RECEIVED;
                tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;
                tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2;
                tp->irs = ti->ti_seq;
                tcp_sendseqinit(tp);
                tcp_rcvseqinit(tp);
                tp->t_state = TCPS_SYN_RECEIVED;
                tp->t_timer[TCPT_KEEP] = TCPTV_KEEP;

+               dropsocket = 0;         /* committed to socket */

                goto trimthenstep6;
                }
 
                goto trimthenstep6;
                }
 


@@ -256,10 +281,8 @@ tcp_input(m0)
                     SEQ_GT(ti->ti_ack, tp->snd_max)))
                        goto dropwithreset;
                if (tiflags & TH_RST) {
                     SEQ_GT(ti->ti_ack, tp->snd_max)))
                        goto dropwithreset;
                if (tiflags & TH_RST) {

-                       if (tiflags & TH_ACK) {
-                               tcp_drop(tp, ECONNREFUSED);
-                               tp = 0;
-                       }
+                       if (tiflags & TH_ACK)
+                               tp = tcp_drop(tp, ECONNREFUSED);

                        goto drop;
                }
                if ((tiflags & TH_SYN) == 0)
                        goto drop;
                }
                if ((tiflags & TH_SYN) == 0)


@@ -274,6 +297,7 @@ tcp_input(m0)
                if (SEQ_GT(tp->snd_una, tp->iss)) {
                        soisconnected(so);
                        tp->t_state = TCPS_ESTABLISHED;
                if (SEQ_GT(tp->snd_una, tp->iss)) {
                        soisconnected(so);
                        tp->t_state = TCPS_ESTABLISHED;

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

                        (void) tcp_reass(tp, (struct tcpiphdr *)0);
                } else
                        tp->t_state = TCPS_SYN_RECEIVED;
                        (void) tcp_reass(tp, (struct tcpiphdr *)0);
                } else
                        tp->t_state = TCPS_SYN_RECEIVED;


@@ -296,6 +320,16 @@ trimthenstep6:
                goto step6;
        }
 
                goto step6;
        }
 

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

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


@@ -359,16 +393,6 @@ trimthenstep6:
                }
        }
 
                }
        }
 

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

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


@@ -382,23 +406,20 @@ trimthenstep6:
        if (tiflags&TH_RST) switch (tp->t_state) {
 
        case TCPS_SYN_RECEIVED:
        if (tiflags&TH_RST) switch (tp->t_state) {
 
        case TCPS_SYN_RECEIVED:

-               tcp_drop(tp, ECONNREFUSED);
-               tp = 0;
+               tp = tcp_drop(tp, ECONNREFUSED);

                goto drop;
 
        case TCPS_ESTABLISHED:
        case TCPS_FIN_WAIT_1:
        case TCPS_FIN_WAIT_2:
        case TCPS_CLOSE_WAIT:
                goto drop;
 
        case TCPS_ESTABLISHED:
        case TCPS_FIN_WAIT_1:
        case TCPS_FIN_WAIT_2:
        case TCPS_CLOSE_WAIT:

-               tcp_drop(tp, ECONNRESET);
-               tp = 0;
+               tp = tcp_drop(tp, ECONNRESET);

                goto drop;
 
        case TCPS_CLOSING:
        case TCPS_LAST_ACK:
        case TCPS_TIME_WAIT:
                goto drop;
 
        case TCPS_CLOSING:
        case TCPS_LAST_ACK:
        case TCPS_TIME_WAIT:

-               tcp_close(tp);
-               tp = 0;
+               tp = tcp_close(tp);

                goto drop;
        }
 
                goto drop;
        }
 


@@ -407,8 +428,7 @@ trimthenstep6:
         * error and we send an RST and drop the connection.
         */
        if (tiflags & TH_SYN) {
         * error and we send an RST and drop the connection.
         */
        if (tiflags & TH_SYN) {

-               tcp_drop(tp, ECONNRESET);
-               tp = 0;
+               tp = tcp_drop(tp, ECONNRESET);

                goto dropwithreset;
        }
 
                goto dropwithreset;
        }
 


@@ -438,6 +458,7 @@ trimthenstep6:
                tp->t_timer[TCPT_REXMT] = 0;
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;
                tp->t_timer[TCPT_REXMT] = 0;
                soisconnected(so);
                tp->t_state = TCPS_ESTABLISHED;

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

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


@@ -476,7 +497,6 @@ trimthenstep6:
                                tp->t_srtt =
                                    tcp_alpha * tp->t_srtt +
                                    (1 - tcp_alpha) * tp->t_rtt;
                                tp->t_srtt =
                                    tcp_alpha * tp->t_srtt +
                                    (1 - tcp_alpha) * tp->t_rtt;

-/* printf("rtt %d srtt*100 now %d\n", tp->t_rtt, (int)(tp->t_srtt*100)); */

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


@@ -485,12 +505,16 @@ trimthenstep6:
                else {
                        TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
                            tcp_beta * tp->t_srtt, TCPTV_MIN, TCPTV_MAX);
                else {
                        TCPT_RANGESET(tp->t_timer[TCPT_REXMT],
                            tcp_beta * tp->t_srtt, TCPTV_MIN, TCPTV_MAX);

-                       tp->t_rtt = 1;

                        tp->t_rxtshift = 0;
                }
                        tp->t_rxtshift = 0;
                }

+               /*
+                * When new data is acked, open the congestion window a bit.
+                */
+               if (acked > 0)
+                       tp->snd_cwnd = MIN(11 * tp->snd_cwnd / 10, 65535);

                if (acked > so->so_snd.sb_cc) {
                if (acked > so->so_snd.sb_cc) {

-                       sbdrop(&so->so_snd, so->so_snd.sb_cc);

                        tp->snd_wnd -= so->so_snd.sb_cc;
                        tp->snd_wnd -= so->so_snd.sb_cc;

+                       sbdrop(&so->so_snd, so->so_snd.sb_cc);

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


@@ -518,6 +542,12 @@ trimthenstep6:
                                if (so->so_state & SS_CANTRCVMORE)
                                        soisdisconnected(so);
                                tp->t_state = TCPS_FIN_WAIT_2;
                                if (so->so_state & SS_CANTRCVMORE)
                                        soisdisconnected(so);
                                tp->t_state = TCPS_FIN_WAIT_2;

+                               /*
+                                * This is contrary to the specification,
+                                * but if we haven't gotten our FIN in 
+                                * 5 minutes, it's not forthcoming.
+                                */
+                               tp->t_timer[TCPT_2MSL] = 5 * 60 * PR_SLOWHZ;

                        }
                        break;
 
                        }
                        break;
 


@@ -543,10 +573,8 @@ trimthenstep6:
                 * and return.
                 */
                case TCPS_LAST_ACK:
                 * and return.
                 */
                case TCPS_LAST_ACK:

-                       if (ourfinisacked) {
-                               tcp_close(tp);
-                               tp = 0;
-                       }
+                       if (ourfinisacked)
+                               tp = tcp_close(tp);

                        goto drop;
 
                /*
                        goto drop;
 
                /*


@@ -580,6 +608,18 @@ step6:
         */
        if ((tiflags & TH_URG) && ti->ti_urp &&
            TCPS_HAVERCVDFIN(tp->t_state) == 0) {
         */
        if ((tiflags & TH_URG) && ti->ti_urp &&
            TCPS_HAVERCVDFIN(tp->t_state) == 0) {

+               /*
+                * This is a kludge, but if we receive accept
+                * random urgent pointers, we'll crash in
+                * soreceive.  It's hard to imagine someone
+                * actually wanting to send this much urgent data.
+                */
+               if (ti->ti_urp + (unsigned) so->so_rcv.sb_cc > 32767) {
+                       ti->ti_urp = 0;                 /* XXX */
+                       tiflags &= ~TH_URG;             /* XXX */
+                       ti->ti_flags &= ~TH_URG;        /* XXX */
+                       goto badurp;                    /* XXX */
+               }

                /*
                 * If this segment advances the known urgent pointer,
                 * then mark the data stream.  This should not happen
                /*
                 * If this segment advances the known urgent pointer,
                 * then mark the data stream.  This should not happen


@@ -605,6 +645,7 @@ step6:
                if (ti->ti_urp <= ti->ti_len)
                        tcp_pulloutofband(so, ti);
        }
                if (ti->ti_urp <= ti->ti_len)
                        tcp_pulloutofband(so, ti);
        }

+badurp:                                                        /* XXX */

 
        /*
         * Process the segment text, merging it into the TCP sequencing queue,
 
        /*
         * Process the segment text, merging it into the TCP sequencing queue,


@@ -698,8 +739,10 @@ dropafterack:
        return;
 
 dropwithreset:
        return;
 
 dropwithreset:

-       if (om)
+       if (om) {

                (void) m_free(om);
                (void) m_free(om);

+               om = 0;
+       }

        /*
         * Generate a RST, dropping incoming segment.
         * Make ACK acceptable to originator of segment.
        /*
         * Generate a RST, dropping incoming segment.
         * Make ACK acceptable to originator of segment.


@@ -714,21 +757,30 @@ dropwithreset:
                tcp_respond(tp, ti, ti->ti_seq+ti->ti_len, (tcp_seq)0,
                    TH_RST|TH_ACK);
        }
                tcp_respond(tp, ti, ti->ti_seq+ti->ti_len, (tcp_seq)0,
                    TH_RST|TH_ACK);
        }

+       /* destroy temporarily created socket */
+       if (dropsocket)
+               (void) soabort(so);

        return;
 
 drop:
        return;
 
 drop:

+       if (om)
+               (void) m_free(om);

        /*
         * Drop space held by incoming segment and return.
         */
        if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
                tcp_trace(TA_DROP, ostate, tp, &tcp_saveti, 0);
        m_freem(m);
        /*
         * Drop space held by incoming segment and return.
         */
        if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
                tcp_trace(TA_DROP, ostate, tp, &tcp_saveti, 0);
        m_freem(m);

+       /* destroy temporarily created socket */
+       if (dropsocket)
+               (void) soabort(so);

        return;
 }
 
        return;
 }
 

-tcp_dooptions(tp, om)
+tcp_dooptions(tp, om, ti)

        struct tcpcb *tp;
        struct mbuf *om;
        struct tcpcb *tp;
        struct mbuf *om;

+       struct tcpiphdr *ti;

 {
        register u_char *cp;
        int opt, optlen, cnt;
 {
        register u_char *cp;
        int opt, optlen, cnt;


@@ -741,8 +793,11 @@ tcp_dooptions(tp, om)
                        break;
                if (opt == TCPOPT_NOP)
                        optlen = 1;
                        break;
                if (opt == TCPOPT_NOP)
                        optlen = 1;

-               else
+               else {

                        optlen = cp[1];
                        optlen = cp[1];

+                       if (optlen <= 0)
+                               break;
+               }

                switch (opt) {
 
                default:
                switch (opt) {
 
                default:


@@ -751,8 +806,11 @@ tcp_dooptions(tp, om)
                case TCPOPT_MAXSEG:
                        if (optlen != 4)
                                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 = *(u_short *)(cp + 2);
                        tp->t_maxseg = ntohs((u_short)tp->t_maxseg);

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

                        break;
                }
        }
                        break;
                }
        }


@@ -886,11 +944,8 @@ present:
                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);

-               else {
-SBCHECK(&so->so_rcv, "tcp_input before");
+               else

                        sbappend(&so->so_rcv, m);
                        sbappend(&so->so_rcv, m);

-SBCHECK(&so->so_rcv, "tcp_input after");
-               }

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


@@ -898,3 +953,51 @@ drop:
        m_freem(dtom(ti));
        return (0);
 }
        m_freem(dtom(ti));
        return (0);
 }

+
+/*
+ *  Determine a reasonable value for maxseg size.
+ *  If the route is known, use one that can be handled
+ *  on the given interface without forcing IP to fragment.
+ *  If bigger than a page (CLSIZE), round down to nearest pagesize
+ *  to utilize pagesize mbufs.
+ *  If interface pointer is unavailable, or the destination isn't local,
+ *  use a conservative size (512 or the default IP max size),
+ *  as we can't discover anything about intervening gateways or networks.
+ *
+ *  This is ugly, and doesn't belong at this level, but has to happen somehow.
+ */
+tcp_mss(tp)
+register struct tcpcb *tp;
+{
+       struct route *ro;
+       struct ifnet *ifp;
+       int mss;
+       struct inpcb *inp;
+
+       inp = tp->t_inpcb;
+       ro = &inp->inp_route;
+       if ((ro->ro_rt == (struct rtentry *)0) ||
+           (ifp = ro->ro_rt->rt_ifp) == (struct ifnet *)0) {
+               /* No route yet, so try to acquire one */
+               if (inp->inp_faddr.s_addr != INADDR_ANY) {
+                       ro->ro_dst.sa_family = AF_INET;
+                       ((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);
+       }
+
+       mss = ifp->if_mtu - sizeof(struct tcpiphdr);
+#if    (CLBYTES & (CLBYTES - 1)) == 0
+       if (mss > CLBYTES)
+               mss &= ~(CLBYTES-1);
+#else
+       if (mss > CLBYTES)
+               mss = mss / CLBYTES * CLBYTES;
+#endif
+       if (in_localaddr(tp->t_inpcb->inp_faddr))
+               return(mss);
+       return (MIN(mss, TCP_MSS));
+}