Subversion Repositories openrisc

//==========================================================================

//

//      src/sys/netinet/tcp_subr.c

//

//==========================================================================

//####BSDCOPYRIGHTBEGIN####

//

// -------------------------------------------

//

// Portions of this software may have been derived from OpenBSD, 

// FreeBSD or other sources, and are covered by the appropriate

// copyright disclaimers included herein.

//

// Portions created by Red Hat are

// Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.

//

// -------------------------------------------

//

//####BSDCOPYRIGHTEND####

//==========================================================================

/*

 * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1995

 *      The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *      This product includes software developed by the University of

 *      California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *      @(#)tcp_subr.c  8.2 (Berkeley) 5/24/95

 * $FreeBSD: src/sys/netinet/tcp_subr.c,v 1.73.2.22 2001/08/22 00:59:12 silby Exp $

 */

#include <sys/param.h>

#include <sys/malloc.h>

#include <sys/mbuf.h>

#ifdef INET6

#include <sys/domain.h>

#endif

#include <sys/socket.h>

#include <sys/socketvar.h>

#include <sys/protosw.h>

#include <net/route.h>

#include <net/if.h>

#define _IP_VHL

#include <netinet/in.h>

#include <netinet/in_systm.h>

#include <netinet/ip.h>

#ifdef INET6

#include <netinet/ip6.h>

#endif

#include <netinet/in_pcb.h>

#ifdef INET6

#include <netinet6/in6_pcb.h>

#endif

#include <netinet/in_var.h>

#include <netinet/ip_var.h>

#ifdef INET6

#include <netinet6/ip6_var.h>

#endif

#include <netinet/tcp.h>

#include <netinet/tcp_fsm.h>

#include <netinet/tcp_seq.h>

#include <netinet/tcp_timer.h>

#include <netinet/tcp_var.h>

#ifdef INET6

#include <netinet6/tcp6_var.h>

#include <netinet6/ip6protosw.h>

#endif

#include <netinet/tcpip.h>

#ifdef TCPDEBUG

#include <netinet/tcp_debug.h>

#endif

#ifdef IPSEC

#include <netinet6/ipsec.h>

#endif /*IPSEC*/

#include <sys/md5.h>

int     tcp_mssdflt = TCP_MSS;

#ifdef INET6

int     tcp_v6mssdflt = TCP6_MSS;

#endif

#if 0

static int      tcp_rttdflt = TCPTV_SRTTDFLT / PR_SLOWHZ;

#endif

static int      tcp_do_rfc1323 = 1;

static int      tcp_do_rfc1644 = 0;

static int      tcp_tcbhashsize = 0;

static int      do_tcpdrain = 1;

static int      icmp_may_rst = 1;

static int      tcp_strict_rfc1948 = 0;

static int      tcp_isn_reseed_interval = 0;

static void     tcp_cleartaocache __P((void));

static void     tcp_notify __P((struct inpcb *, int));

/*

 * Target size of TCP PCB hash tables. Must be a power of two.

 *

 * Note that this can be overridden by the kernel environment

 * variable net.inet.tcp.tcbhashsize

 */

#ifndef TCBHASHSIZE

#define TCBHASHSIZE     512

#endif

/*

 * This is the actual shape of what we allocate using the zone

 * allocator.  Doing it this way allows us to protect both structures

 * using the same generation count, and also eliminates the overhead

 * of allocating tcpcbs separately.  By hiding the structure here,

 * we avoid changing most of the rest of the code (although it needs

 * to be changed, eventually, for greater efficiency).

 */

#define ALIGNMENT       32

#define ALIGNM1         (ALIGNMENT - 1)

struct  inp_tp {

        union {

                struct  inpcb inp;

                char    align[(sizeof(struct inpcb) + ALIGNM1) & ~ALIGNM1];

        } inp_tp_u;

        struct  tcpcb tcb;

        struct  callout inp_tp_rexmt, inp_tp_persist, inp_tp_keep, inp_tp_2msl;

        struct  callout inp_tp_delack;

};

#undef ALIGNMENT

#undef ALIGNM1

/*

 * Tcp initialization

 */

void

tcp_init()

{

        int hashsize = TCBHASHSIZE;

        tcp_ccgen = 1;

        tcp_cleartaocache();

        tcp_delacktime = TCPTV_DELACK;

        tcp_keepinit = TCPTV_KEEP_INIT;

        tcp_keepidle = TCPTV_KEEP_IDLE;

        tcp_keepintvl = TCPTV_KEEPINTVL;

        tcp_maxpersistidle = TCPTV_KEEP_IDLE;

        tcp_msl = TCPTV_MSL;

        LIST_INIT(&tcb);

        tcbinfo.listhead = &tcb;

        tcp_tcbhashsize = hashsize;

        tcbinfo.hashbase = hashinit(hashsize, M_PCB, &tcbinfo.hashmask);

        tcbinfo.porthashbase = hashinit(hashsize, M_PCB,

                                        &tcbinfo.porthashmask);

        tcbinfo.ipi_zone = zinit("tcpcb", sizeof(struct inp_tp), maxsockets,

                                 ZONE_INTERRUPT, 0);

#ifdef INET6

#define TCP_MINPROTOHDR (sizeof(struct ip6_hdr) + sizeof(struct tcphdr))

#else /* INET6 */

#define TCP_MINPROTOHDR (sizeof(struct tcpiphdr))

#endif /* INET6 */

        if (max_protohdr < TCP_MINPROTOHDR)

                max_protohdr = TCP_MINPROTOHDR;

        if (max_linkhdr + TCP_MINPROTOHDR > MHLEN)

                panic("tcp_init");

#undef TCP_MINPROTOHDR

}

/*

 * Fill in the IP and TCP headers for an outgoing packet, given the tcpcb.

 * tcp_template used to store this data in mbufs, but we now recopy it out

 * of the tcpcb each time to conserve mbufs.

 */

void

tcp_fillheaders(tp, ip_ptr, tcp_ptr)

        struct tcpcb *tp;

        void *ip_ptr;

        void *tcp_ptr;

{

        struct inpcb *inp = tp->t_inpcb;

        struct tcphdr *tcp_hdr = (struct tcphdr *)tcp_ptr;

#ifdef INET6

        if ((inp->inp_vflag & INP_IPV6) != 0) {

                struct ip6_hdr *ip6;

                ip6 = (struct ip6_hdr *)ip_ptr;

                ip6->ip6_flow = (ip6->ip6_flow & ~IPV6_FLOWINFO_MASK) |

                        (inp->in6p_flowinfo & IPV6_FLOWINFO_MASK);

                ip6->ip6_vfc = (ip6->ip6_vfc & ~IPV6_VERSION_MASK) |

                        (IPV6_VERSION & IPV6_VERSION_MASK);

                ip6->ip6_nxt = IPPROTO_TCP;

                ip6->ip6_plen = sizeof(struct tcphdr);

                ip6->ip6_src = inp->in6p_laddr;

                ip6->ip6_dst = inp->in6p_faddr;

                tcp_hdr->th_sum = 0;

        } else

#endif

        {

        struct ip *ip = (struct ip *) ip_ptr;

        ip->ip_vhl = IP_VHL_BORING;

        ip->ip_tos = 0;

        ip->ip_len = 0;

        ip->ip_id = 0;

        ip->ip_off = 0;

        ip->ip_ttl = 0;

        ip->ip_sum = 0;

        ip->ip_p = IPPROTO_TCP;

        ip->ip_src = inp->inp_laddr;

        ip->ip_dst = inp->inp_faddr;

        tcp_hdr->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,

                htons(sizeof(struct tcphdr) + IPPROTO_TCP));

        }

        tcp_hdr->th_sport = inp->inp_lport;

        tcp_hdr->th_dport = inp->inp_fport;

        tcp_hdr->th_seq = 0;

        tcp_hdr->th_ack = 0;

        tcp_hdr->th_x2 = 0;

        tcp_hdr->th_off = 5;

        tcp_hdr->th_flags = 0;

        tcp_hdr->th_win = 0;

        tcp_hdr->th_urp = 0;

}

/*

 * Create template to be used to send tcp packets on a connection.

 * Allocates an mbuf and fills in a skeletal tcp/ip header.  The only

 * use for this function is in keepalives, which use tcp_respond.

 */

struct tcptemp *

tcp_maketemplate(tp)

        struct tcpcb *tp;

{

        struct mbuf *m;

        struct tcptemp *n;

        m = m_get(M_DONTWAIT, MT_HEADER);

        if (m == NULL)

                return (0);

        m->m_len = sizeof(struct tcptemp);

        n = mtod(m, struct tcptemp *);

        tcp_fillheaders(tp, (void *)&n->tt_ipgen, (void *)&n->tt_t);

        return (n);

}

/*

 * Send a single message to the TCP at address specified by

 * the given TCP/IP header.  If m == 0, then we make a copy

 * of the tcpiphdr at ti and send directly to the addressed host.

 * This is used to force keep alive messages out using the TCP

 * template for a connection.  If flags are given then we send

 * a message back to the TCP which originated the * segment ti,

 * and discard the mbuf containing it and any other attached mbufs.

 *

 * In any case the ack and sequence number of the transmitted

 * segment are as specified by the parameters.

 *

 * NOTE: If m != NULL, then ti must point to *inside* the mbuf.

 */

void

tcp_respond(tp, ipgen, th, m, ack, seq, flags)

        struct tcpcb *tp;

        void *ipgen;

        register struct tcphdr *th;

        register struct mbuf *m;

        tcp_seq ack, seq;

        int flags;

{

        register int tlen;

        int win = 0;

        struct route *ro = 0;

        struct route sro;

        struct ip *ip;

        struct tcphdr *nth;

#ifdef INET6

#ifdef NEW_STRUCT_ROUTE

        struct route *ro6 = 0;

        struct route sro6;

#else

        struct route_in6 *ro6 = 0;

        struct route_in6 sro6;

#endif

        struct ip6_hdr *ip6;

        int isipv6;

#endif /* INET6 */

        int ipflags = 0;

#ifdef INET6

        isipv6 = IP_VHL_V(((struct ip *)ipgen)->ip_vhl) == 6;

        ip6 = ipgen;

#endif /* INET6 */

        ip = ipgen;

        if (tp) {

                if (!(flags & TH_RST)) {

                        win = sbspace(&tp->t_inpcb->inp_socket->so_rcv);

                        if (win > (long)TCP_MAXWIN << tp->rcv_scale)

                                win = (long)TCP_MAXWIN << tp->rcv_scale;

                }

#ifdef INET6

                if (isipv6)

                        ro6 = &tp->t_inpcb->in6p_route;

                else

#endif /* INET6 */

                ro = &tp->t_inpcb->inp_route;

        } else {

#ifdef INET6

                if (isipv6) {

                        ro6 = &sro6;

                        bzero(ro6, sizeof *ro6);

                } else

#endif /* INET6 */

              {

                ro = &sro;

                bzero(ro, sizeof *ro);

              }

        }

        if (m == 0) {

                m = m_gethdr(M_DONTWAIT, MT_HEADER);

                if (m == NULL)

                        return;

                tlen = 0;

                m->m_data += max_linkhdr;

#ifdef INET6

                if (isipv6) {

                        bcopy((caddr_t)ip6, mtod(m, caddr_t),

                              sizeof(struct ip6_hdr));

                        ip6 = mtod(m, struct ip6_hdr *);

                        nth = (struct tcphdr *)(ip6 + 1);

                } else

#endif /* INET6 */

              {

                bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip));

                ip = mtod(m, struct ip *);

                nth = (struct tcphdr *)(ip + 1);

              }

                bcopy((caddr_t)th, (caddr_t)nth, sizeof(struct tcphdr));

                flags = TH_ACK;

        } else {

                m_freem(m->m_next);

                m->m_next = 0;

                m->m_data = (caddr_t)ipgen;

                /* m_len is set later */

                tlen = 0;

#define xchg(a,b,type) { type t; t=a; a=b; b=t; }

#ifdef INET6

                if (isipv6) {

                        xchg(ip6->ip6_dst, ip6->ip6_src, struct in6_addr);

                        nth = (struct tcphdr *)(ip6 + 1);

                } else

#endif /* INET6 */

              {

                xchg(ip->ip_dst.s_addr, ip->ip_src.s_addr, n_long);

                nth = (struct tcphdr *)(ip + 1);

              }

                if (th != nth) {

                        /*

                         * this is usually a case when an extension header

                         * exists between the IPv6 header and the

                         * TCP header.

                         */

                        nth->th_sport = th->th_sport;

                        nth->th_dport = th->th_dport;

                }

                xchg(nth->th_dport, nth->th_sport, n_short);

#undef xchg

        }

#ifdef INET6

        if (isipv6) {

                ip6->ip6_plen = htons((u_short)(sizeof (struct tcphdr) +

                                                tlen));

                tlen += sizeof (struct ip6_hdr) + sizeof (struct tcphdr);

        } else

#endif

      {

        tlen += sizeof (struct tcpiphdr);

        ip->ip_len = tlen;

        ip->ip_ttl = ip_defttl;

      }

        m->m_len = tlen;

        m->m_pkthdr.len = tlen;

        m->m_pkthdr.rcvif = (struct ifnet *) 0;

        nth->th_seq = htonl(seq);

        nth->th_ack = htonl(ack);

        nth->th_x2 = 0;

        nth->th_off = sizeof (struct tcphdr) >> 2;

        nth->th_flags = flags;

        if (tp)

                nth->th_win = htons((u_short) (win >> tp->rcv_scale));

        else

                nth->th_win = htons((u_short)win);

        nth->th_urp = 0;

#ifdef INET6

        if (isipv6) {

                nth->th_sum = 0;

                nth->th_sum = in6_cksum(m, IPPROTO_TCP,

                                        sizeof(struct ip6_hdr),

                                        tlen - sizeof(struct ip6_hdr));

                ip6->ip6_hlim = in6_selecthlim(tp ? tp->t_inpcb : NULL,

                                               ro6 && ro6->ro_rt ?

                                               ro6->ro_rt->rt_ifp :

                                               NULL);

        } else

#endif /* INET6 */

      {

        nth->th_sum = in_pseudo(ip->ip_src.s_addr, ip->ip_dst.s_addr,

            htons((u_short)(tlen - sizeof(struct ip) + ip->ip_p)));

        m->m_pkthdr.csum_flags = CSUM_TCP;

        m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);

      }

#ifdef TCPDEBUG

        if (tp == NULL || (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))

                tcp_trace(TA_OUTPUT, 0, tp, mtod(m, void *), th, 0);

#endif

#ifdef IPSEC

        if (ipsec_setsocket(m, tp ? tp->t_inpcb->inp_socket : NULL) != 0) {

                m_freem(m);

                return;

        }

#endif

#ifdef INET6

        if (isipv6) {

                (void)ip6_output(m, NULL, ro6, ipflags, NULL, NULL);

                if (ro6 == &sro6 && ro6->ro_rt) {

                        RTFREE(ro6->ro_rt);

                        ro6->ro_rt = NULL;

                }

        } else

#endif /* INET6 */

      {

        (void) ip_output(m, NULL, ro, ipflags, NULL);

        if (ro == &sro && ro->ro_rt) {

                RTFREE(ro->ro_rt);

                ro->ro_rt = NULL;

        }

      }

}

/*

 * Create a new TCP control block, making an

 * empty reassembly queue and hooking it to the argument

 * protocol control block.  The `inp' parameter must have

 * come from the zone allocator set up in tcp_init().

 */

struct tcpcb *

tcp_newtcpcb(inp)

        struct inpcb *inp;

{

        struct inp_tp *it;

        register struct tcpcb *tp;

#ifdef INET6

        int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;

#endif /* INET6 */

        it = (struct inp_tp *)inp;

        tp = &it->tcb;

        bzero((char *) tp, sizeof(struct tcpcb));

        LIST_INIT(&tp->t_segq);

        tp->t_maxseg = tp->t_maxopd =

#ifdef INET6

                isipv6 ? tcp_v6mssdflt :

#endif /* INET6 */

                tcp_mssdflt;

        /* Set up our timeouts. */

        callout_init(tp->tt_rexmt = &it->inp_tp_rexmt);

        callout_init(tp->tt_persist = &it->inp_tp_persist);

        callout_init(tp->tt_keep = &it->inp_tp_keep);

        callout_init(tp->tt_2msl = &it->inp_tp_2msl);

        callout_init(tp->tt_delack = &it->inp_tp_delack);

        if (tcp_do_rfc1323)

                tp->t_flags = (TF_REQ_SCALE|TF_REQ_TSTMP);

        if (tcp_do_rfc1644)

                tp->t_flags |= TF_REQ_CC;

        tp->t_inpcb = inp;      /* XXX */

        /*

         * Init srtt to TCPTV_SRTTBASE (0), so we can tell that we have no

         * rtt estimate.  Set rttvar so that srtt + 4 * rttvar gives

         * reasonable initial retransmit time.

         */

        tp->t_srtt = TCPTV_SRTTBASE;

        tp->t_rttvar = ((TCPTV_RTOBASE - TCPTV_SRTTBASE) << TCP_RTTVAR_SHIFT) / 4;

        tp->t_rttmin = TCPTV_MIN;

        tp->t_rxtcur = TCPTV_RTOBASE;

        tp->snd_cwnd = TCP_MAXWIN << TCP_MAX_WINSHIFT;

        tp->snd_ssthresh = TCP_MAXWIN << TCP_MAX_WINSHIFT;

        tp->t_rcvtime = ticks;

        /*

         * IPv4 TTL initialization is necessary for an IPv6 socket as well,

         * because the socket may be bound to an IPv6 wildcard address,

         * which may match an IPv4-mapped IPv6 address.

         */

        inp->inp_ip_ttl = ip_defttl;

        inp->inp_ppcb = (caddr_t)tp;

        return (tp);            /* XXX */

}

/*

 * Drop a TCP connection, reporting

 * the specified error.  If connection is synchronized,

 * then send a RST to peer.

 */

struct tcpcb *

tcp_drop(tp, _errno)

        register struct tcpcb *tp;

        int _errno;

{

        struct socket *so = tp->t_inpcb->inp_socket;

        if (TCPS_HAVERCVDSYN(tp->t_state)) {

                tp->t_state = TCPS_CLOSED;

                (void) tcp_output(tp);

                tcpstat.tcps_drops++;

        } else

                tcpstat.tcps_conndrops++;

        if (_errno == ETIMEDOUT && tp->t_softerror)

                _errno = tp->t_softerror;

        so->so_error = _errno;

        return (tcp_close(tp));

}

/*

 * Close a TCP control block:

 *      discard all space held by the tcp

 *      discard internet protocol block

 *      wake up any sleepers

 */

struct tcpcb *

tcp_close(tp)

        register struct tcpcb *tp;

{

        register struct tseg_qent *q;

        struct inpcb *inp = tp->t_inpcb;

        struct socket *so = inp->inp_socket;

#ifdef INET6

        int isipv6 = (inp->inp_vflag & INP_IPV6) != 0;

#endif /* INET6 */

        register struct rtentry *rt;

        int dosavessthresh;

        /*

         * Make sure that all of our timers are stopped before we

         * delete the PCB.

         */

        callout_stop(tp->tt_rexmt);

        callout_stop(tp->tt_persist);

        callout_stop(tp->tt_keep);

        callout_stop(tp->tt_2msl);

        callout_stop(tp->tt_delack);

        /*

         * If we got enough samples through the srtt filter,

         * save the rtt and rttvar in the routing entry.

         * 'Enough' is arbitrarily defined as the 16 samples.

         * 16 samples is enough for the srtt filter to converge

         * to within 5% of the correct value; fewer samples and

         * we could save a very bogus rtt.

         *

         * Don't update the default route's characteristics and don't

         * update anything that the user "locked".

         */

        if (tp->t_rttupdated >= 16) {

                register u_long i = 0;

#ifdef INET6

                if (isipv6) {

                        struct sockaddr_in6 *sin6;

                        if ((rt = inp->in6p_route.ro_rt) == NULL)

                                goto no_valid_rt;

                        sin6 = (struct sockaddr_in6 *)rt_key(rt);

                        if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))

                                goto no_valid_rt;

                }

                else

#endif /* INET6 */              

                if ((rt = inp->inp_route.ro_rt) == NULL ||

                    ((struct sockaddr_in *)rt_key(rt))->sin_addr.s_addr

                    == INADDR_ANY)

                        goto no_valid_rt;

                if ((rt->rt_rmx.rmx_locks & RTV_RTT) == 0) {

                        i = tp->t_srtt *

                            (RTM_RTTUNIT / (hz * TCP_RTT_SCALE));

                        if (rt->rt_rmx.rmx_rtt && i)

                                /*

                                 * filter this update to half the old & half

                                 * the new values, converting scale.

                                 * See route.h and tcp_var.h for a

                                 * description of the scaling constants.

                                 */

                                rt->rt_rmx.rmx_rtt =

                                    (rt->rt_rmx.rmx_rtt + i) / 2;

                        else

                                rt->rt_rmx.rmx_rtt = i;

                        tcpstat.tcps_cachedrtt++;

                }

                if ((rt->rt_rmx.rmx_locks & RTV_RTTVAR) == 0) {

                        i = tp->t_rttvar *

                            (RTM_RTTUNIT / (hz * TCP_RTTVAR_SCALE));

                        if (rt->rt_rmx.rmx_rttvar && i)

                                rt->rt_rmx.rmx_rttvar =

                                    (rt->rt_rmx.rmx_rttvar + i) / 2;

                        else

                                rt->rt_rmx.rmx_rttvar = i;

                        tcpstat.tcps_cachedrttvar++;

                }

                /*

                 * The old comment here said:

                 * update the pipelimit (ssthresh) if it has been updated

                 * already or if a pipesize was specified & the threshhold

                 * got below half the pipesize.  I.e., wait for bad news

                 * before we start updating, then update on both good

                 * and bad news.

                 *

                 * But we want to save the ssthresh even if no pipesize is

                 * specified explicitly in the route, because such

                 * connections still have an implicit pipesize specified

                 * by the global tcp_sendspace.  In the absence of a reliable

                 * way to calculate the pipesize, it will have to do.

                 */

                i = tp->snd_ssthresh;

                if (rt->rt_rmx.rmx_sendpipe != 0)

                        dosavessthresh = (i < rt->rt_rmx.rmx_sendpipe / 2);

                else

                        dosavessthresh = (i < so->so_snd.sb_hiwat / 2);

                if (((rt->rt_rmx.rmx_locks & RTV_SSTHRESH) == 0 &&

                     i != 0 && rt->rt_rmx.rmx_ssthresh != 0)

                    || dosavessthresh) {

                        /*

                         * convert the limit from user data bytes to

                         * packets then to packet data bytes.

                         */

                        i = (i + tp->t_maxseg / 2) / tp->t_maxseg;

                        if (i < 2)

                                i = 2;

                        i *= (u_long)(tp->t_maxseg +

#ifdef INET6

                                      (isipv6 ? sizeof (struct ip6_hdr) +

                                               sizeof (struct tcphdr) :

#endif

                                       sizeof (struct tcpiphdr)

#ifdef INET6

                                       )

#endif

                                      );

                        if (rt->rt_rmx.rmx_ssthresh)

                                rt->rt_rmx.rmx_ssthresh =

                                    (rt->rt_rmx.rmx_ssthresh + i) / 2;