xnu-2050.18.24.tar.gz

[apple/xnu.git] / bsd / netinet / tcp_output.c

diff --git a/bsd/netinet/tcp_output.c b/bsd/netinet/tcp_output.c
index 69a2c2aedc23cfeee4777fc14b5645180c5828fb..83a205319e79b9cc92ef47eafecf7e7e2b0e6b3e 100644 (file)
--- a/bsd/netinet/tcp_output.c
+++ b/bsd/netinet/tcp_output.c
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2012 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -81,7 +81,10 @@
 #include <sys/socketvar.h>
 
 #include <net/route.h>
 #include <sys/socketvar.h>
 
 #include <net/route.h>

+#include <net/ntstat.h>

 #include <net/if_var.h>
 #include <net/if_var.h>

+#include <net/if.h>
+#include <net/if_types.h>

 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 
 #include <netinet/in.h>
 #include <netinet/in_systm.h>


@@ -89,6 +92,7 @@
 #include <netinet/ip.h>
 #include <netinet/in_pcb.h>
 #include <netinet/ip_var.h>
 #include <netinet/ip.h>
 #include <netinet/in_pcb.h>
 #include <netinet/ip_var.h>

+#include <mach/sdt.h>

 #if INET6
 #include <netinet6/in6_pcb.h>
 #include <netinet/ip6.h>
 #if INET6
 #include <netinet6/in6_pcb.h>
 #include <netinet/ip6.h>


@@ -101,10 +105,12 @@
 #include <netinet/tcp_timer.h>
 #include <netinet/tcp_var.h>
 #include <netinet/tcpip.h>
 #include <netinet/tcp_timer.h>
 #include <netinet/tcp_var.h>
 #include <netinet/tcpip.h>

+#include <netinet/tcp_cc.h>

 #if TCPDEBUG
 #include <netinet/tcp_debug.h>
 #endif
 #include <sys/kdebug.h>
 #if TCPDEBUG
 #include <netinet/tcp_debug.h>
 #endif
 #include <sys/kdebug.h>

+#include <mach/sdt.h>

 
 #if IPSEC
 #include <netinet6/ipsec.h>
 
 #if IPSEC
 #include <netinet6/ipsec.h>


@@ -114,52 +120,77 @@
 #include <security/mac_framework.h>
 #endif /* MAC_SOCKET */
 
 #include <security/mac_framework.h>
 #endif /* MAC_SOCKET */
 

+#include <netinet/lro_ext.h>
+

 #define DBG_LAYER_BEG          NETDBG_CODE(DBG_NETTCP, 1)
 #define DBG_LAYER_END          NETDBG_CODE(DBG_NETTCP, 3)
 #define DBG_FNC_TCP_OUTPUT     NETDBG_CODE(DBG_NETTCP, (4 << 8) | 1)
 
 #define DBG_LAYER_BEG          NETDBG_CODE(DBG_NETTCP, 1)
 #define DBG_LAYER_END          NETDBG_CODE(DBG_NETTCP, 3)
 #define DBG_FNC_TCP_OUTPUT     NETDBG_CODE(DBG_NETTCP, (4 << 8) | 1)
 

-

 #ifdef notyet
 extern struct mbuf *m_copypack();
 #endif
 
 int path_mtu_discovery = 1;
 #ifdef notyet
 extern struct mbuf *m_copypack();
 #endif
 
 int path_mtu_discovery = 1;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, path_mtu_discovery, CTLFLAG_RW,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, path_mtu_discovery, CTLFLAG_RW | CTLFLAG_LOCKED,

        &path_mtu_discovery, 1, "Enable Path MTU Discovery");
 
 int ss_fltsz = 1;
        &path_mtu_discovery, 1, "Enable Path MTU Discovery");
 
 int ss_fltsz = 1;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, slowstart_flightsize, CTLFLAG_RW,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, slowstart_flightsize, CTLFLAG_RW | CTLFLAG_LOCKED,

        &ss_fltsz, 1, "Slow start flight size");
 
 int ss_fltsz_local = 8; /* starts with eight segments max */
        &ss_fltsz, 1, "Slow start flight size");
 
 int ss_fltsz_local = 8; /* starts with eight segments max */

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, local_slowstart_flightsize, CTLFLAG_RW,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, local_slowstart_flightsize, CTLFLAG_RW | CTLFLAG_LOCKED,

        &ss_fltsz_local, 1, "Slow start flight size for local networks");
 
        &ss_fltsz_local, 1, "Slow start flight size for local networks");
 

-int     tcp_do_newreno = 0;
-SYSCTL_INT(_net_inet_tcp, OID_AUTO, newreno, CTLFLAG_RW, &tcp_do_newreno,
-        0, "Enable NewReno Algorithms");
-

 int    tcp_do_tso = 1;
 int    tcp_do_tso = 1;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, tso, CTLFLAG_RW,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, tso, CTLFLAG_RW | CTLFLAG_LOCKED,

        &tcp_do_tso, 0, "Enable TCP Segmentation Offload");
 
 
 int     tcp_ecn_outbound = 0;
        &tcp_do_tso, 0, "Enable TCP Segmentation Offload");
 
 
 int     tcp_ecn_outbound = 0;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, ecn_initiate_out, CTLFLAG_RW, &tcp_ecn_outbound,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, ecn_initiate_out, CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_ecn_outbound,

         0, "Initiate ECN for outbound connections");
 
 int     tcp_ecn_inbound = 0;
         0, "Initiate ECN for outbound connections");
 
 int     tcp_ecn_inbound = 0;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, ecn_negotiate_in, CTLFLAG_RW, &tcp_ecn_inbound,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, ecn_negotiate_in, CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_ecn_inbound,

         0, "Allow ECN negotiation for inbound connections");
 
 int    tcp_packet_chaining = 50;
         0, "Allow ECN negotiation for inbound connections");
 
 int    tcp_packet_chaining = 50;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, packetchain, CTLFLAG_RW, &tcp_packet_chaining,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, packetchain, CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_packet_chaining,

         0, "Enable TCP output packet chaining");
 
 int    tcp_output_unlocked = 1;
         0, "Enable TCP output packet chaining");
 
 int    tcp_output_unlocked = 1;

-SYSCTL_INT(_net_inet_tcp, OID_AUTO, socket_unlocked_on_output, CTLFLAG_RW, &tcp_output_unlocked,
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, socket_unlocked_on_output, CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_output_unlocked,

         0, "Unlock TCP when sending packets down to IP");
 
         0, "Unlock TCP when sending packets down to IP");
 

+int tcp_do_rfc3390 = 1;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, rfc3390, CTLFLAG_RW | CTLFLAG_LOCKED,
+       &tcp_do_rfc3390, 1, "Calculate intial slowstart cwnd depending on MSS");
+
+int tcp_min_iaj_win = MIN_IAJ_WIN;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, min_iaj_win, CTLFLAG_RW | CTLFLAG_LOCKED,
+       &tcp_min_iaj_win, 1, "Minimum recv win based on inter-packet arrival jitter");
+
+int tcp_acc_iaj_react_limit = ACC_IAJ_REACT_LIMIT;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, acc_iaj_react_limit, CTLFLAG_RW | CTLFLAG_LOCKED,
+        &tcp_acc_iaj_react_limit, 1, "Accumulated IAJ when receiver starts to react");
+
+uint32_t tcp_do_autosendbuf = 1;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, doautosndbuf, CTLFLAG_RW | CTLFLAG_LOCKED,
+        &tcp_do_autosendbuf, 1, "Enable send socket buffer auto-tuning");
+
+uint32_t tcp_autosndbuf_inc = 8 * 1024;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, autosndbufinc, CTLFLAG_RW | CTLFLAG_LOCKED,
+        &tcp_autosndbuf_inc, 1, "Increment in send socket bufffer size");
+
+uint32_t tcp_autosndbuf_max = 512 * 1024;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, autosndbufmax, CTLFLAG_RW | CTLFLAG_LOCKED,
+        &tcp_autosndbuf_max, 1, "Maximum send socket buffer size");
+
+uint32_t tcp_prioritize_acks = 1;
+SYSCTL_INT(_net_inet_tcp, OID_AUTO, ack_prioritize, CTLFLAG_RW | CTLFLAG_LOCKED,
+        &tcp_prioritize_acks, 1, "Prioritize pure acks");
+

 static int32_t packchain_newlist = 0;
 static int32_t packchain_looped = 0;
 static int32_t packchain_sent = 0;
 static int32_t packchain_newlist = 0;
 static int32_t packchain_looped = 0;
 static int32_t packchain_sent = 0;


@@ -181,9 +212,14 @@ extern int                 ip_use_randomid;
 #endif /* RANDOM_IP_ID */
 extern u_int32_t dlil_filter_count;
 extern u_int32_t kipf_count;
 #endif /* RANDOM_IP_ID */
 extern u_int32_t dlil_filter_count;
 extern u_int32_t kipf_count;

+extern int tcp_recv_bg;
+extern int maxseg_unacked;

 
 static int tcp_ip_output(struct socket *, struct tcpcb *, struct mbuf *, int,
 
 static int tcp_ip_output(struct socket *, struct tcpcb *, struct mbuf *, int,

-    struct mbuf *, int, int, int32_t);
+    struct mbuf *, int, int, int32_t, boolean_t);
+
+extern uint32_t get_base_rtt(struct tcpcb *tp);
+static struct mbuf* tcp_send_lroacks(struct tcpcb *tp, struct mbuf *m, struct tcphdr *th);

 
 static __inline__ u_int16_t
 get_socket_id(struct socket * s)
 
 static __inline__ u_int16_t
 get_socket_id(struct socket * s)


@@ -217,7 +253,14 @@ get_socket_id(struct socket * s)
  *     ip_output_list:EMSGSIZE
  *     ip_output_list:ENOBUFS
  *     ip_output_list:???              [ignorable: mostly IPSEC/firewall/DLIL]
  *     ip_output_list:EMSGSIZE
  *     ip_output_list:ENOBUFS
  *     ip_output_list:???              [ignorable: mostly IPSEC/firewall/DLIL]

- *     ip6_output:???                  [IPV6 only]
+ *     ip6_output_list:EINVAL
+ *     ip6_output_list:EOPNOTSUPP
+ *     ip6_output_list:EHOSTUNREACH
+ *     ip6_output_list:EADDRNOTAVAIL
+ *     ip6_output_list:ENETUNREACH
+ *     ip6_output_list:EMSGSIZE
+ *     ip6_output_list:ENOBUFS
+ *     ip6_output_list:???             [ignorable: mostly IPSEC/firewall/DLIL]

  */
 int
 tcp_output(struct tcpcb *tp)
  */
 int
 tcp_output(struct tcpcb *tp)


@@ -242,21 +285,24 @@ tcp_output(struct tcpcb *tp)
 #ifdef IPSEC
        unsigned ipsec_optlen = 0;
 #endif
 #ifdef IPSEC
        unsigned ipsec_optlen = 0;
 #endif

-       int maxburst = TCP_MAXBURST;

        int    last_off = 0;
        int    m_off;
        int    last_off = 0;
        int    m_off;

-       struct mbuf *m_last = NULL;
+       int    idle_time = 0;
+       struct mbuf *m_lastm = NULL;

        struct mbuf *m_head = NULL;
        struct mbuf *packetlist = NULL;
        struct mbuf *tp_inp_options = tp->t_inpcb->inp_depend4.inp4_options;
 #if INET6
        int isipv6 = tp->t_inpcb->inp_vflag & INP_IPV6 ;
        struct mbuf *m_head = NULL;
        struct mbuf *packetlist = NULL;
        struct mbuf *tp_inp_options = tp->t_inpcb->inp_depend4.inp4_options;
 #if INET6
        int isipv6 = tp->t_inpcb->inp_vflag & INP_IPV6 ;

-       struct ip6_pktopts *inp6_pktopts = tp->t_inpcb->inp_depend6.inp6_outputopts;

 #endif
        short packchain_listadd = 0;
        u_int16_t       socket_id = get_socket_id(so);
        int so_options = so->so_options;
        struct rtentry *rt;
 #endif
        short packchain_listadd = 0;
        u_int16_t       socket_id = get_socket_id(so);
        int so_options = so->so_options;
        struct rtentry *rt;

+       u_int32_t basertt, svc_flags = 0, allocated_len;
+       u_int32_t lro_ackmore = (tp->t_lropktlen != 0) ? 1 : 0;
+       struct mbuf *mnext = NULL;
+       int sackoptlen = 0;

 
        /*
         * Determine length of data that should be transmitted,
 
        /*
         * Determine length of data that should be transmitted,


@@ -265,28 +311,17 @@ tcp_output(struct tcpcb *tp)
         * to send, then transmit; otherwise, investigate further.
         */
        idle = (tp->t_flags & TF_LASTIDLE) || (tp->snd_max == tp->snd_una);
         * to send, then transmit; otherwise, investigate further.
         */
        idle = (tp->t_flags & TF_LASTIDLE) || (tp->snd_max == tp->snd_una);

-       if (idle && tp->t_rcvtime >= tp->t_rxtcur) {
-               /*
-                * We have been idle for "a while" and no acks are
-                * expected to clock out any data we send --
-                * slow start to get ack "clock" running again.
-                *
-                * Set the slow-start flight size depending on whether
-                * this is a local network or not.
-                */
-               if (
-#if INET6
-                   (isipv6 && in6_localaddr(&tp->t_inpcb->in6p_faddr)) ||
-                   (!isipv6 &&
-#endif
-                    in_localaddr(tp->t_inpcb->inp_faddr)
-#if INET6
-                    )
-#endif
-                   )
-                       tp->snd_cwnd = tp->t_maxseg * ss_fltsz_local;
-               else     
-                       tp->snd_cwnd = tp->t_maxseg * ss_fltsz;
+
+       /* Since idle_time is signed integer, the following integer subtraction
+        * will take care of wrap around of tcp_now
+        */
+       idle_time = tcp_now - tp->t_rcvtime;
+       if (idle && idle_time >= TCP_IDLETIMEOUT(tp)) {
+               if (CC_ALGO(tp)->after_idle != NULL) 
+                       CC_ALGO(tp)->after_idle(tp);
+               DTRACE_TCP5(cc, void, NULL, struct inpcb *, tp->t_inpcb,
+                       struct tcpcb *, tp, struct tcphdr *, NULL,
+                       int32_t, TCP_CC_IDLE_TIMEOUT);

        }
        tp->t_flags &= ~TF_LASTIDLE;
        if (idle) {
        }
        tp->t_flags &= ~TF_LASTIDLE;
        if (idle) {


@@ -300,14 +335,12 @@ again:
 
 #if INET6
        if (isipv6) {
 
 #if INET6
        if (isipv6) {

-       

                KERNEL_DEBUG(DBG_LAYER_BEG,
                     ((tp->t_inpcb->inp_fport << 16) | tp->t_inpcb->inp_lport),
                     (((tp->t_inpcb->in6p_laddr.s6_addr16[0] & 0xffff) << 16) |
                      (tp->t_inpcb->in6p_faddr.s6_addr16[0] & 0xffff)),
                     sendalot,0,0);
                KERNEL_DEBUG(DBG_LAYER_BEG,
                     ((tp->t_inpcb->inp_fport << 16) | tp->t_inpcb->inp_lport),
                     (((tp->t_inpcb->in6p_laddr.s6_addr16[0] & 0xffff) << 16) |
                      (tp->t_inpcb->in6p_faddr.s6_addr16[0] & 0xffff)),
                     sendalot,0,0);

-       }
-       else
+       } else

 #endif
 
        {
 #endif
 
        {


@@ -316,6 +349,7 @@ again:
                     (((tp->t_inpcb->inp_laddr.s_addr & 0xffff) << 16) |
                      (tp->t_inpcb->inp_faddr.s_addr & 0xffff)),
                     sendalot,0,0);
                     (((tp->t_inpcb->inp_laddr.s_addr & 0xffff) << 16) |
                      (tp->t_inpcb->inp_faddr.s_addr & 0xffff)),
                     sendalot,0,0);

+       }

        /*
         * If the route generation id changed, we need to check that our
         * local (source) IP address is still valid. If it isn't either
        /*
         * If the route generation id changed, we need to check that our
         * local (source) IP address is still valid. If it isn't either


@@ -326,7 +360,9 @@ again:
        if (rt != NULL && (!(rt->rt_flags & RTF_UP) ||
            rt->generation_id != route_generation)) {
                struct ifnet *ifp;
        if (rt != NULL && (!(rt->rt_flags & RTF_UP) ||
            rt->generation_id != route_generation)) {
                struct ifnet *ifp;

-               struct in_ifaddr *ia;
+               struct in_ifaddr *ia = NULL;
+               struct in6_ifaddr *ia6 = NULL;
+               int found_srcaddr = 0;

 
                /* disable multipages at the socket */
                somultipages(so, FALSE);
 
                /* disable multipages at the socket */
                somultipages(so, FALSE);


@@ -334,8 +370,21 @@ again:
                /* Disable TSO for the socket until we know more */
                tp->t_flags &= ~TF_TSO;
 
                /* Disable TSO for the socket until we know more */
                tp->t_flags &= ~TF_TSO;
 

+               if (isipv6) {
+                       ia6 = ifa_foraddr6(&tp->t_inpcb->in6p_laddr);
+                       if (ia6 != NULL)
+                               found_srcaddr = 1;
+               } else {
+                       ia = ifa_foraddr(tp->t_inpcb->inp_laddr.s_addr);
+                       if (ia != NULL)
+                               found_srcaddr = 1;
+               }
+

                /* check that the source address is still valid */
                /* check that the source address is still valid */

-               if ((ia = ifa_foraddr(tp->t_inpcb->inp_laddr.s_addr)) == NULL) {
+               if (found_srcaddr == 0) {
+
+                       soevent(so,
+                           (SO_FILT_HINT_LOCKED | SO_FILT_HINT_NOSRCADDR));

 
                        if (tp->t_state >= TCPS_CLOSE_WAIT) {
                                tcp_drop(tp, EADDRNOTAVAIL);
 
                        if (tp->t_state >= TCPS_CLOSE_WAIT) {
                                tcp_drop(tp, EADDRNOTAVAIL);


@@ -344,14 +393,16 @@ again:
 
                        /* set Retransmit  timer if it wasn't set
                         * reset Persist timer and shift register as the
 
                        /* set Retransmit  timer if it wasn't set
                         * reset Persist timer and shift register as the

-                        * adversed peer window may not be valid anymore
+                        * advertised peer window may not be valid anymore

                         */
 
                         if (!tp->t_timer[TCPT_REXMT]) {
                         */
 
                         if (!tp->t_timer[TCPT_REXMT]) {

-                                tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
+                                tp->t_timer[TCPT_REXMT] = OFFSET_FROM_START(tp, tp->t_rxtcur);

                                if (tp->t_timer[TCPT_PERSIST]) {
                                        tp->t_timer[TCPT_PERSIST] = 0;
                                        tp->t_rxtshift = 0;
                                if (tp->t_timer[TCPT_PERSIST]) {
                                        tp->t_timer[TCPT_PERSIST] = 0;
                                        tp->t_rxtshift = 0;

+                                       tp->t_persist_stop = 0;
+                                       tp->rxt_start = 0;

                                }
                        }
 
                                }
                        }
 


@@ -364,10 +415,16 @@ again:
                                tcp_drop(tp, EADDRNOTAVAIL);
                                return(EADDRNOTAVAIL);
                        }
                                tcp_drop(tp, EADDRNOTAVAIL);
                                return(EADDRNOTAVAIL);
                        }

-                       else
+                       else {
+                               tcp_check_timer_state(tp);

                                return(0); /* silently ignore, keep data in socket: address may be back */
                                return(0); /* silently ignore, keep data in socket: address may be back */

+                       }

                }
                }

-               ifafree(&ia->ia_ifa);
+               if (ia != NULL)
+                       IFA_REMREF(&ia->ia_ifa);
+
+               if (ia6 != NULL)
+                       IFA_REMREF(&ia6->ia_ifa);

 
                /*
                 * Address is still valid; check for multipages capability
 
                /*
                 * Address is still valid; check for multipages capability


@@ -395,7 +452,6 @@ again:
                        tp->t_flags |= TF_PMTUD;
 
                RT_UNLOCK(rt);
                        tp->t_flags |= TF_PMTUD;
 
                RT_UNLOCK(rt);

-        }

        }
 
        /*
        }
 
        /*


@@ -454,8 +510,9 @@ again:
                                /* Can rexmit part of the current hole */
                                len = ((int32_t)min(cwin,
                                                   tp->snd_recover - p->rxmit));
                                /* Can rexmit part of the current hole */
                                len = ((int32_t)min(cwin,
                                                   tp->snd_recover - p->rxmit));

-               } else
+               } else {

                        len = ((int32_t)min(cwin, p->end - p->rxmit));
                        len = ((int32_t)min(cwin, p->end - p->rxmit));

+               }

                if (len > 0) {
                        off = p->rxmit - tp->snd_una; /* update off only if we really transmit SACK data */
                        sack_rxmit = 1;
                if (len > 0) {
                        off = p->rxmit - tp->snd_una; /* update off only if we really transmit SACK data */
                        sack_rxmit = 1;


@@ -463,9 +520,17 @@ again:
                        tcpstat.tcps_sack_rexmits++;
                        tcpstat.tcps_sack_rexmit_bytes +=
                            min(len, tp->t_maxseg);
                        tcpstat.tcps_sack_rexmits++;
                        tcpstat.tcps_sack_rexmit_bytes +=
                            min(len, tp->t_maxseg);

-               }
-               else 
+                       if (nstat_collect) {
+                               nstat_route_tx(tp->t_inpcb->inp_route.ro_rt, 1, 
+                                       min(len, tp->t_maxseg), NSTAT_TX_FLAG_RETRANSMIT);
+                               locked_add_64(&tp->t_inpcb->inp_stat->txpackets, 1);
+                               locked_add_64(&tp->t_inpcb->inp_stat->txbytes, 
+                                       min(len, tp->t_maxseg));
+                               tp->t_stat.txretransmitbytes += min(len, tp->t_maxseg);
+                       }
+               } else {

                        len = 0;
                        len = 0;

+               }

        }
 after_sack_rexmit:
        /*
        }
 after_sack_rexmit:
        /*


@@ -507,6 +572,8 @@ after_sack_rexmit:
                } else {
                        tp->t_timer[TCPT_PERSIST] = 0;
                        tp->t_rxtshift = 0;
                } else {
                        tp->t_timer[TCPT_PERSIST] = 0;
                        tp->t_rxtshift = 0;

+                       tp->rxt_start = 0;
+                       tp->t_persist_stop = 0;

                }
        }
 
                }
        }
 


@@ -568,29 +635,39 @@ after_sack_rexmit:
                flags &= ~TH_SYN;
                off--, len++;
                if (len > 0 && tp->t_state == TCPS_SYN_SENT) {
                flags &= ~TH_SYN;
                off--, len++;
                if (len > 0 && tp->t_state == TCPS_SYN_SENT) {

-                       while (!(tp->t_flags & TF_SENDINPROG) &&
-                           tp->t_pktlist_head != NULL) {
+                       while (tp->t_inpcb->inp_sndinprog_cnt == 0 &&
+                               tp->t_pktlist_head != NULL) {

                                packetlist = tp->t_pktlist_head;
                                packchain_listadd = tp->t_lastchain;
                                packchain_sent++;
                                TCP_PKTLIST_CLEAR(tp);
                                packetlist = tp->t_pktlist_head;
                                packchain_listadd = tp->t_lastchain;
                                packchain_sent++;
                                TCP_PKTLIST_CLEAR(tp);

-                               tp->t_flags |= TF_SENDINPROG;

 
                                error = tcp_ip_output(so, tp, packetlist,
                                    packchain_listadd, tp_inp_options,
 
                                error = tcp_ip_output(so, tp, packetlist,
                                    packchain_listadd, tp_inp_options,

-                                   (so_options & SO_DONTROUTE), (sack_rxmit | (sack_bytes_rxmt != 0)), 0);
+                                   (so_options & SO_DONTROUTE),
+                                   (sack_rxmit | (sack_bytes_rxmt != 0)), 0,
+#ifdef INET6
+                                   isipv6);
+#else
+                                   0);
+#endif
+

 
 

-                               tp->t_flags &= ~TF_SENDINPROG;

                        }
                        }

-                       /* tcp was closed while we were in ip; resume close */
-                       if ((tp->t_flags &
-                           (TF_CLOSING|TF_SENDINPROG)) == TF_CLOSING) {
+                       /*
+                        * tcp was closed while we were in ip,
+                        * resume close 
+                        */
+                       if (tp->t_inpcb->inp_sndinprog_cnt == 0 &&
+                               (tp->t_flags & TF_CLOSING)) {

                                tp->t_flags &= ~TF_CLOSING;
                                (void) tcp_close(tp);
                                tp->t_flags &= ~TF_CLOSING;
                                (void) tcp_close(tp);

+                       } else {
+                               tcp_check_timer_state(tp);

                        }
                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END,
                            0,0,0,0,0);
                        }
                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END,
                            0,0,0,0,0);

-                       return 0;
+                       return(0);

                }
        }
 
                }
        }
 


@@ -604,7 +681,12 @@ after_sack_rexmit:
                flags &= ~TH_FIN;
        }
 
                flags &= ~TH_FIN;
        }
 

-       if (len < 0) {
+       /* The check here used to be (len < 0). Some times len is zero when
+        * the congestion window is closed and we need to check if persist timer
+        * has to be set in that case. But don't set persist until connection 
+        * is established.
+        */  
+       if (len <= 0 && !(flags & TH_SYN)) {

                /*
                 * If FIN has been sent but not acked,
                 * but we haven't been called to retransmit,
                /*
                 * If FIN has been sent but not acked,
                 * but we haven't been called to retransmit,


@@ -619,12 +701,53 @@ after_sack_rexmit:
                if (sendwin == 0) {
                        tp->t_timer[TCPT_REXMT] = 0;
                        tp->t_rxtshift = 0;
                if (sendwin == 0) {
                        tp->t_timer[TCPT_REXMT] = 0;
                        tp->t_rxtshift = 0;

+                       tp->rxt_start = 0;

                        tp->snd_nxt = tp->snd_una;
                        if (tp->t_timer[TCPT_PERSIST] == 0)
                                tcp_setpersist(tp);
                }
        }
 
                        tp->snd_nxt = tp->snd_una;
                        if (tp->t_timer[TCPT_PERSIST] == 0)
                                tcp_setpersist(tp);
                }
        }
 

+       /* Automatic sizing of send socket buffer. Increase the send socket buffer
+        * size if all of the following criteria are met
+        *      1. the receiver has enough buffer space for this data
+        *      2. send buffer is filled to 7/8th with data (so we actually
+        *         have data to make use of it);
+        *      3. our send window (slow start and congestion controlled) is
+        *         larger than sent but unacknowledged data in send buffer.
+        */
+       basertt = get_base_rtt(tp);
+       if (tcp_do_autosendbuf == 1 &&
+           !INP_WAIT_FOR_IF_FEEDBACK(tp->t_inpcb) && !IN_FASTRECOVERY(tp) &&
+           (so->so_snd.sb_flags & (SB_AUTOSIZE | SB_TRIM)) == SB_AUTOSIZE &&
+           tcp_cansbgrow(&so->so_snd)) {
+               if ((tp->snd_wnd / 4 * 5) >= so->so_snd.sb_hiwat &&
+                       so->so_snd.sb_cc >= (so->so_snd.sb_hiwat / 8 * 7) &&
+                       sendwin >= (so->so_snd.sb_cc - 
+                               (tp->snd_nxt - tp->snd_una))) {
+                       /* Also increase the send buffer only if the 
+                        * round-trip time is not increasing because we do
+                        * not want to contribute to latency by filling buffers.
+                        * We also do not want to hold onto application's
+                        * old data for too long. Interactive applications would
+                        * rather discard old data.
+                        */
+                       if (tp->t_rttcur <= 
+                               (basertt + 25)) {
+                               if (sbreserve(&so->so_snd, 
+                                       min(so->so_snd.sb_hiwat + tcp_autosndbuf_inc,
+                                       tcp_autosndbuf_max)) == 1) {
+                                       so->so_snd.sb_idealsize = so->so_snd.sb_hiwat;
+                               }
+                       } else {
+                               so->so_snd.sb_idealsize = 
+                                   max(tcp_sendspace, so->so_snd.sb_hiwat -
+                                       (2 * tcp_autosndbuf_inc));
+                               so->so_snd.sb_flags |= SB_TRIM;
+                       }
+               }
+       }
+

        /*
         * Truncate to the maximum segment length or enable TCP Segmentation
         * Offloading (if supported by hardware) and ensure that FIN is removed
        /*
         * Truncate to the maximum segment length or enable TCP Segmentation
         * Offloading (if supported by hardware) and ensure that FIN is removed


@@ -688,47 +811,60 @@ after_sack_rexmit:
         * Sender silly window avoidance.   We transmit under the following
         * conditions when len is non-zero:
         *
         * Sender silly window avoidance.   We transmit under the following
         * conditions when len is non-zero:
         *

+        *      - we've timed out (e.g. persist timer)
+        *      - we need to retransmit

         *      - We have a full segment (or more with TSO)
         *      - This is the last buffer in a write()/send() and we are
         *        either idle or running NODELAY
         *      - We have a full segment (or more with TSO)
         *      - This is the last buffer in a write()/send() and we are
         *        either idle or running NODELAY

-        *      - we've timed out (e.g. persist timer)

         *      - we have more then 1/2 the maximum send window's worth of
         *        data (receiver may be limited the window size)
         *      - we have more then 1/2 the maximum send window's worth of
         *        data (receiver may be limited the window size)

-        *      - we need to retransmit

         */
        if (len) {
         */
        if (len) {

-               if (len >= tp->t_maxseg) {
-                       tp->t_flags |= TF_MAXSEGSNT;
-                       goto send;
-               }
-               if (!(tp->t_flags & TF_MORETOCOME) &&
-                   (idle || tp->t_flags & TF_NODELAY || tp->t_flags & TF_MAXSEGSNT) &&
-                   (tp->t_flags & TF_NOPUSH) == 0 &&
-                   len + off >= so->so_snd.sb_cc) {
-                       tp->t_flags &= ~TF_MAXSEGSNT;
-                       goto send;
-               }

                if (tp->t_force) {
                        tp->t_flags &= ~TF_MAXSEGSNT;
                        goto send;
                }
                if (tp->t_force) {
                        tp->t_flags &= ~TF_MAXSEGSNT;
                        goto send;
                }

-               if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0) {
-                       tp->t_flags &= ~TF_MAXSEGSNT;
-                       goto send;
-               }

                if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {
                if (SEQ_LT(tp->snd_nxt, tp->snd_max)) {

-                       tp->t_flags &= ~TF_MAXSEGSNT;
+                       if (len >= tp->t_maxseg)
+                               tp->t_flags |= TF_MAXSEGSNT;
+                       else
+                               tp->t_flags &= ~TF_MAXSEGSNT;

                        goto send;
                }
                if (sack_rxmit)
                        goto send;
                        goto send;
                }
                if (sack_rxmit)
                        goto send;

+
+               /*
+                * Send new data on the connection only if it is
+                * not flow controlled
+                */
+               if (!INP_WAIT_FOR_IF_FEEDBACK(tp->t_inpcb) ||
+                   tp->t_state != TCPS_ESTABLISHED) {
+                       if (len >= tp->t_maxseg) {
+                               tp->t_flags |= TF_MAXSEGSNT;
+                               goto send;
+                       }
+                       if (!(tp->t_flags & TF_MORETOCOME) &&
+                           (idle || tp->t_flags & TF_NODELAY || tp->t_flags & TF_MAXSEGSNT) &&
+                           (tp->t_flags & TF_NOPUSH) == 0 &&
+                           len + off >= so->so_snd.sb_cc) {
+                               tp->t_flags &= ~TF_MAXSEGSNT;
+                               goto send;
+                       }
+                       if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0) {
+                               tp->t_flags &= ~TF_MAXSEGSNT;
+                               goto send;
+                       }
+               } else {
+                       tcpstat.tcps_fcholdpacket++;
+               }

        }
 
        /*
         * Compare available window to amount of window
         * known to peer (as advertised window less
         * next expected input).  If the difference is at least two
        }
 
        /*
         * Compare available window to amount of window
         * known to peer (as advertised window less
         * next expected input).  If the difference is at least two

-        * max size segments, or at least 50% of the maximum possible
+        * max size segments, or at least 25% of the maximum possible

         * window, then want to send a window update to peer.
         * Skip this if the connection is in T/TCP half-open state.
         */
         * window, then want to send a window update to peer.
         * Skip this if the connection is in T/TCP half-open state.
         */


@@ -742,17 +878,31 @@ after_sack_rexmit:
                        (tp->rcv_adv - tp->rcv_nxt);
 
                if (adv >= (int32_t) (2 * tp->t_maxseg)) {
                        (tp->rcv_adv - tp->rcv_nxt);
 
                if (adv >= (int32_t) (2 * tp->t_maxseg)) {

-                       
-                       /* 
-                        * Update only if the resulting scaled value of the window changed, or
+                       /* Update only if the resulting scaled value of the window changed, or

                         * if there is a change in the sequence since the last ack.
                         * This avoids what appears as dupe ACKS (see rdar://5640997)
                         * if there is a change in the sequence since the last ack.
                         * This avoids what appears as dupe ACKS (see rdar://5640997)

+                        *
+                        * If streaming is detected avoid sending too many window updates.
+                        * We will depend on the delack timer to send a window update
+                        * when needed.

                         */
                         */

-
-                       if ((tp->last_ack_sent != tp->rcv_nxt) || (((recwin + adv) >> tp->rcv_scale) > recwin)) 
+                       if ((tp->t_flags & TF_STRETCHACK) == 0 &&
+                               (tp->last_ack_sent != tp->rcv_nxt || 
+                               ((recwin + adv) >> tp->rcv_scale) > recwin)) {

                                goto send;
                                goto send;

+                       }
+
+                       /* Make sure that the delayed ack timer is set if we
+                        * delayed sending a window update because of streaming
+                        * detection.
+                        */
+                       if ((tp->t_flags & TF_STRETCHACK) != 0 &&
+                               (tp->t_flags & TF_DELACK) == 0) { 
+                               tp->t_flags |= TF_DELACK;
+                               tp->t_timer[TCPT_DELACK] = OFFSET_FROM_START(tp, tcp_delack);
+                       }

                }
                }

-               if (2 * adv >= (int32_t) so->so_rcv.sb_hiwat) 
+               if (4 * adv >= (int32_t) so->so_rcv.sb_hiwat) 

                                goto send;
        }
 
                                goto send;
        }
 


@@ -779,10 +929,11 @@ after_sack_rexmit:
         * after the retransmission timer has been turned off.  Make sure
         * that the retransmission timer is set.
         */
         * after the retransmission timer has been turned off.  Make sure
         * that the retransmission timer is set.
         */

-       if (tp->sack_enable && (tp->t_state >= TCPS_ESTABLISHED) && SEQ_GT(tp->snd_max, tp->snd_una) &&
-               tp->t_timer[TCPT_REXMT] == 0 &&
+       if (tp->sack_enable && (tp->t_state >= TCPS_ESTABLISHED) && 
+           SEQ_GT(tp->snd_max, tp->snd_una) &&
+           tp->t_timer[TCPT_REXMT] == 0 &&

            tp->t_timer[TCPT_PERSIST] == 0) {
            tp->t_timer[TCPT_PERSIST] == 0) {

-                       tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
+                       tp->t_timer[TCPT_REXMT] = OFFSET_FROM_START(tp, tp->t_rxtcur);

                        goto just_return;
        } 
        /*
                        goto just_return;
        } 
        /*


@@ -810,6 +961,7 @@ after_sack_rexmit:
        if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&
            tp->t_timer[TCPT_PERSIST] == 0) {
                tp->t_rxtshift = 0;
        if (so->so_snd.sb_cc && tp->t_timer[TCPT_REXMT] == 0 &&
            tp->t_timer[TCPT_PERSIST] == 0) {
                tp->t_rxtshift = 0;

+               tp->rxt_start = 0;

                tcp_setpersist(tp);
        }
 just_return:
                tcp_setpersist(tp);
        }
 just_return:


@@ -817,22 +969,29 @@ just_return:
         * If there is no reason to send a segment, just return.
         * but if there is some packets left in the packet list, send them now.
         */
         * If there is no reason to send a segment, just return.
         * but if there is some packets left in the packet list, send them now.
         */

-       while (!(tp->t_flags & TF_SENDINPROG) && tp->t_pktlist_head != NULL) {
+       while (tp->t_inpcb->inp_sndinprog_cnt == 0 &&
+               tp->t_pktlist_head != NULL) {

                packetlist = tp->t_pktlist_head;
                packchain_listadd = tp->t_lastchain;
                packchain_sent++;
                TCP_PKTLIST_CLEAR(tp);
                packetlist = tp->t_pktlist_head;
                packchain_listadd = tp->t_lastchain;
                packchain_sent++;
                TCP_PKTLIST_CLEAR(tp);

-               tp->t_flags |= TF_SENDINPROG;

 
                error = tcp_ip_output(so, tp, packetlist, packchain_listadd,
 
                error = tcp_ip_output(so, tp, packetlist, packchain_listadd,

-                   tp_inp_options, (so_options & SO_DONTROUTE), (sack_rxmit | (sack_bytes_rxmt != 0)), recwin);
-
-               tp->t_flags &= ~TF_SENDINPROG;
+                   tp_inp_options, (so_options & SO_DONTROUTE),
+                   (sack_rxmit | (sack_bytes_rxmt != 0)), recwin,
+#ifdef INET6
+                   isipv6);
+#else
+                   0);
+#endif

        }
        /* tcp was closed while we were in ip; resume close */
        }
        /* tcp was closed while we were in ip; resume close */

-       if ((tp->t_flags & (TF_CLOSING|TF_SENDINPROG)) == TF_CLOSING) {
+       if (tp->t_inpcb->inp_sndinprog_cnt == 0 &&
+               (tp->t_flags & TF_CLOSING)) {

                tp->t_flags &= ~TF_CLOSING;
                (void) tcp_close(tp);
                tp->t_flags &= ~TF_CLOSING;
                (void) tcp_close(tp);

+       } else {
+               tcp_check_timer_state(tp);

        }
        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
        return (0);
        }
        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
        return (0);


@@ -852,7 +1011,7 @@ send:
                hdrlen = sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
        else
 #endif
                hdrlen = sizeof (struct ip6_hdr) + sizeof (struct tcphdr);
        else
 #endif

-       hdrlen = sizeof (struct tcpiphdr);
+               hdrlen = sizeof (struct tcpiphdr);

        if (flags & TH_SYN) {
                tp->snd_nxt = tp->iss;
                if ((tp->t_flags & TF_NOOPT) == 0) {
        if (flags & TH_SYN) {
                tp->snd_nxt = tp->iss;
                if ((tp->t_flags & TF_NOOPT) == 0) {


@@ -867,7 +1026,7 @@ send:
                        if ((tp->t_flags & TF_REQ_SCALE) &&
                            ((flags & TH_ACK) == 0 ||
                            (tp->t_flags & TF_RCVD_SCALE))) {
                        if ((tp->t_flags & TF_REQ_SCALE) &&
                            ((flags & TH_ACK) == 0 ||
                            (tp->t_flags & TF_RCVD_SCALE))) {

-                               *((u_int32_t *)(opt + optlen)) = htonl(
+                               *((u_int32_t *)(void *)(opt + optlen)) = htonl(

                                        TCPOPT_NOP << 24 |
                                        TCPOPT_WINDOW << 16 |
                                        TCPOLEN_WINDOW << 8 |
                                        TCPOPT_NOP << 24 |
                                        TCPOPT_WINDOW << 16 |
                                        TCPOLEN_WINDOW << 8 |


@@ -948,7 +1107,7 @@ send:
         * the CWR flag on data packets. Pure acks don't have this set.
         */
        if ((tp->ecn_flags & TE_SENDCWR) != 0 && len != 0 &&
         * the CWR flag on data packets. Pure acks don't have this set.
         */
        if ((tp->ecn_flags & TE_SENDCWR) != 0 && len != 0 &&

-               !SEQ_LT(tp->snd_nxt, tp->snd_max)) {
+               !SEQ_LT(tp->snd_nxt, tp->snd_max) && !sack_rxmit) {

                flags |= TH_CWR;
                tp->ecn_flags &= ~TE_SENDCWR;
        }
                flags |= TH_CWR;
                tp->ecn_flags &= ~TE_SENDCWR;
        }


@@ -969,7 +1128,7 @@ send:
            (flags & TH_RST) == 0 &&
            ((flags & TH_ACK) == 0 ||
             (tp->t_flags & TF_RCVD_TSTMP))) {
            (flags & TH_RST) == 0 &&
            ((flags & TH_ACK) == 0 ||
             (tp->t_flags & TF_RCVD_TSTMP))) {

-               u_int32_t *lp = (u_int32_t *)(opt + optlen);
+               u_int32_t *lp = (u_int32_t *)(void *)(opt + optlen);

 
                /* Form timestamp option as shown in appendix A of RFC 1323. */
                *lp++ = htonl(TCPOPT_TSTAMP_HDR);
 
                /* Form timestamp option as shown in appendix A of RFC 1323. */
                *lp++ = htonl(TCPOPT_TSTAMP_HDR);


@@ -978,6 +1137,10 @@ send:
                optlen += TCPOLEN_TSTAMP_APPA;
        }
 
                optlen += TCPOLEN_TSTAMP_APPA;
        }
 

+       /* Note the timestamp for receive buffer autosizing */
+       if (tp->rfbuf_ts == 0 && (so->so_rcv.sb_flags & SB_AUTOSIZE))
+               tp->rfbuf_ts = tcp_now;
+

        if (tp->sack_enable && ((tp->t_flags & TF_NOOPT) == 0)) {
                /* 
                 * Tack on the SACK permitted option *last*.
        if (tp->sack_enable && ((tp->t_flags & TF_NOOPT) == 0)) {
                /* 
                 * Tack on the SACK permitted option *last*.


@@ -1019,7 +1182,7 @@ send:
                if (TCPS_HAVEESTABLISHED(tp->t_state) &&
                    (tp->t_flags & TF_SACK_PERMIT) && tp->rcv_numsacks > 0 &&
                    MAX_TCPOPTLEN - optlen - 2 >= TCPOLEN_SACK) {
                if (TCPS_HAVEESTABLISHED(tp->t_state) &&
                    (tp->t_flags & TF_SACK_PERMIT) && tp->rcv_numsacks > 0 &&
                    MAX_TCPOPTLEN - optlen - 2 >= TCPOLEN_SACK) {

-                       int nsack, sackoptlen, padlen;
+                       int nsack, padlen;

                        u_char *bp = (u_char *)opt + optlen;
                        u_int32_t *lp;
 
                        u_char *bp = (u_char *)opt + optlen;
                        u_int32_t *lp;
 


@@ -1040,7 +1203,7 @@ send:
                        tcpstat.tcps_sack_send_blocks++;
                        *bp++ = TCPOPT_SACK;
                        *bp++ = sackoptlen;
                        tcpstat.tcps_sack_send_blocks++;
                        *bp++ = TCPOPT_SACK;
                        *bp++ = sackoptlen;

-                       lp = (u_int32_t *)bp;
+                       lp = (u_int32_t *)(void *)bp;

                        for (i = 0; i < nsack; i++) {
                                struct sackblk sack = tp->sackblks[i];
                                *lp++ = htonl(sack.start);
                        for (i = 0; i < nsack; i++) {
                                struct sackblk sack = tp->sackblks[i];
                                *lp++ = htonl(sack.start);


@@ -1115,16 +1278,26 @@ send:
                }
        }
 
                }
        }
 

-/*#ifdef DIAGNOSTIC*/
-#if INET6

        if (max_linkhdr + hdrlen > MCLBYTES)
                panic("tcphdr too big");
        if (max_linkhdr + hdrlen > MCLBYTES)
                panic("tcphdr too big");

-#else
-       if (max_linkhdr + hdrlen > MHLEN)
-               panic("tcphdr too big");
-#endif
-/*#endif*/

 
 

+       /* Check if there is enough data in the send socket
+        * buffer to start measuring bw 
+        */
+       if ((tp->t_flagsext & TF_MEASURESNDBW) != 0 &&
+               (tp->t_bwmeas != NULL) &&
+               (tp->t_flagsext & TF_BWMEAS_INPROGRESS) == 0 &&
+               (so->so_snd.sb_cc - (tp->snd_max - tp->snd_una)) >= 
+                       tp->t_bwmeas->bw_minsize) {
+               tp->t_bwmeas->bw_size = min((so->so_snd.sb_cc - (tp->snd_max - tp->snd_una)),
+                       tp->t_bwmeas->bw_maxsize);
+               tp->t_flagsext |= TF_BWMEAS_INPROGRESS;
+               tp->t_bwmeas->bw_start = tp->snd_max;
+               tp->t_bwmeas->bw_ts = tcp_now;
+       }
+
+       VERIFY(tp->t_inpcb->inp_flowhash != 0);
+       

        /*
         * Grab a header mbuf, attaching a copy of data to
         * be transmitted, and initialize the header from
        /*
         * Grab a header mbuf, attaching a copy of data to
         * be transmitted, and initialize the header from


@@ -1136,22 +1309,21 @@ send:
                else if (SEQ_LT(tp->snd_nxt, tp->snd_max) || sack_rxmit) {
                        tcpstat.tcps_sndrexmitpack++;
                        tcpstat.tcps_sndrexmitbyte += len;
                else if (SEQ_LT(tp->snd_nxt, tp->snd_max) || sack_rxmit) {
                        tcpstat.tcps_sndrexmitpack++;
                        tcpstat.tcps_sndrexmitbyte += len;

+                       if (nstat_collect) {
+                               nstat_route_tx(tp->t_inpcb->inp_route.ro_rt, 1, 
+                                       len, NSTAT_TX_FLAG_RETRANSMIT);
+                               locked_add_64(&tp->t_inpcb->inp_stat->txpackets, 1);
+                               locked_add_64(&tp->t_inpcb->inp_stat->txbytes, len);
+                               tp->t_stat.txretransmitbytes += len;
+                       }

                } else {
                        tcpstat.tcps_sndpack++;
                        tcpstat.tcps_sndbyte += len;
                } else {
                        tcpstat.tcps_sndpack++;
                        tcpstat.tcps_sndbyte += len;

+                       if (nstat_collect) {
+                               locked_add_64(&tp->t_inpcb->inp_stat->txpackets, 1);
+                               locked_add_64(&tp->t_inpcb->inp_stat->txbytes, len);
+                       }

                }
                }

-#ifdef notyet
-               if ((m = m_copypack(so->so_snd.sb_mb, off,
-                   (int)len, max_linkhdr + hdrlen)) == 0) {
-                       error = ENOBUFS;
-                       goto out;
-               }
-               /*
-                * m_copypack left space for our hdr; use it.
-                */
-               m->m_len += hdrlen;
-               m->m_data -= hdrlen;
-#else

                /*
                 * try to use the new interface that allocates all 
                 * the necessary mbuf hdrs under 1 mbuf lock and 
                /*
                 * try to use the new interface that allocates all 
                 * the necessary mbuf hdrs under 1 mbuf lock and 


@@ -1165,11 +1337,13 @@ send:
                 * data area (no cluster attached)
                 */
                m = NULL;
                 * data area (no cluster attached)
                 */
                m = NULL;

-#if INET6
+
+               /* minimum length we are going to allocate */
+               allocated_len = MHLEN;

                if (MHLEN < hdrlen + max_linkhdr) {
                if (MHLEN < hdrlen + max_linkhdr) {

-                       MGETHDR(m, M_DONTWAIT, MT_HEADER);      /* MAC-OK */
+                       MGETHDR(m, M_DONTWAIT, MT_HEADER);

                        if (m == NULL) {
                        if (m == NULL) {

-                               error = ENOBUFS;
+                               error = ENOBUFS;

                                goto out;
                        }
                        MCLGET(m, M_DONTWAIT);
                                goto out;
                        }
                        MCLGET(m, M_DONTWAIT);


@@ -1180,13 +1354,14 @@ send:
                        }
                        m->m_data += max_linkhdr;
                        m->m_len = hdrlen;
                        }
                        m->m_data += max_linkhdr;
                        m->m_len = hdrlen;

+                       allocated_len = MCLBYTES;

                }
                }

-#endif
-               if (len <= MHLEN - hdrlen - max_linkhdr) {
+               if (len <= allocated_len - hdrlen - max_linkhdr) {

                        if (m == NULL) {
                        if (m == NULL) {

-                               MGETHDR(m, M_DONTWAIT, MT_HEADER);      /* MAC-OK */
+                               VERIFY(allocated_len <= MHLEN);
+                               MGETHDR(m, M_DONTWAIT, MT_HEADER);

                                if (m == NULL) {
                                if (m == NULL) {

-                                       error = ENOBUFS;
+                                       error = ENOBUFS;

                                        goto out;
                                }
                                m->m_data += max_linkhdr;
                                        goto out;
                                }
                                m->m_data += max_linkhdr;


@@ -1221,7 +1396,7 @@ send:
                                 * setting the mbuf pointer to NULL is sufficient to disable the hint mechanism.
                                 */
                                if (m_head != so->so_snd.sb_mb || sack_rxmit || last_off != off)
                                 * setting the mbuf pointer to NULL is sufficient to disable the hint mechanism.
                                 */
                                if (m_head != so->so_snd.sb_mb || sack_rxmit || last_off != off)

-                                       m_last = NULL;
+                                       m_lastm = NULL;

                                last_off = off + len;
                                m_head = so->so_snd.sb_mb;
        
                                last_off = off + len;
                                m_head = so->so_snd.sb_mb;
        


@@ -1235,7 +1410,7 @@ send:
                                 * m_copym_with_hdrs will always return the last mbuf pointer and the offset into it that
                                 * it acted on to fullfill the current request, whether a valid 'hint' was passed in or not
                                 */
                                 * m_copym_with_hdrs will always return the last mbuf pointer and the offset into it that
                                 * it acted on to fullfill the current request, whether a valid 'hint' was passed in or not
                                 */

-                               if ((m = m_copym_with_hdrs(so->so_snd.sb_mb, off, len, M_DONTWAIT, &m_last, &m_off)) == NULL) {
+                               if ((m = m_copym_with_hdrs(so->so_snd.sb_mb, off, len, M_DONTWAIT, &m_lastm, &m_off)) == NULL) {

                                        error = ENOBUFS;
                                        goto out;
                                }
                                        error = ENOBUFS;
                                        goto out;
                                }


@@ -1243,7 +1418,6 @@ send:
                                m->m_len = hdrlen;
                        }
                }
                                m->m_len = hdrlen;
                        }
                }

-#endif

                /*
                 * If we're sending everything we've got, set PUSH.
                 * (This will keep happy those implementations which only
                /*
                 * If we're sending everything we've got, set PUSH.
                 * (This will keep happy those implementations which only


@@ -1267,12 +1441,14 @@ send:
                        error = ENOBUFS;
                        goto out;
                }
                        error = ENOBUFS;
                        goto out;
                }

-#if INET6
-               if (isipv6 && (MHLEN < hdrlen + max_linkhdr) &&
-                   MHLEN >= hdrlen) {
-                       MH_ALIGN(m, hdrlen);
-               } else
-#endif
+               if (MHLEN < (hdrlen + max_linkhdr)) {
+                       MCLGET(m, M_DONTWAIT);
+                       if ((m->m_flags & M_EXT) == 0) {
+                               m_freem(m);
+                               error = ENOBUFS;
+                               goto out;
+                       }
+               }

                m->m_data += max_linkhdr;
                m->m_len = hdrlen;
        }
                m->m_data += max_linkhdr;
                m->m_len = hdrlen;
        }


@@ -1283,18 +1459,23 @@ send:
 #if INET6
        if (isipv6) {
                ip6 = mtod(m, struct ip6_hdr *);
 #if INET6
        if (isipv6) {
                ip6 = mtod(m, struct ip6_hdr *);

-               th = (struct tcphdr *)(ip6 + 1);
+               th = (struct tcphdr *)(void *)(ip6 + 1);

                tcp_fillheaders(tp, ip6, th);
                tcp_fillheaders(tp, ip6, th);

+               if ((tp->ecn_flags & TE_SENDIPECT) != 0 && len &&
+                       !SEQ_LT(tp->snd_nxt, tp->snd_max) && !sack_rxmit) {
+                       ip6->ip6_flow |= htonl(IPTOS_ECN_ECT0 << 20);
+               }
+               svc_flags |= PKT_SCF_IPV6;

        } else
 #endif /* INET6 */
        {
                ip = mtod(m, struct ip *);
                ipov = (struct ipovly *)ip;
        } else
 #endif /* INET6 */
        {
                ip = mtod(m, struct ip *);
                ipov = (struct ipovly *)ip;

-               th = (struct tcphdr *)(ip + 1);
+               th = (struct tcphdr *)(void *)(ip + 1);

                /* this picks up the pseudo header (w/o the length) */
                tcp_fillheaders(tp, ip, th);
                if ((tp->ecn_flags & TE_SENDIPECT) != 0 && len &&
                /* this picks up the pseudo header (w/o the length) */
                tcp_fillheaders(tp, ip, th);
                if ((tp->ecn_flags & TE_SENDIPECT) != 0 && len &&

-                       !SEQ_LT(tp->snd_nxt, tp->snd_max)) {
+                       !SEQ_LT(tp->snd_nxt, tp->snd_max) && !sack_rxmit) {

                        ip->ip_tos = IPTOS_ECN_ECT0;
                }
        }
                        ip->ip_tos = IPTOS_ECN_ECT0;
                }
        }


@@ -1304,7 +1485,7 @@ send:
         * window for use in delaying messages about window sizes.
         * If resending a FIN, be sure not to use a new sequence number.
         */
         * window for use in delaying messages about window sizes.
         * If resending a FIN, be sure not to use a new sequence number.
         */

-       if (flags & TH_FIN && tp->t_flags & TF_SENTFIN &&
+       if (flags & TH_FIN && (tp->t_flags & TF_SENTFIN) &&

            tp->snd_nxt == tp->snd_max)
                tp->snd_nxt--;
        /*
            tp->snd_nxt == tp->snd_max)
                tp->snd_nxt--;
        /*


@@ -1349,13 +1530,25 @@ send:
        if (tp->t_flags & TF_SLOWLINK && slowlink_wsize > 0) {
                if (recwin > (int32_t)slowlink_wsize) 
                        recwin = slowlink_wsize;
        if (tp->t_flags & TF_SLOWLINK && slowlink_wsize > 0) {
                if (recwin > (int32_t)slowlink_wsize) 
                        recwin = slowlink_wsize;

-               th->th_win = htons((u_short) (recwin>>tp->rcv_scale));

        }
        }

-       else {
-               if (recwin > (int32_t)(TCP_MAXWIN << tp->rcv_scale))
-                       recwin = (int32_t)(TCP_MAXWIN << tp->rcv_scale);
-               th->th_win = htons((u_short) (recwin>>tp->rcv_scale));
+
+#if TRAFFIC_MGT
+       if (tcp_recv_bg == 1  || IS_TCP_RECV_BG(so)) {
+               if (tp->acc_iaj > tcp_acc_iaj_react_limit) {
+                       uint32_t min_iaj_win = tcp_min_iaj_win * tp->t_maxseg;
+                       if (tp->iaj_rwintop == 0 ||
+                               SEQ_LT(tp->iaj_rwintop, tp->rcv_adv))
+                               tp->iaj_rwintop = tp->rcv_adv; 
+                       if (SEQ_LT(tp->iaj_rwintop, tp->rcv_nxt + min_iaj_win))
+                               tp->iaj_rwintop =  tp->rcv_nxt + min_iaj_win;
+                       recwin = min(tp->iaj_rwintop - tp->rcv_nxt, recwin);
+               }

        }
        }

+#endif /* TRAFFIC_MGT */
+
+       if (recwin > (int32_t)(TCP_MAXWIN << tp->rcv_scale))
+               recwin = (int32_t)(TCP_MAXWIN << tp->rcv_scale);
+       th->th_win = htons((u_short) (recwin>>tp->rcv_scale));

 
        /*
         * Adjust the RXWIN0SENT flag - indicate that we have advertised
 
        /*
         * Adjust the RXWIN0SENT flag - indicate that we have advertised


@@ -1365,7 +1558,7 @@ send:
         * to read more data then can be buffered prior to transmitting on
         * the connection.
         */
         * to read more data then can be buffered prior to transmitting on
         * the connection.
         */

-       if (recwin == 0)
+       if (th->th_win == 0)

                tp->t_flags |= TF_RXWIN0SENT;
        else
                tp->t_flags &= ~TF_RXWIN0SENT;
                tp->t_flags |= TF_RXWIN0SENT;
        else
                tp->t_flags &= ~TF_RXWIN0SENT;


@@ -1387,13 +1580,17 @@ send:
         */
        m->m_pkthdr.len = hdrlen + len; /* in6_cksum() need this */
 #if INET6
         */
        m->m_pkthdr.len = hdrlen + len; /* in6_cksum() need this */
 #if INET6

-       if (isipv6)
+       if (isipv6) {

                /*
                 * ip6_plen is not need to be filled now, and will be filled
                 * in ip6_output.
                 */
                /*
                 * ip6_plen is not need to be filled now, and will be filled
                 * in ip6_output.
                 */

-               th->th_sum = in6_cksum(m, IPPROTO_TCP, sizeof(struct ip6_hdr),
-                                      sizeof(struct tcphdr) + optlen + len);
+               m->m_pkthdr.csum_flags = CSUM_TCPIPV6;
+               m->m_pkthdr.csum_data = offsetof(struct tcphdr, th_sum);
+               if (len + optlen)
+                       th->th_sum = in_addword(th->th_sum, 
+                               htons((u_short)(optlen + len)));
+       }

        else
 #endif /* INET6 */
        {
        else
 #endif /* INET6 */
        {


@@ -1407,7 +1604,6 @@ send:
        /*
         * Enable TSO and specify the size of the segments.
         * The TCP pseudo header checksum is always provided.
        /*
         * Enable TSO and specify the size of the segments.
         * The TCP pseudo header checksum is always provided.

-        * XXX: Fixme: This is currently not the case for IPv6.

         */
        if (tso) {
 #if INET6
         */
        if (tso) {
 #if INET6


@@ -1450,7 +1646,7 @@ send:
                         * not currently timing anything.
                         */
                        if (tp->t_rtttime == 0) {
                         * not currently timing anything.
                         */
                        if (tp->t_rtttime == 0) {

-                               tp->t_rtttime = 1;
+                               tp->t_rtttime = tcp_now;

                                tp->t_rtseq = startseq;
                                tcpstat.tcps_segstimed++;
                        }
                                tp->t_rtseq = startseq;
                                tcpstat.tcps_segstimed++;
                        }


@@ -1471,8 +1667,10 @@ timer:
                        if (tp->t_timer[TCPT_PERSIST]) {
                                tp->t_timer[TCPT_PERSIST] = 0;
                                tp->t_rxtshift = 0;
                        if (tp->t_timer[TCPT_PERSIST]) {
                                tp->t_timer[TCPT_PERSIST] = 0;
                                tp->t_rxtshift = 0;

+                               tp->rxt_start = 0;
+                               tp->t_persist_stop = 0;

                        }
                        }

-                       tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
+                       tp->t_timer[TCPT_REXMT] = OFFSET_FROM_START(tp, tp->t_rxtcur);

                }
        } else {
                /*
                }
        } else {
                /*


@@ -1504,11 +1702,11 @@ timer:
         * to handle ttl and tos; we could keep them in
         * the template, but need a way to checksum without them.
         */
         * to handle ttl and tos; we could keep them in
         * the template, but need a way to checksum without them.
         */

+#ifdef INET6

        /*
         * m->m_pkthdr.len should have been set before cksum calcuration,
         * because in6_cksum() need it.
         */
        /*
         * m->m_pkthdr.len should have been set before cksum calcuration,
         * because in6_cksum() need it.
         */

-#if INET6

        if (isipv6) {
                /*
                 * we separately set hoplimit for every segment, since the
        if (isipv6) {
                /*
                 * we separately set hoplimit for every segment, since the


@@ -1522,55 +1720,23 @@ timer:
                                               : NULL);
 
                /* TODO: IPv6 IP6TOS_ECT bit on */
                                               : NULL);
 
                /* TODO: IPv6 IP6TOS_ECT bit on */

-#if IPSEC
-               if (ipsec_bypass == 0 && ipsec_setsocket(m, so) != 0) {
-                       m_freem(m);
-                       error = ENOBUFS;
-                       goto out;
-               }
-#endif /*IPSEC*/
-               m->m_pkthdr.socket_id = socket_id;
-
-#if PKT_PRIORITY
-               set_traffic_class(m, so, MBUF_TC_NONE);
-#endif /* PKT_PRIORITY */
-               error = ip6_output(m,
-                           inp6_pktopts,
-                           &tp->t_inpcb->in6p_route,
-                           (so_options & SO_DONTROUTE), NULL, NULL, 0);
+               KERNEL_DEBUG(DBG_LAYER_BEG,
+                   ((tp->t_inpcb->inp_fport << 16) | tp->t_inpcb->inp_lport),
+                   (((tp->t_inpcb->in6p_laddr.s6_addr16[0] & 0xffff) << 16) |
+                   (tp->t_inpcb->in6p_faddr.s6_addr16[0] & 0xffff)),
+                   sendalot,0,0);

        } else
 #endif /* INET6 */
        } else
 #endif /* INET6 */

-    {
-       ip->ip_len = m->m_pkthdr.len;
-#if INET6
-       if (isipv6)
-               ip->ip_ttl = in6_selecthlim(tp->t_inpcb,
-                                           tp->t_inpcb->in6p_route.ro_rt ?
-                                           tp->t_inpcb->in6p_route.ro_rt->rt_ifp
-                                           : NULL);
-       else
-#endif /* INET6 */
-       ip->ip_ttl = tp->t_inpcb->inp_ip_ttl;   /* XXX */
-       ip->ip_tos |= (tp->t_inpcb->inp_ip_tos & ~IPTOS_ECN_MASK);      /* XXX */
-
-
-#if INET6
-       if (isipv6) {
-               KERNEL_DEBUG(DBG_LAYER_BEG,
-                    ((tp->t_inpcb->inp_fport << 16) | tp->t_inpcb->inp_lport),
-                    (((tp->t_inpcb->in6p_laddr.s6_addr16[0] & 0xffff) << 16) |
-                     (tp->t_inpcb->in6p_faddr.s6_addr16[0] & 0xffff)),
-                    0,0,0);
-       }
-        else 
-#endif

        {
        {

-               KERNEL_DEBUG(DBG_LAYER_BEG,
-                    ((tp->t_inpcb->inp_fport << 16) | tp->t_inpcb->inp_lport),
-                    (((tp->t_inpcb->inp_laddr.s_addr & 0xffff) << 16) |
-                     (tp->t_inpcb->inp_faddr.s_addr & 0xffff)),
-                    0,0,0);
-       }
+               ip->ip_len = m->m_pkthdr.len;
+               ip->ip_ttl = tp->t_inpcb->inp_ip_ttl;   /* XXX */
+               ip->ip_tos |= (tp->t_inpcb->inp_ip_tos & ~IPTOS_ECN_MASK);/* XXX */
+               KERNEL_DEBUG(DBG_LAYER_BEG,
+                   ((tp->t_inpcb->inp_fport << 16) | tp->t_inpcb->inp_lport),
+                   (((tp->t_inpcb->inp_laddr.s_addr & 0xffff) << 16) |
+                   (tp->t_inpcb->inp_faddr.s_addr & 0xffff)),
+                   0,0,0);
+       }

 
        /*
         * See if we should do MTU discovery.
 
        /*
         * See if we should do MTU discovery.


@@ -1581,9 +1747,11 @@ timer:
         *      4) the MTU is not locked (if it is, then discovery has been
         *         disabled for that route)
         */
         *      4) the MTU is not locked (if it is, then discovery has been
         *         disabled for that route)
         */

-
-       if (path_mtu_discovery && (tp->t_flags & TF_PMTUD))
-               ip->ip_off |= IP_DF;
+#ifdef INET6
+       if (!isipv6)
+#endif
+               if (path_mtu_discovery && (tp->t_flags & TF_PMTUD))
+                       ip->ip_off |= IP_DF;

 
 #if IPSEC
        if (ipsec_bypass == 0)
 
 #if IPSEC
        if (ipsec_bypass == 0)


@@ -1595,12 +1763,51 @@ timer:
         */
        lost = 0;
        m->m_pkthdr.socket_id = socket_id;
         */
        lost = 0;
        m->m_pkthdr.socket_id = socket_id;

+
+       /*
+        * Embed the flow hash in pkt hdr and mark the packet as
+        * capable of flow controlling
+        */
+       m->m_pkthdr.m_flowhash = tp->t_inpcb->inp_flowhash;
+       m->m_pkthdr.m_fhflags |=
+           (PF_TAG_TCP | PF_TAG_FLOWHASH | PF_TAG_FLOWADV);
+

        m->m_nextpkt = NULL;
        m->m_nextpkt = NULL;

-#if PKT_PRIORITY
-       set_traffic_class(m, so, MBUF_TC_NONE);
-#endif /* PKT_PRIORITY */
+
+       if (tp->t_inpcb->inp_last_outifp != NULL &&
+           tp->t_inpcb->inp_last_outifp != lo_ifp) {
+               /* Hint to prioritize this packet if
+                * 1. if the packet has no data
+                * 2. the interface supports transmit-start model and did 
+                *    not disable ACK prioritization.
+                * 3. Only ACK flag is set.
+                * 4. there is no outstanding data on this connection.
+                */
+               if (tcp_prioritize_acks != 0 && len == 0 &&
+                   (tp->t_inpcb->inp_last_outifp->if_eflags & 
+                       (IFEF_TXSTART | IFEF_NOACKPRI)) == IFEF_TXSTART &&
+                   th->th_flags == TH_ACK && tp->snd_una == tp->snd_max &&
+                   tp->t_timer[TCPT_REXMT] == 0) {
+                       svc_flags |= PKT_SCF_TCP_ACK;
+               }
+               set_packet_service_class(m, so, MBUF_SC_UNSPEC, svc_flags);
+       }
+

        tp->t_pktlist_sentlen += len;
        tp->t_lastchain++;
        tp->t_pktlist_sentlen += len;
        tp->t_lastchain++;

+
+#ifdef INET6
+       if (isipv6) {
+               DTRACE_TCP5(send, struct mbuf *, m, struct inpcb *, tp->t_inpcb,
+                       struct ip6 *, ip6, struct tcpcb *, tp, struct tcphdr *,
+                       th);
+       } else
+#endif
+       {
+               DTRACE_TCP5(send, struct mbuf *, m, struct inpcb *, tp->t_inpcb,
+                       struct ip *, ip, struct tcpcb *, tp, struct tcphdr *, th);
+       }
+

        if (tp->t_pktlist_head != NULL) {
                tp->t_pktlist_tail->m_nextpkt = m;
                tp->t_pktlist_tail = m;
        if (tp->t_pktlist_head != NULL) {
                tp->t_pktlist_tail->m_nextpkt = m;
                tp->t_pktlist_tail = m;


@@ -1609,25 +1816,53 @@ timer:
                tp->t_pktlist_head = tp->t_pktlist_tail = m;
        }
 
                tp->t_pktlist_head = tp->t_pktlist_tail = m;
        }
 

+       if ((lro_ackmore) && (!sackoptlen) && (!tp->t_timer[TCPT_PERSIST]) &&
+                       ((th->th_flags & TH_ACK) == TH_ACK) && (!len) &&
+                       (tp->t_state == TCPS_ESTABLISHED)) {
+               /* For a pure ACK, see if you need to send more of them */      
+               mnext = tcp_send_lroacks(tp, m, th);
+               if (mnext) {
+                       tp->t_pktlist_tail->m_nextpkt = mnext;
+                       if (mnext->m_nextpkt == NULL) {
+                               tp->t_pktlist_tail = mnext;
+                               tp->t_lastchain++;
+                       } else {
+                               struct mbuf *tail, *next;
+                               next = mnext->m_nextpkt;
+                               tail = next->m_nextpkt;
+                               while (tail) {
+                                       next = tail;
+                                       tail = tail->m_nextpkt;
+                                       tp->t_lastchain++;
+                               }
+                               tp->t_pktlist_tail = next;
+                       }
+               }
+       }
+

        if (sendalot == 0 || (tp->t_state != TCPS_ESTABLISHED) ||
              (tp->snd_cwnd <= (tp->snd_wnd / 8)) ||
              (tp->t_flags & (TH_PUSH | TF_ACKNOW)) || tp->t_force != 0 ||
              tp->t_lastchain >= tcp_packet_chaining) {
                error = 0;
        if (sendalot == 0 || (tp->t_state != TCPS_ESTABLISHED) ||
              (tp->snd_cwnd <= (tp->snd_wnd / 8)) ||
              (tp->t_flags & (TH_PUSH | TF_ACKNOW)) || tp->t_force != 0 ||
              tp->t_lastchain >= tcp_packet_chaining) {
                error = 0;

-               while (!(tp->t_flags & TF_SENDINPROG) &&
-                   tp->t_pktlist_head != NULL) {
+               while (tp->t_inpcb->inp_sndinprog_cnt == 0 &&
+                       tp->t_pktlist_head != NULL) {

                        packetlist = tp->t_pktlist_head;
                        packchain_listadd = tp->t_lastchain;
                        packchain_sent++;
                        lost = tp->t_pktlist_sentlen;
                        TCP_PKTLIST_CLEAR(tp);
                        packetlist = tp->t_pktlist_head;
                        packchain_listadd = tp->t_lastchain;
                        packchain_sent++;
                        lost = tp->t_pktlist_sentlen;
                        TCP_PKTLIST_CLEAR(tp);

-                       tp->t_flags |= TF_SENDINPROG;

 
                        error = tcp_ip_output(so, tp, packetlist,
                            packchain_listadd, tp_inp_options,
 
                        error = tcp_ip_output(so, tp, packetlist,
                            packchain_listadd, tp_inp_options,

-                           (so_options & SO_DONTROUTE), (sack_rxmit | (sack_bytes_rxmt != 0)), recwin);
+                           (so_options & SO_DONTROUTE),
+                           (sack_rxmit | (sack_bytes_rxmt != 0)), recwin,
+#ifdef INET6
+                           isipv6);
+#else
+                           0);
+#endif

 
 

-                       tp->t_flags &= ~TF_SENDINPROG;

                        if (error) {
                                /*
                                 * Take into account the rest of unsent
                        if (error) {
                                /*
                                 * Take into account the rest of unsent


@@ -1642,20 +1877,19 @@ timer:
                        }
                }
                /* tcp was closed while we were in ip; resume close */
                        }
                }
                /* tcp was closed while we were in ip; resume close */

-               if ((tp->t_flags & (TF_CLOSING|TF_SENDINPROG)) == TF_CLOSING) {
+               if (tp->t_inpcb->inp_sndinprog_cnt == 0 &&
+                       (tp->t_flags & TF_CLOSING)) {

                        tp->t_flags &= ~TF_CLOSING;
                        (void) tcp_close(tp);
                        return (0);
                }
                        tp->t_flags &= ~TF_CLOSING;
                        (void) tcp_close(tp);
                        return (0);
                }

-       }
-       else {
+       } else {

                error = 0;
                packchain_looped++;
                tcpstat.tcps_sndtotal++;
 
                goto again;
        }
                error = 0;
                packchain_looped++;
                tcpstat.tcps_sndtotal++;
 
                goto again;
        }

-   }

        if (error) {
                /*
                 * Assume that the packets were lost, so back out the
        if (error) {
                /*
                 * Assume that the packets were lost, so back out the


@@ -1684,13 +1918,19 @@ out:
 
                if (error == ENOBUFS) {
                        if (!tp->t_timer[TCPT_REXMT] &&
 
                if (error == ENOBUFS) {
                        if (!tp->t_timer[TCPT_REXMT] &&

-                                !tp->t_timer[TCPT_PERSIST])
-                                       tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
+                               !tp->t_timer[TCPT_PERSIST])
+                               tp->t_timer[TCPT_REXMT] = 
+                                       OFFSET_FROM_START(tp, tp->t_rxtcur);

 
                        tp->snd_cwnd = tp->t_maxseg;
                        tp->t_bytes_acked = 0;
 
 
                        tp->snd_cwnd = tp->t_maxseg;
                        tp->t_bytes_acked = 0;
 

+                       tcp_check_timer_state(tp);

                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);

+
+                       DTRACE_TCP5(cc, void, NULL, struct inpcb *, tp->t_inpcb,
+                               struct tcpcb *, tp, struct tcphdr *, NULL,
+                               int32_t, TCP_CC_OUTPUT_ERROR);

                        return (0);
                }
                if (error == EMSGSIZE) {
                        return (0);
                }
                if (error == EMSGSIZE) {


@@ -1710,65 +1950,92 @@ out:
                                tp->t_flags &= ~TF_TSO;
 
                        tcp_mtudisc(tp->t_inpcb, 0);
                                tp->t_flags &= ~TF_TSO;
 
                        tcp_mtudisc(tp->t_inpcb, 0);

+                       tcp_check_timer_state(tp);
+

                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                        return 0;
                }
                if ((error == EHOSTUNREACH || error == ENETDOWN)
                    && TCPS_HAVERCVDSYN(tp->t_state)) {
                        tp->t_softerror = error;
                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                        return 0;
                }
                if ((error == EHOSTUNREACH || error == ENETDOWN)
                    && TCPS_HAVERCVDSYN(tp->t_state)) {
                        tp->t_softerror = error;

+                       tcp_check_timer_state(tp);

                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                        return (0);
                }
                        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                        return (0);
                }

+               tcp_check_timer_state(tp);

                KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                return (error);
        }
 
        tcpstat.tcps_sndtotal++;
 
                KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END, 0,0,0,0,0);
                return (error);
        }
 
        tcpstat.tcps_sndtotal++;
 

-       /*
-        * Data sent (as far as we can tell).
-        * If this advertises a larger window than any other segment,
-        * then remember the size of the advertised window.
-        * Make sure ACK/DELACK conditions are cleared before
-        * we unlock the socket.
-        *  NOTE: for now, this is done in tcp_ip_output for IPv4
-        */
-#if INET6
-       if (isipv6) {
-               if (recwin > 0 && SEQ_GT(tp->rcv_nxt + recwin, tp->rcv_adv))
-                       tp->rcv_adv = tp->rcv_nxt + recwin;
-               tp->last_ack_sent = tp->rcv_nxt;
-               tp->t_flags &= ~(TF_ACKNOW | TF_DELACK);
-       }
-#endif
-

        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END,0,0,0,0,0);
        KERNEL_DEBUG(DBG_FNC_TCP_OUTPUT | DBG_FUNC_END,0,0,0,0,0);

-       if (sendalot && (!tcp_do_newreno || --maxburst))
+       if (sendalot)

                goto again;
                goto again;

+
+       tcp_check_timer_state(tp);

        return (0);
 }
 
 static int
 tcp_ip_output(struct socket *so, struct tcpcb *tp, struct mbuf *pkt,
        return (0);
 }
 
 static int
 tcp_ip_output(struct socket *so, struct tcpcb *tp, struct mbuf *pkt,

-    int cnt, struct mbuf *opt, int flags, int sack_in_progress, int recwin)
+    int cnt, struct mbuf *opt, int flags, int sack_in_progress, int recwin,
+    boolean_t isipv6)

 {
        int error = 0;
        boolean_t chain;
        boolean_t unlocked = FALSE;
        struct inpcb *inp = tp->t_inpcb;
 {
        int error = 0;
        boolean_t chain;
        boolean_t unlocked = FALSE;
        struct inpcb *inp = tp->t_inpcb;

-       struct ip_out_args ipoa;
+       struct ip_out_args ipoa =
+           { IFSCOPE_NONE, { 0 }, IPOAF_SELECT_SRCIF | IPOAF_BOUND_SRCADDR };

        struct route ro;
        struct route ro;

-#if CONFIG_OUT_IF
-       unsigned int outif;
-#endif /* CONFIG_OUT_IF */
+       struct ifnet *outif = NULL;
+#ifdef INET6
+       struct ip6_out_args ip6oa =
+           { IFSCOPE_NONE, { 0 }, IP6OAF_SELECT_SRCIF | IP6OAF_BOUND_SRCADDR };
+       struct route_in6 ro6;
+       struct flowadv *adv =
+           (isipv6 ? &ip6oa.ip6oa_flowadv : &ipoa.ipoa_flowadv);
+#else
+       struct flowadv *adv = &ipoa.ipoa_flowadv;
+#endif /* !INET6 */

 
        /* If socket was bound to an ifindex, tell ip_output about it */
 
        /* If socket was bound to an ifindex, tell ip_output about it */

-       ipoa.ipoa_ifscope = (inp->inp_flags & INP_BOUND_IF) ?
-           inp->inp_boundif : IFSCOPE_NONE;
-       flags |= IP_OUTARGS;
+       if (inp->inp_flags & INP_BOUND_IF) {
+#ifdef INET6
+               if (isipv6) {
+                       ip6oa.ip6oa_boundif = inp->inp_boundifp->if_index;
+                       ip6oa.ip6oa_flags |= IP6OAF_BOUND_IF;
+               } else
+#endif
+               {
+                       ipoa.ipoa_boundif = inp->inp_boundifp->if_index;
+                       ipoa.ipoa_flags |= IPOAF_BOUND_IF;
+               }
+       }
+
+       if (inp->inp_flags & INP_NO_IFT_CELLULAR) {
+#ifdef INET6
+               if (isipv6)
+                       ip6oa.ip6oa_flags |=  IP6OAF_NO_CELLULAR;
+               else
+#endif
+                       ipoa.ipoa_flags |=  IPOAF_NO_CELLULAR;
+       }
+#ifdef INET6
+       if (isipv6)
+               flags |= IPV6_OUTARGS;
+       else
+#endif
+               flags |= IP_OUTARGS;

 
        /* Copy the cached route and take an extra reference */
 
        /* Copy the cached route and take an extra reference */

-       inp_route_copyout(inp, &ro);
+#ifdef INET6
+       if (isipv6)
+               in6p_route_copyout(inp, &ro6);
+       else
+#endif
+               inp_route_copyout(inp, &ro);

 
        /*
         * Data sent (as far as we can tell).
 
        /*
         * Data sent (as far as we can tell).


@@ -1781,14 +2048,25 @@ tcp_ip_output(struct socket *so, struct tcpcb *tp, struct mbuf *pkt,
                tp->rcv_adv = tp->rcv_nxt + recwin;
        tp->last_ack_sent = tp->rcv_nxt;
        tp->t_flags &= ~(TF_ACKNOW | TF_DELACK);
                tp->rcv_adv = tp->rcv_nxt + recwin;
        tp->last_ack_sent = tp->rcv_nxt;
        tp->t_flags &= ~(TF_ACKNOW | TF_DELACK);

+       tp->t_timer[TCPT_DELACK] = 0;
+       tp->t_unacksegs = 0;
+
+       /* Increment the count of outstanding send operations */
+       inp->inp_sndinprog_cnt++;

 
        /*
         * If allowed, unlock TCP socket while in IP
         * but only if the connection is established and
 
        /*
         * If allowed, unlock TCP socket while in IP
         * but only if the connection is established and

-        * if we're not sending from an upcall.
+        * in a normal mode where reentrancy on the tcpcb won't be
+        * an issue:
+        * - there is no SACK episode
+        * - we're not in Fast Recovery mode
+        * - if we're not sending from an upcall.

         */
         */

-       if (tcp_output_unlocked && ((so->so_flags & SOF_UPCALLINUSE) == 0) &&
-           (tp->t_state == TCPS_ESTABLISHED) && (sack_in_progress == 0)) {
+       if (tcp_output_unlocked && !so->so_upcallusecount &&
+           (tp->t_state == TCPS_ESTABLISHED) && (sack_in_progress == 0) &&
+           ((tp->t_flags & TF_FASTRECOVERY) == 0)) {
+

                unlocked = TRUE;
                socket_unlock(so, 0);
        }
                unlocked = TRUE;
                socket_unlock(so, 0);
        }


@@ -1828,8 +2106,16 @@ tcp_ip_output(struct socket *so, struct tcpcb *tp, struct mbuf *pkt,
                         */
                        cnt = 0;
                }
                         */
                        cnt = 0;
                }

-       
-               error = ip_output_list(pkt, cnt, opt, &ro, flags, 0, &ipoa);
+#ifdef INET6
+               if (isipv6)
+                       error = ip6_output_list(pkt, cnt,
+                           inp->in6p_outputopts, &ro6, flags, NULL, NULL,
+                           &ip6oa);
+               else
+#endif
+                       error = ip_output_list(pkt, cnt, opt, &ro, flags, NULL,
+                           &ipoa);
+

                if (chain || error) {
                        /*
                         * If we sent down a chain then we are done since
                if (chain || error) {
                        /*
                         * If we sent down a chain then we are done since


@@ -1846,9 +2132,71 @@ tcp_ip_output(struct socket *so, struct tcpcb *tp, struct mbuf *pkt,
        if (unlocked)
                socket_lock(so, 0);
 
        if (unlocked)
                socket_lock(so, 0);
 

-       /* Synchronize cached PCB route */
-       inp_route_copyin(inp, &ro);
+       /* 
+        * Enter flow controlled state if the connection is established
+        * and is not in recovery.
+        *
+        * A connection will enter suspended state even if it is in 
+        * recovery.
+        */
+       if (((adv->code == FADV_FLOW_CONTROLLED && !IN_FASTRECOVERY(tp)) ||
+           adv->code == FADV_SUSPENDED) && 
+           !(tp->t_flags & TF_CLOSING) &&
+           tp->t_state == TCPS_ESTABLISHED) {
+               int rc;
+               rc = inp_set_fc_state(inp, adv->code);
+
+               if (rc == 1) 
+                       DTRACE_TCP5(cc, void, NULL, struct inpcb *, inp,
+                           struct tcpcb *, tp, struct tcphdr *, NULL,
+                           int32_t, ((adv->code == FADV_FLOW_CONTROLLED) ?
+                           TCP_CC_FLOW_CONTROL : TCP_CC_SUSPEND));
+       }
+
+       /* 
+        * When an interface queue gets suspended, some of the
+        * packets are dropped. Return ENOBUFS, to update the
+        * pcb state.
+        */
+       if (adv->code == FADV_SUSPENDED)
+               error = ENOBUFS;
+
+       VERIFY(inp->inp_sndinprog_cnt > 0);
+       if ( --inp->inp_sndinprog_cnt == 0)
+               inp->inp_flags &= ~(INP_FC_FEEDBACK);

 
 

+#ifdef INET6
+       if (isipv6) {
+               if (ro6.ro_rt != NULL && (outif = ro6.ro_rt->rt_ifp) !=
+                   inp->in6p_last_outifp)
+                       inp->in6p_last_outifp = outif;
+       } else
+#endif
+               if (ro.ro_rt != NULL && (outif = ro.ro_rt->rt_ifp) !=
+                   inp->inp_last_outifp)
+                       inp->inp_last_outifp = outif;
+
+       if ((inp->inp_flags & INP_NO_IFT_CELLULAR) && outif != NULL &&
+           outif->if_type == IFT_CELLULAR)
+               soevent(inp->inp_socket,
+                   (SO_FILT_HINT_LOCKED|SO_FILT_HINT_IFDENIED));
+
+       /* Synchronize cached PCB route & options */
+#ifdef INET6
+       if (isipv6)
+               in6p_route_copyin(inp, &ro6);
+       else
+#endif
+               inp_route_copyin(inp, &ro);
+
+       if (tp->t_state < TCPS_ESTABLISHED && tp->t_rxtshift == 0 && 
+               tp->t_inpcb->inp_route.ro_rt != NULL) {
+               /* If we found the route and there is an rtt on it
+                * reset the retransmit timer
+                */
+               tcp_getrt_rtt(tp, tp->t_inpcb->in6p_route.ro_rt);
+               tp->t_timer[TCPT_REXMT] = OFFSET_FROM_START(tp, tp->t_rxtcur);
+       }

        return (error);
 }
 
        return (error);
 }
 


@@ -1858,14 +2206,104 @@ tcp_setpersist(tp)
 {
        int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
 
 {
        int t = ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1;
 

-       if (tp->t_timer[TCPT_REXMT])
-               panic("tcp_setpersist: retransmit pending");
+       /* If a PERSIST_TIMER option was set we will limit the
+        * time the persist timer will be active for that connection
+        * in order to avoid DOS by using zero window probes.
+        * see rdar://5805356
+        */
+
+       if ((tp->t_persist_timeout != 0) &&
+                   (tp->t_timer[TCPT_PERSIST] == 0) &&
+                   (tp->t_persist_stop == 0)) {
+               tp->t_persist_stop = tcp_now + tp->t_persist_timeout;
+       }
+

        /*
         * Start/restart persistance timer.
         */
        TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
            t * tcp_backoff[tp->t_rxtshift],
        /*
         * Start/restart persistance timer.
         */
        TCPT_RANGESET(tp->t_timer[TCPT_PERSIST],
            t * tcp_backoff[tp->t_rxtshift],

-           TCPTV_PERSMIN, TCPTV_PERSMAX);
+           TCPTV_PERSMIN, TCPTV_PERSMAX, 0);
+       tp->t_timer[TCPT_PERSIST] = OFFSET_FROM_START(tp, tp->t_timer[TCPT_PERSIST]);
+

        if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
                tp->t_rxtshift++;
 }
        if (tp->t_rxtshift < TCP_MAXRXTSHIFT)
                tp->t_rxtshift++;
 }

+
+/*
+ * Send as many acks as data coalesced. Every other packet when stretch
+ * ACK is not enabled. Every 8 packets, if stretch ACK is enabled.
+ */
+static struct mbuf*
+tcp_send_lroacks(struct tcpcb *tp, struct mbuf *m, struct tcphdr *th)
+{
+       struct mbuf *mnext = NULL, *ack_chain = NULL, *tail = NULL;
+       int count = 0;
+       tcp_seq org_ack = ntohl(th->th_ack);
+       tcp_seq prev_ack = 0;
+       int tack_offset = 28; /* XXX IPv6 not supported */
+       int ack_size = (tp->t_flags & TF_STRETCHACK) ?
+                       (maxseg_unacked * tp->t_maxseg) : (tp->t_maxseg << 1);
+       int segs_acked = (tp->t_flags & TF_STRETCHACK) ? maxseg_unacked : 2;
+       struct mbuf *prev_ack_pkt = NULL;
+       struct socket *so = tp->t_inpcb->inp_socket;
+
+       count = tp->t_lropktlen/tp->t_maxseg;
+
+       prev_ack = (org_ack - tp->t_lropktlen) + ack_size;
+       if (prev_ack < org_ack) {
+               ack_chain = m_dup(m, M_DONTWAIT);
+               if (ack_chain) {
+                       th->th_ack = htonl(prev_ack);
+                       tail = ack_chain;
+                       count -= segs_acked; /* accounts for prev_ack packet */
+                       count = (count <= segs_acked) ? 0 : count - segs_acked;
+                       tcpstat.tcps_sndacks++;
+                       so_tc_update_stats(m, so, m_get_service_class(m));
+               } else {
+                       return NULL;
+               }
+       }       
+       else {
+               tp->t_lropktlen = 0;
+               return NULL;
+       }
+
+       prev_ack_pkt = ack_chain;
+       
+       while (count > 0) {
+               if ((prev_ack + ack_size) < org_ack) {
+                       prev_ack += ack_size;
+               } else {
+                       /*
+                        * The last ACK sent must have the ACK number that TCP
+                        * thinks is the last sent ACK number.
+                        */
+                        prev_ack = org_ack;
+               }
+               mnext = m_dup(prev_ack_pkt, M_DONTWAIT);
+               if (mnext) {
+                       HTONL(prev_ack);
+                       bcopy(&prev_ack, mtod(prev_ack_pkt, caddr_t) + tack_offset, 4);
+                       NTOHL(prev_ack);
+                       tail->m_nextpkt = mnext;
+                       tail = mnext;
+                       count -= segs_acked;
+                       tcpstat.tcps_sndacks++;
+                       so_tc_update_stats(m, so, m_get_service_class(m));
+                       if (lrodebug == 5) { 
+                               printf("%s: lropktlen = %d count = %d, th_ack = %x \n", 
+                                       __func__, tp->t_lropktlen, count, 
+                                       th->th_ack);
+                       }
+               } else {
+                       if (lrodebug == 5) {
+                               printf("%s: failed to alloc mbuf.\n", __func__);
+                       }
+                       break;
+               }
+               prev_ack_pkt = mnext;
+       } 
+       tp->t_lropktlen = 0;
+       return ack_chain;
+}