xnu-4570.61.1.tar.gz

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

diff --git a/bsd/netinet/tcp_usrreq.c b/bsd/netinet/tcp_usrreq.c
index 6484f92b62c5ecab105902b3009c80cc60abee83..1af338ade1997928b275e7d7fab1c09155ca0890 100644 (file)
--- a/bsd/netinet/tcp_usrreq.c
+++ b/bsd/netinet/tcp_usrreq.c
@@ -1,8 +1,8 @@
 /*
 /*

- * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2017 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

- * 
+ *

  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in


@@ -11,10 +11,10 @@
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.
  * unlawful or unlicensed copies of an Apple operating system, or to
  * circumvent, violate, or enable the circumvention or violation of, any
  * terms of an Apple operating system software license agreement.

- * 
+ *

  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  * Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this file.

- * 
+ *

  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,


@@ -22,7 +22,7 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.

- * 
+ *

  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*


@@ -70,7 +70,9 @@
 #if INET6
 #include <sys/domain.h>
 #endif /* INET6 */
 #if INET6
 #include <sys/domain.h>
 #endif /* INET6 */

+#if !CONFIG_EMBEDDED

 #include <sys/kasl.h>
 #include <sys/kasl.h>

+#endif

 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/protosw.h>


@@ -79,6 +81,7 @@
 #include <net/if.h>
 #include <net/route.h>
 #include <net/ntstat.h>
 #include <net/if.h>
 #include <net/route.h>
 #include <net/ntstat.h>

+#include <net/content_filter.h>

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


@@ -100,6 +103,7 @@
 #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>

 #include <mach/sdt.h>
 #if TCPDEBUG
 #include <netinet/tcp_debug.h>
 #include <mach/sdt.h>
 #if TCPDEBUG
 #include <netinet/tcp_debug.h>


@@ -116,10 +120,11 @@
 #include <netinet/flow_divert.h>
 #endif /* FLOW_DIVERT */
 
 #include <netinet/flow_divert.h>
 #endif /* FLOW_DIVERT */
 

-void   tcp_fill_info(struct tcpcb *, struct tcp_info *);

 errno_t tcp_fill_info_for_info_tuple(struct info_tuple *, struct tcp_info *);
 
 int tcp_sysctl_info(struct sysctl_oid *, void *, int , struct sysctl_req *);
 errno_t tcp_fill_info_for_info_tuple(struct info_tuple *, struct tcp_info *);
 
 int tcp_sysctl_info(struct sysctl_oid *, void *, int , struct sysctl_req *);

+static void tcp_connection_fill_info(struct tcpcb *tp,
+    struct tcp_connection_info *tci);

 
 /*
  * TCP protocol interface to socket abstraction.
 
 /*
  * TCP protocol interface to socket abstraction.


@@ -133,13 +138,8 @@ static int tcp6_connect(struct tcpcb *, struct sockaddr *, struct proc *);
 static int     tcp6_usr_connect(struct socket *, struct sockaddr *,
                    struct proc *);
 #endif /* INET6 */
 static int     tcp6_usr_connect(struct socket *, struct sockaddr *,
                    struct proc *);
 #endif /* INET6 */

-static struct tcpcb *
-               tcp_disconnect(struct tcpcb *);
-static struct tcpcb *
-               tcp_usrclosed(struct tcpcb *);
-
-extern uint32_t tcp_autorcvbuf_max;
-
+static struct tcpcb *tcp_disconnect(struct tcpcb *);
+static struct tcpcb *tcp_usrclosed(struct tcpcb *);

 extern void tcp_sbrcv_trim(struct tcpcb *tp, struct sockbuf *sb);
 
 #if TCPDEBUG
 extern void tcp_sbrcv_trim(struct tcpcb *tp, struct sockbuf *sb);
 
 #if TCPDEBUG


@@ -180,7 +180,7 @@ tcp_usr_attach(struct socket *so, __unused int proto, struct proc *p)
                error = EISCONN;
                goto out;
        }
                error = EISCONN;
                goto out;
        }

-       
+

        error = tcp_attach(so, p);
        if (error)
                goto out;
        error = tcp_attach(so, p);
        if (error)
                goto out;


@@ -211,7 +211,7 @@ tcp_usr_detach(struct socket *so)
        if (inp == 0 || (inp->inp_state == INPCB_STATE_DEAD)) {
                return EINVAL;  /* XXX */
        }
        if (inp == 0 || (inp->inp_state == INPCB_STATE_DEAD)) {
                return EINVAL;  /* XXX */
        }

-       lck_mtx_assert(&((struct inpcb *)so->so_pcb)->inpcb_mtx, LCK_MTX_ASSERT_OWNED);
+       socket_lock_assert_owned(so);

        tp = intotcpcb(inp);
        /* In case we got disconnected from the peer */
         if (tp == NULL)
        tp = intotcpcb(inp);
        /* In case we got disconnected from the peer */
         if (tp == NULL)


@@ -226,16 +226,27 @@ out:
        return error;
 }
 
        return error;
 }
 

+#if NECP

 #define        COMMON_START()  TCPDEBUG0;                                      \
 do {                                                                   \
        if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)          \
                return (EINVAL);                                        \
 #define        COMMON_START()  TCPDEBUG0;                                      \
 do {                                                                   \
        if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)          \
                return (EINVAL);                                        \

-       if (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)                    \
+       if (necp_socket_should_use_flow_divert(inp))                    \

                return (EPROTOTYPE);                                    \
        tp = intotcpcb(inp);                                            \
        TCPDEBUG1();                                                    \
        calculate_tcp_clock();                                          \
 } while (0)
                return (EPROTOTYPE);                                    \
        tp = intotcpcb(inp);                                            \
        TCPDEBUG1();                                                    \
        calculate_tcp_clock();                                          \
 } while (0)

+#else /* NECP */
+#define        COMMON_START()  TCPDEBUG0;                                      \
+do {                                                                   \
+       if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)          \
+               return (EINVAL);                                        \
+       tp = intotcpcb(inp);                                            \
+       TCPDEBUG1();                                                    \
+       calculate_tcp_clock();                                          \
+} while (0)
+#endif /* !NECP */

 
 #define COMMON_END(req)        out: TCPDEBUG2(req); return error; goto out
 
 
 #define COMMON_END(req)        out: TCPDEBUG2(req); return error; goto out
 


@@ -282,6 +293,17 @@ tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
        error = in_pcbbind(inp, nam, p);
        if (error)
                goto out;
        error = in_pcbbind(inp, nam, p);
        if (error)
                goto out;

+
+#if NECP
+       /* Update NECP client with bind result if not in middle of connect */
+       if ((inp->inp_flags2 & INP2_CONNECT_IN_PROGRESS) &&
+               !uuid_is_null(inp->necp_client_uuid)) {
+               socket_unlock(so, 0);
+               necp_client_assign_from_socket(so->last_pid, inp->necp_client_uuid, inp);
+               socket_lock(so, 0);
+       }
+#endif /* NECP */
+

        COMMON_END(PRU_BIND);
 
 }
        COMMON_END(PRU_BIND);
 
 }


@@ -383,6 +405,37 @@ tcp6_usr_listen(struct socket *so, struct proc *p)
 }
 #endif /* INET6 */
 
 }
 #endif /* INET6 */
 

+static int
+tcp_connect_complete(struct socket *so)
+{
+       struct tcpcb *tp = sototcpcb(so);
+       struct inpcb *inp = sotoinpcb(so);
+       int error = 0;
+
+       /* TFO delays the tcp_output until later, when the app calls write() */
+       if (so->so_flags1 & SOF1_PRECONNECT_DATA) {
+               if (!necp_socket_is_allowed_to_send_recv(sotoinpcb(so), NULL, NULL))
+                       return (EHOSTUNREACH);
+
+               /* Initialize enough state so that we can actually send data */
+               tcp_mss(tp, -1, IFSCOPE_NONE);
+               tp->snd_wnd = tp->t_maxseg;
+       } else {
+               error = tcp_output(tp);
+       }
+
+#if NECP
+       /* Update NECP client with connected five-tuple */
+       if (error == 0 && !uuid_is_null(inp->necp_client_uuid)) {
+               socket_unlock(so, 0);
+               necp_client_assign_from_socket(so->last_pid, inp->necp_client_uuid, inp);
+               socket_lock(so, 0);
+       }
+#endif /* NECP */
+
+       return (error);
+}
+

 /*
  * Initiate connection to peer.
  * Create a template for use in transmissions on this connection.
 /*
  * Initiate connection to peer.
  * Create a template for use in transmissions on this connection.


@@ -409,23 +462,28 @@ tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
                } else
                        return EINVAL;
        }
                } else
                        return EINVAL;
        }

+#if NECP

 #if FLOW_DIVERT
 #if FLOW_DIVERT

-       else if (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT) {
-               uint32_t fd_ctl_unit = 0;
-               error = flow_divert_check_policy(so, p, FALSE, &fd_ctl_unit);
-               if (error == 0) {
-                       if (fd_ctl_unit > 0) {
-                               error = flow_divert_pcb_init(so, fd_ctl_unit);
-                               if (error == 0) {
-                                       error = flow_divert_connect_out(so, nam, p);
-                               }
-                       } else {
-                               error = ENETDOWN;
+       else if (necp_socket_should_use_flow_divert(inp)) {
+               uint32_t fd_ctl_unit = necp_socket_get_flow_divert_control_unit(inp);
+               if (fd_ctl_unit > 0) {
+                       error = flow_divert_pcb_init(so, fd_ctl_unit);
+                       if (error == 0) {
+                               error = flow_divert_connect_out(so, nam, p);

                        }
                        }

+               } else {
+                       error = ENETDOWN;

                }
                }

+

                return error;
        }
 #endif /* FLOW_DIVERT */
                return error;
        }
 #endif /* FLOW_DIVERT */

+#if CONTENT_FILTER
+       error = cfil_sock_attach(so);
+       if (error != 0)
+               return error;
+#endif /* CONTENT_FILTER */
+#endif /* NECP */

        tp = intotcpcb(inp);
        TCPDEBUG1();
 
        tp = intotcpcb(inp);
        TCPDEBUG1();
 


@@ -447,91 +505,61 @@ tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
 
        if ((error = tcp_connect(tp, nam, p)) != 0)
                goto out;
 
        if ((error = tcp_connect(tp, nam, p)) != 0)
                goto out;

-       error = tcp_output(tp);
+
+       error = tcp_connect_complete(so);
+

        COMMON_END(PRU_CONNECT);
 }
 
 static int
 tcp_usr_connectx_common(struct socket *so, int af,
        COMMON_END(PRU_CONNECT);
 }
 
 static int
 tcp_usr_connectx_common(struct socket *so, int af,

-    struct sockaddr_list **src_sl, struct sockaddr_list **dst_sl,
-    struct proc *p, uint32_t ifscope, associd_t aid, connid_t *pcid,
-    uint32_t flags, void *arg, uint32_t arglen)
+    struct sockaddr *src, struct sockaddr *dst,
+    struct proc *p, uint32_t ifscope, sae_associd_t aid, sae_connid_t *pcid,
+    uint32_t flags, void *arg, uint32_t arglen, struct uio *auio,
+    user_ssize_t *bytes_written)

 {
 {

-#pragma unused(aid)
-#if !MPTCP
-#pragma unused(flags, arg, arglen)
-#endif /* !MPTCP */
-       struct sockaddr_entry *src_se = NULL, *dst_se = NULL;
+#pragma unused(aid, flags, arg, arglen)

        struct inpcb *inp = sotoinpcb(so);
        struct inpcb *inp = sotoinpcb(so);

-       int error;
+       int error = 0;
+       user_ssize_t datalen = 0;

 
        if (inp == NULL)
                return (EINVAL);
 
 
        if (inp == NULL)
                return (EINVAL);
 

-       VERIFY(dst_sl != NULL);
+       VERIFY(dst != NULL);

 
 

-       /* select source (if specified) and destination addresses */
-       error = in_selectaddrs(af, src_sl, &src_se, dst_sl, &dst_se);
-       if (error != 0)
-               return (error);
+       ASSERT(!(inp->inp_flags2 & INP2_CONNECT_IN_PROGRESS));
+       inp->inp_flags2 |= INP2_CONNECT_IN_PROGRESS;

 
 

-       VERIFY(*dst_sl != NULL && dst_se != NULL);
-       VERIFY(src_se == NULL || *src_sl != NULL);
-       VERIFY(dst_se->se_addr->sa_family == af);
-       VERIFY(src_se == NULL || src_se->se_addr->sa_family == af);
+#if NECP
+       inp_update_necp_policy(inp, src, dst, ifscope);
+#endif /* NECP */

 
 

-       /*
-        * We get here for 2 cases:
-        *
-        *   a. From MPTCP, to connect a subflow.  There is no need to
-        *      bind the socket to the source address and/or interface,
-        *      since everything has been taken care of by MPTCP.  We
-        *      simply check whether or not this is for the initial
-        *      MPTCP connection attempt, or to join an existing one.
-        *
-        *   b. From the socket layer, to connect a TCP.  Perform the
-        *      bind to source address and/or interface as necessary.
-        */
-#if MPTCP
-       if (flags & TCP_CONNREQF_MPTCP) {
-               struct mptsub_connreq *mpcr = arg;
-
-               /* Check to make sure this came down from MPTCP */
-               if (arg == NULL || arglen != sizeof (*mpcr))
-                       return (EOPNOTSUPP);
+       if ((so->so_flags1 & SOF1_DATA_IDEMPOTENT) &&
+           (tcp_fastopen & TCP_FASTOPEN_CLIENT))
+               sototcpcb(so)->t_flagsext |= TF_FASTOPEN;

 
 

-               switch (mpcr->mpcr_type) {
-               case MPTSUB_CONNREQ_MP_ENABLE:
-                       break;
-               case MPTSUB_CONNREQ_MP_ADD:
-                       break;
-               default:
-                       return (EOPNOTSUPP);
-               }
-       } else
-#endif /* MPTCP */
-       {
-               /* bind socket to the specified interface, if requested */
-               if (ifscope != IFSCOPE_NONE &&
-                   (error = inp_bindif(inp, ifscope, NULL)) != 0)
-                       return (error);
+       /* bind socket to the specified interface, if requested */
+       if (ifscope != IFSCOPE_NONE &&
+               (error = inp_bindif(inp, ifscope, NULL)) != 0) {
+               goto done;
+       }

 
 

-               /* if source address and/or port is specified, bind to it */
-               if (src_se != NULL) {
-                       struct sockaddr *sa = src_se->se_addr;
-                       error = sobindlock(so, sa, 0);  /* already locked */
-                       if (error != 0)
-                               return (error);
+       /* if source address and/or port is specified, bind to it */
+       if (src != NULL) {
+               error = sobindlock(so, src, 0); /* already locked */
+               if (error != 0) {
+                       goto done;

                }
        }
 
        switch (af) {
        case AF_INET:
                }
        }
 
        switch (af) {
        case AF_INET:

-               error = tcp_usr_connect(so, dst_se->se_addr, p);
+               error = tcp_usr_connect(so, dst, p);

                break;
 #if INET6
        case AF_INET6:
                break;
 #if INET6
        case AF_INET6:

-               error = tcp6_usr_connect(so, dst_se->se_addr, p);
+               error = tcp6_usr_connect(so, dst, p);

                break;
 #endif /* INET6 */
        default:
                break;
 #endif /* INET6 */
        default:


@@ -539,20 +567,55 @@ tcp_usr_connectx_common(struct socket *so, int af,
                /* NOTREACHED */
        }
 
                /* NOTREACHED */
        }
 

+       if (error != 0) {
+               goto done;
+       }
+
+       /* if there is data, copy it */
+       if (auio != NULL) {
+               socket_unlock(so, 0);
+
+               VERIFY(bytes_written != NULL);
+
+               datalen = uio_resid(auio);
+               error = so->so_proto->pr_usrreqs->pru_sosend(so, NULL,
+                   (uio_t)auio, NULL, NULL, 0);
+               socket_lock(so, 0);
+
+               if (error == 0 || error == EWOULDBLOCK)
+                       *bytes_written = datalen - uio_resid(auio);
+
+               /*
+                * sosend returns EWOULDBLOCK if it's a non-blocking
+                * socket or a timeout occured (this allows to return
+                * the amount of queued data through sendit()).
+                *
+                * However, connectx() returns EINPROGRESS in case of a
+                * blocking socket. So we change the return value here.
+                */
+               if (error == EWOULDBLOCK)
+                       error = EINPROGRESS;
+       }
+

        if (error == 0 && pcid != NULL)
        if (error == 0 && pcid != NULL)

-               *pcid = 1;      /* there is only 1 connection for a TCP */
+               *pcid = 1; /* there is only one connection in regular TCP */
+
+done:
+       if (error && error != EINPROGRESS)
+               so->so_flags1 &= ~SOF1_PRECONNECT_DATA;

 
 

+       inp->inp_flags2 &= ~INP2_CONNECT_IN_PROGRESS;

        return (error);
 }
 
 static int
        return (error);
 }
 
 static int

-tcp_usr_connectx(struct socket *so, struct sockaddr_list **src_sl,
-    struct sockaddr_list **dst_sl, struct proc *p, uint32_t ifscope,
-    associd_t aid, connid_t *pcid, uint32_t flags, void *arg,
-    uint32_t arglen)
+tcp_usr_connectx(struct socket *so, struct sockaddr *src,
+    struct sockaddr *dst, struct proc *p, uint32_t ifscope,
+    sae_associd_t aid, sae_connid_t *pcid, uint32_t flags, void *arg,
+    uint32_t arglen, struct uio *uio, user_ssize_t *bytes_written)

 {
 {

-       return (tcp_usr_connectx_common(so, AF_INET, src_sl, dst_sl,
-           p, ifscope, aid, pcid, flags, arg, arglen));
+       return (tcp_usr_connectx_common(so, AF_INET, src, dst, p, ifscope, aid,
+           pcid, flags, arg, arglen, uio, bytes_written));

 }
 
 #if INET6
 }
 
 #if INET6


@@ -575,23 +638,29 @@ tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
                } else
                        return EINVAL;
        }
                } else
                        return EINVAL;
        }

+#if NECP

 #if FLOW_DIVERT
 #if FLOW_DIVERT

-       else if (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT) {
-               uint32_t fd_ctl_unit = 0;
-               error = flow_divert_check_policy(so, p, FALSE, &fd_ctl_unit);
-               if (error == 0) {
-                       if (fd_ctl_unit > 0) {
-                               error = flow_divert_pcb_init(so, fd_ctl_unit);
-                               if (error == 0) {
-                                       error = flow_divert_connect_out(so, nam, p);
-                               }
-                       } else {
-                               error = ENETDOWN;
+       else if (necp_socket_should_use_flow_divert(inp)) {
+               uint32_t fd_ctl_unit = necp_socket_get_flow_divert_control_unit(inp);
+               if (fd_ctl_unit > 0) {
+                       error = flow_divert_pcb_init(so, fd_ctl_unit);
+                       if (error == 0) {
+                               error = flow_divert_connect_out(so, nam, p);

                        }
                        }

+               } else {
+                       error = ENETDOWN;

                }
                }

+

                return error;
        }
 #endif /* FLOW_DIVERT */
                return error;
        }
 #endif /* FLOW_DIVERT */

+#if CONTENT_FILTER
+       error = cfil_sock_attach(so);
+       if (error != 0)
+               return error;
+#endif /* CONTENT_FILTER */
+#endif /* NECP */
+

        tp = intotcpcb(inp);
        TCPDEBUG1();
 
        tp = intotcpcb(inp);
        TCPDEBUG1();
 


@@ -623,27 +692,27 @@ tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
                inp->inp_vflag &= ~INP_IPV6;
                if ((error = tcp_connect(tp, (struct sockaddr *)&sin, p)) != 0)
                        goto out;
                inp->inp_vflag &= ~INP_IPV6;
                if ((error = tcp_connect(tp, (struct sockaddr *)&sin, p)) != 0)
                        goto out;

-               error = tcp_output(tp);
+
+               error = tcp_connect_complete(so);

                goto out;
        }
        inp->inp_vflag &= ~INP_IPV4;
        inp->inp_vflag |= INP_IPV6;
        if ((error = tcp6_connect(tp, nam, p)) != 0)
                goto out;
                goto out;
        }
        inp->inp_vflag &= ~INP_IPV4;
        inp->inp_vflag |= INP_IPV6;
        if ((error = tcp6_connect(tp, nam, p)) != 0)
                goto out;

-       error = tcp_output(tp);
-       if (error)
-               goto out;
+
+       error = tcp_connect_complete(so);

        COMMON_END(PRU_CONNECT);
 }
 
 static int
        COMMON_END(PRU_CONNECT);
 }
 
 static int

-tcp6_usr_connectx(struct socket *so, struct sockaddr_list **src_sl,
-    struct sockaddr_list **dst_sl, struct proc *p, uint32_t ifscope,
-    associd_t aid, connid_t *pcid, uint32_t flags, void *arg,
-    uint32_t arglen)
+tcp6_usr_connectx(struct socket *so, struct sockaddr*src,
+    struct sockaddr *dst, struct proc *p, uint32_t ifscope,
+    sae_associd_t aid, sae_connid_t *pcid, uint32_t flags, void *arg,
+    uint32_t arglen, struct uio *uio, user_ssize_t *bytes_written)

 {
 {

-       return (tcp_usr_connectx_common(so, AF_INET6, src_sl, dst_sl,
-           p, ifscope, aid, pcid, flags, arg, arglen));
+       return (tcp_usr_connectx_common(so, AF_INET6, src, dst, p, ifscope, aid,
+           pcid, flags, arg, arglen, uio, bytes_written));

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


@@ -665,8 +734,7 @@ tcp_usr_disconnect(struct socket *so)
        struct inpcb *inp = sotoinpcb(so);
        struct tcpcb *tp;
 
        struct inpcb *inp = sotoinpcb(so);
        struct tcpcb *tp;
 

-       lck_mtx_assert(&((struct inpcb *)so->so_pcb)->inpcb_mtx,
-           LCK_MTX_ASSERT_OWNED);
+       socket_lock_assert_owned(so);

        COMMON_START();
         /* In case we got disconnected from the peer */
         if (tp == NULL)
        COMMON_START();
         /* In case we got disconnected from the peer */
         if (tp == NULL)


@@ -679,10 +747,10 @@ tcp_usr_disconnect(struct socket *so)
  * User-protocol pru_disconnectx callback.
  */
 static int
  * User-protocol pru_disconnectx callback.
  */
 static int

-tcp_usr_disconnectx(struct socket *so, associd_t aid, connid_t cid)
+tcp_usr_disconnectx(struct socket *so, sae_associd_t aid, sae_connid_t cid)

 {
 #pragma unused(cid)
 {
 #pragma unused(cid)

-       if (aid != ASSOCID_ANY && aid != ASSOCID_ALL)
+       if (aid != SAE_ASSOCID_ANY && aid != SAE_ASSOCID_ALL)

                return (EINVAL);
 
        return (tcp_usr_disconnect(so));
                return (EINVAL);
 
        return (tcp_usr_disconnect(so));


@@ -709,8 +777,15 @@ tcp_usr_accept(struct socket *so, struct sockaddr **nam)
        }
        if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)
                return (EINVAL);
        }
        if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)
                return (EINVAL);

-       else if (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)
+#if NECP
+       else if (necp_socket_should_use_flow_divert(inp))

                return (EPROTOTYPE);
                return (EPROTOTYPE);

+#if CONTENT_FILTER
+       error = cfil_sock_attach(so);
+       if (error != 0)
+               return (error);
+#endif /* CONTENT_FILTER */
+#endif /* NECP */

 
        tp = intotcpcb(inp);
        TCPDEBUG1();
 
        tp = intotcpcb(inp);
        TCPDEBUG1();


@@ -735,8 +810,15 @@ tcp6_usr_accept(struct socket *so, struct sockaddr **nam)
        }
        if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)
                return (EINVAL);
        }
        if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD)
                return (EINVAL);

-       else if (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)
+#if NECP
+       else if (necp_socket_should_use_flow_divert(inp))

                return (EPROTOTYPE);
                return (EPROTOTYPE);

+#if CONTENT_FILTER
+       error = cfil_sock_attach(so);
+       if (error != 0)
+               return (error);
+#endif /* CONTENT_FILTER */
+#endif /* NECP */

 
        tp = intotcpcb(inp);
        TCPDEBUG1();
 
        tp = intotcpcb(inp);
        TCPDEBUG1();


@@ -784,7 +866,12 @@ tcp_usr_shutdown(struct socket *so)
         */
        tp = intotcpcb(inp);
        TCPDEBUG1();
         */
        tp = intotcpcb(inp);
        TCPDEBUG1();

-        if (tp == NULL || (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)) {
+
+       if (tp == NULL
+#if NECP
+               || (necp_socket_should_use_flow_divert(inp))
+#endif /* NECP */
+               ) {

                if (tp != NULL)
                        error = EPROTOTYPE;
                goto out;
                if (tp != NULL)
                        error = EPROTOTYPE;
                goto out;


@@ -800,6 +887,12 @@ tcp_usr_shutdown(struct socket *so)
                goto out;
        }
 #endif
                goto out;
        }
 #endif

+#if CONTENT_FILTER
+       /* Don't send a FIN yet */
+       if (tp && !(so->so_state & SS_ISDISCONNECTED) &&
+               cfil_sock_data_pending(&so->so_snd))
+               goto out;
+#endif /* CONTENT_FILTER */

        if (tp)
                error = tcp_output(tp);
        COMMON_END(PRU_SHUTDOWN);
        if (tp)
                error = tcp_output(tp);
        COMMON_END(PRU_SHUTDOWN);


@@ -821,7 +914,18 @@ tcp_usr_rcvd(struct socket *so, __unused int flags)
                goto out;
        tcp_sbrcv_trim(tp, &so->so_rcv);
 
                goto out;
        tcp_sbrcv_trim(tp, &so->so_rcv);
 

-       tcp_output(tp);
+       /*
+        * This tcp_output is solely there to trigger window-updates.
+        * However, we really do not want these window-updates while we
+        * are still in SYN_SENT or SYN_RECEIVED.
+        */
+       if (TCPS_HAVEESTABLISHED(tp->t_state))
+               tcp_output(tp);
+
+#if CONTENT_FILTER
+       cfil_sock_buf_update(&so->so_rcv);
+#endif /* CONTENT_FILTER */
+

        COMMON_END(PRU_RCVD);
 }
 
        COMMON_END(PRU_RCVD);
 }
 


@@ -869,8 +973,11 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
 #endif
        TCPDEBUG0;
 
 #endif
        TCPDEBUG0;
 

-       if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD ||
-           (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT)) {
+       if (inp == NULL || inp->inp_state == INPCB_STATE_DEAD
+#if NECP
+               || (necp_socket_should_use_flow_divert(inp))
+#endif /* NECP */
+               ) {

                /*
                 * OOPS! we lost a race, the TCP session got reset after
                 * we checked SS_CANTSENDMORE, eg: while doing uiomove or a
                /*
                 * OOPS! we lost a race, the TCP session got reset after
                 * we checked SS_CANTSENDMORE, eg: while doing uiomove or a


@@ -882,10 +989,11 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
                        m_freem(control);
                        control = NULL;
                }
                        m_freem(control);
                        control = NULL;
                }

-               if (inp != NULL && (inp->inp_flags2 & INP2_WANT_FLOW_DIVERT))
-                       error = EPROTOTYPE;
-               else
+
+               if (inp == NULL)

                        error = ECONNRESET;     /* XXX EPIPE? */
                        error = ECONNRESET;     /* XXX EPIPE? */

+               else
+                       error = EPROTOTYPE;

                tp = NULL;
                TCPDEBUG1();
                goto out;
                tp = NULL;
                TCPDEBUG1();
                goto out;


@@ -913,8 +1021,8 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
                        m_freem(control);
                        control = NULL;
                } else if (control->m_len) {
                        m_freem(control);
                        control = NULL;
                } else if (control->m_len) {

-                       /* 
-                        * if not unordered, TCP should not have 
+                       /*
+                        * if not unordered, TCP should not have

                         * control mbufs
                         */
                        m_freem(control);
                         * control mbufs
                         */
                        m_freem(control);


@@ -936,7 +1044,7 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
        VERIFY(!(so->so_flags & SOF_MP_SUBFLOW) ||
            (so->so_snd.sb_flags & SB_NOCOMPRESS));
 
        VERIFY(!(so->so_flags & SOF_MP_SUBFLOW) ||
            (so->so_snd.sb_flags & SB_NOCOMPRESS));
 

-       if(!(flags & PRUS_OOB)) {
+       if(!(flags & PRUS_OOB) || (so->so_flags1 & SOF1_PRECONNECT_DATA)) {

                /* Call msg send if message delivery is enabled */
                if (so->so_flags & SOF_ENABLE_MSGS)
                        sbappendmsg_snd(&so->so_snd, m);
                /* Call msg send if message delivery is enabled */
                if (so->so_flags & SOF_ENABLE_MSGS)
                        sbappendmsg_snd(&so->so_snd, m);


@@ -944,6 +1052,7 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
                        sbappendstream(&so->so_snd, m);
 
                if (nam && tp->t_state < TCPS_SYN_SENT) {
                        sbappendstream(&so->so_snd, m);
 
                if (nam && tp->t_state < TCPS_SYN_SENT) {

+

                        /*
                         * Do implied connect if not yet connected,
                         * initialize window to default value, and
                        /*
                         * Do implied connect if not yet connected,
                         * initialize window to default value, and


@@ -978,8 +1087,8 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
                                tp->t_flags &= ~TF_MORETOCOME;
                }
        } else {
                                tp->t_flags &= ~TF_MORETOCOME;
                }
        } else {

-               if (sbspace(&so->so_snd) == 0) { 
-                       /* if no space is left in sockbuf, 
+               if (sbspace(&so->so_snd) == 0) {
+                       /* if no space is left in sockbuf,

                         * do not try to squeeze in OOB traffic */
                        m_freem(m);
                        error = ENOBUFS;
                         * do not try to squeeze in OOB traffic */
                        m_freem(m);
                        error = ENOBUFS;


@@ -1013,11 +1122,24 @@ tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
                        tcp_mss(tp, -1, IFSCOPE_NONE);
                }
                tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
                        tcp_mss(tp, -1, IFSCOPE_NONE);
                }
                tp->snd_up = tp->snd_una + so->so_snd.sb_cc;

-               tp->t_force = 1;
+               tp->t_flagsext |= TF_FORCE;

                error = tcp_output(tp);
                error = tcp_output(tp);

-               tp->t_force = 0;
+               tp->t_flagsext &= ~TF_FORCE;
+       }
+
+
+       /*
+        * We wait for the socket to successfully connect before returning.
+        * This allows us to signal a timeout to the application.
+        */
+       if (so->so_state & SS_ISCONNECTING) {
+               if (so->so_state & SS_NBIO)
+                       error = EWOULDBLOCK;
+               else
+                       error = sbwait(&so->so_snd);

        }
        }

-       COMMON_END((flags & PRUS_OOB) ? PRU_SENDOOB : 
+
+       COMMON_END((flags & PRUS_OOB) ? PRU_SENDOOB :

                   ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
 }
 
                   ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
 }
 


@@ -1036,6 +1158,7 @@ tcp_usr_abort(struct socket *so)
         if (tp == NULL)
                goto out;
        tp = tcp_drop(tp, ECONNABORTED);
         if (tp == NULL)
                goto out;
        tp = tcp_drop(tp, ECONNABORTED);

+       VERIFY(so->so_usecount > 0);

        so->so_usecount--;
        COMMON_END(PRU_ABORT);
 }
        so->so_usecount--;
        COMMON_END(PRU_ABORT);
 }


@@ -1069,11 +1192,35 @@ tcp_usr_rcvoob(struct socket *so, struct mbuf *m, int flags)
        }
        m->m_len = 1;
        *mtod(m, caddr_t) = tp->t_iobc;
        }
        m->m_len = 1;
        *mtod(m, caddr_t) = tp->t_iobc;

+       so->so_state &= ~SS_RCVATMARK;

        if ((flags & MSG_PEEK) == 0)
                tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
        COMMON_END(PRU_RCVOOB);
 }
 
        if ((flags & MSG_PEEK) == 0)
                tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
        COMMON_END(PRU_RCVOOB);
 }
 

+static int
+tcp_usr_preconnect(struct socket *so)
+{
+       struct inpcb *inp = sotoinpcb(so);
+       int error = 0;
+
+#if NECP
+       if (necp_socket_should_use_flow_divert(inp)) {
+               /* May happen, if in tcp_usr_connect we did not had a chance
+                * to set the usrreqs (due to some error). So, let's get out
+                * of here.
+                */
+               goto out;
+       }
+#endif /* NECP */
+
+       error = tcp_output(sototcpcb(so));
+
+       soclearfastopen(so);
+
+       COMMON_END(PRU_PRECONNECT);
+}
+

 /* xxx - should be const */
 struct pr_usrreqs tcp_usrreqs = {
        .pru_abort =            tcp_usr_abort,
 /* xxx - should be const */
 struct pr_usrreqs tcp_usrreqs = {
        .pru_abort =            tcp_usr_abort,


@@ -1095,6 +1242,7 @@ struct pr_usrreqs tcp_usrreqs = {
        .pru_sockaddr =         in_getsockaddr,
        .pru_sosend =           sosend,
        .pru_soreceive =        soreceive,
        .pru_sockaddr =         in_getsockaddr,
        .pru_sosend =           sosend,
        .pru_soreceive =        soreceive,

+       .pru_preconnect =       tcp_usr_preconnect,

 };
 
 #if INET6
 };
 
 #if INET6


@@ -1118,6 +1266,7 @@ struct pr_usrreqs tcp6_usrreqs = {
        .pru_sockaddr =         in6_mapped_sockaddr,
        .pru_sosend =           sosend,
        .pru_soreceive =        soreceive,
        .pru_sockaddr =         in6_mapped_sockaddr,
        .pru_sosend =           sosend,
        .pru_soreceive =        soreceive,

+       .pru_preconnect =       tcp_usr_preconnect,

 };
 #endif /* INET6 */
 
 };
 #endif /* INET6 */
 


@@ -1146,18 +1295,13 @@ struct pr_usrreqs tcp6_usrreqs = {
  *     in_pcbladdr:EADDRNOTAVAIL       Address not available
  */
 static int
  *     in_pcbladdr:EADDRNOTAVAIL       Address not available
  */
 static int

-tcp_connect(tp, nam, p)
-       register struct tcpcb *tp;
-       struct sockaddr *nam;
-       struct proc *p;
+tcp_connect(struct tcpcb *tp, struct sockaddr *nam, struct proc *p)

 {
        struct inpcb *inp = tp->t_inpcb, *oinp;
        struct socket *so = inp->inp_socket;
        struct tcpcb *otp;
        struct sockaddr_in *sin = (struct sockaddr_in *)(void *)nam;
        struct in_addr laddr;
 {
        struct inpcb *inp = tp->t_inpcb, *oinp;
        struct socket *so = inp->inp_socket;
        struct tcpcb *otp;
        struct sockaddr_in *sin = (struct sockaddr_in *)(void *)nam;
        struct in_addr laddr;

-       struct rmxp_tao *taop;
-       struct rmxp_tao tao_noncached;

        int error = 0;
        struct ifnet *outif = NULL;
 
        int error = 0;
        struct ifnet *outif = NULL;
 


@@ -1172,23 +1316,23 @@ tcp_connect(tp, nam, p)
         * earlier incarnation of this same connection still in
         * TIME_WAIT state, creating an ADDRINUSE error.
         */
         * earlier incarnation of this same connection still in
         * TIME_WAIT state, creating an ADDRINUSE error.
         */

-       error = in_pcbladdr(inp, nam, &laddr, IFSCOPE_NONE, &outif);
+       error = in_pcbladdr(inp, nam, &laddr, IFSCOPE_NONE, &outif, 0);

        if (error)
                goto done;
 
        if (error)
                goto done;
 

-       tcp_unlock(inp->inp_socket, 0, 0);
+       socket_unlock(inp->inp_socket, 0);

        oinp = in_pcblookup_hash(inp->inp_pcbinfo,
            sin->sin_addr, sin->sin_port,
            inp->inp_laddr.s_addr != INADDR_ANY ? inp->inp_laddr : laddr,
            inp->inp_lport,  0, NULL);
 
        oinp = in_pcblookup_hash(inp->inp_pcbinfo,
            sin->sin_addr, sin->sin_port,
            inp->inp_laddr.s_addr != INADDR_ANY ? inp->inp_laddr : laddr,
            inp->inp_lport,  0, NULL);
 

-       tcp_lock(inp->inp_socket, 0, 0);
+       socket_lock(inp->inp_socket, 0);

        if (oinp) {
                if (oinp != inp) /* 4143933: avoid deadlock if inp == oinp */
        if (oinp) {
                if (oinp != inp) /* 4143933: avoid deadlock if inp == oinp */

-                       tcp_lock(oinp->inp_socket, 1, 0);
+                       socket_lock(oinp->inp_socket, 1);

                if (in_pcb_checkstate(oinp, WNT_RELEASE, 1) == WNT_STOPUSING) {
                        if (oinp != inp)
                if (in_pcb_checkstate(oinp, WNT_RELEASE, 1) == WNT_STOPUSING) {
                        if (oinp != inp)

-                               tcp_unlock(oinp->inp_socket, 1, 0);
+                               socket_unlock(oinp->inp_socket, 1);

                        goto skip_oinp;
                }
 
                        goto skip_oinp;
                }
 


@@ -1201,12 +1345,12 @@ tcp_connect(tp, nam, p)
                        printf("tcp_connect: inp=0x%llx err=EADDRINUSE\n",
                            (uint64_t)VM_KERNEL_ADDRPERM(inp));
                        if (oinp != inp)
                        printf("tcp_connect: inp=0x%llx err=EADDRINUSE\n",
                            (uint64_t)VM_KERNEL_ADDRPERM(inp));
                        if (oinp != inp)

-                               tcp_unlock(oinp->inp_socket, 1, 0);
+                               socket_unlock(oinp->inp_socket, 1);

                        error = EADDRINUSE;
                        goto done;
                }
                if (oinp != inp)
                        error = EADDRINUSE;
                        goto done;
                }
                if (oinp != inp)

-                       tcp_unlock(oinp->inp_socket, 1, 0);
+                       socket_unlock(oinp->inp_socket, 1);

        }
 skip_oinp:
        if ((inp->inp_laddr.s_addr == INADDR_ANY ? laddr.s_addr :
        }
 skip_oinp:
        if ((inp->inp_laddr.s_addr == INADDR_ANY ? laddr.s_addr :


@@ -1225,6 +1369,7 @@ skip_oinp:
                inp->inp_laddr = laddr;
                /* no reference needed */
                inp->inp_last_outifp = outif;
                inp->inp_laddr = laddr;
                /* no reference needed */
                inp->inp_last_outifp = outif;

+

                inp->inp_flags |= INP_INADDR_ANY;
        }
        inp->inp_faddr = sin->sin_addr;
                inp->inp_flags |= INP_INADDR_ANY;
        }
        inp->inp_faddr = sin->sin_addr;


@@ -1235,7 +1380,7 @@ skip_oinp:
        if (inp->inp_flowhash == 0)
                inp->inp_flowhash = inp_calc_flowhash(inp);
 
        if (inp->inp_flowhash == 0)
                inp->inp_flowhash = inp_calc_flowhash(inp);
 

-       tcp_set_max_rwinscale(tp, so);
+       tcp_set_max_rwinscale(tp, so, TCP_AUTORCVBUF_MAX(outif));

 
        soisconnecting(so);
        tcpstat.tcps_connattempt++;
 
        soisconnecting(so);
        tcpstat.tcps_connattempt++;


@@ -1246,24 +1391,6 @@ skip_oinp:
        if (nstat_collect)
                nstat_route_connect_attempt(inp->inp_route.ro_rt);
 
        if (nstat_collect)
                nstat_route_connect_attempt(inp->inp_route.ro_rt);
 

-       /*
-        * Generate a CC value for this connection and
-        * check whether CC or CCnew should be used.
-        */
-       if ((taop = tcp_gettaocache(tp->t_inpcb)) == NULL) {
-               taop = &tao_noncached;
-               bzero(taop, sizeof(*taop));
-       }
-
-       tp->cc_send = CC_INC(tcp_ccgen);
-       if (taop->tao_ccsent != 0 &&
-           CC_GEQ(tp->cc_send, taop->tao_ccsent)) {
-               taop->tao_ccsent = tp->cc_send;
-       } else {
-               taop->tao_ccsent = 0;
-               tp->t_flags |= TF_SENDCCNEW;
-       }
-

 done:
        if (outif != NULL)
                ifnet_release(outif);
 done:
        if (outif != NULL)
                ifnet_release(outif);


@@ -1273,18 +1400,13 @@ done:
 
 #if INET6
 static int
 
 #if INET6
 static int

-tcp6_connect(tp, nam, p)
-       register struct tcpcb *tp;
-       struct sockaddr *nam;
-       struct proc *p;
+tcp6_connect(struct tcpcb *tp, struct sockaddr *nam, struct proc *p)

 {
        struct inpcb *inp = tp->t_inpcb, *oinp;
        struct socket *so = inp->inp_socket;
        struct tcpcb *otp;
        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)(void *)nam;
        struct in6_addr addr6;
 {
        struct inpcb *inp = tp->t_inpcb, *oinp;
        struct socket *so = inp->inp_socket;
        struct tcpcb *otp;
        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)(void *)nam;
        struct in6_addr addr6;

-       struct rmxp_tao *taop;
-       struct rmxp_tao tao_noncached;

        int error = 0;
        struct ifnet *outif = NULL;
 
        int error = 0;
        struct ifnet *outif = NULL;
 


@@ -1306,14 +1428,14 @@ tcp6_connect(tp, nam, p)
        error = in6_pcbladdr(inp, nam, &addr6, &outif);
        if (error)
                goto done;
        error = in6_pcbladdr(inp, nam, &addr6, &outif);
        if (error)
                goto done;

-       tcp_unlock(inp->inp_socket, 0, 0);
+       socket_unlock(inp->inp_socket, 0);

        oinp = in6_pcblookup_hash(inp->inp_pcbinfo,
                                  &sin6->sin6_addr, sin6->sin6_port,
                                  IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)
                                  ? &addr6
                                  : &inp->in6p_laddr,
                                  inp->inp_lport,  0, NULL);
        oinp = in6_pcblookup_hash(inp->inp_pcbinfo,
                                  &sin6->sin6_addr, sin6->sin6_port,
                                  IN6_IS_ADDR_UNSPECIFIED(&inp->in6p_laddr)
                                  ? &addr6
                                  : &inp->in6p_laddr,
                                  inp->inp_lport,  0, NULL);

-       tcp_lock(inp->inp_socket, 0, 0);
+       socket_lock(inp->inp_socket, 0);

        if (oinp) {
                if (oinp != inp && (otp = intotcpcb(oinp)) != NULL &&
                    otp->t_state == TCPS_TIME_WAIT &&
        if (oinp) {
                if (oinp != inp && (otp = intotcpcb(oinp)) != NULL &&
                    otp->t_state == TCPS_TIME_WAIT &&


@@ -1352,36 +1474,18 @@ tcp6_connect(tp, nam, p)
                    (htonl(inp->inp_flowhash) & IPV6_FLOWLABEL_MASK);
        }
 
                    (htonl(inp->inp_flowhash) & IPV6_FLOWLABEL_MASK);
        }
 

-       tcp_set_max_rwinscale(tp, so);
+       tcp_set_max_rwinscale(tp, so, TCP_AUTORCVBUF_MAX(outif));

 
        soisconnecting(so);
        tcpstat.tcps_connattempt++;
        tp->t_state = TCPS_SYN_SENT;
 
        soisconnecting(so);
        tcpstat.tcps_connattempt++;
        tp->t_state = TCPS_SYN_SENT;

-       tp->t_timer[TCPT_KEEP] = OFFSET_FROM_START(tp, 
+       tp->t_timer[TCPT_KEEP] = OFFSET_FROM_START(tp,

                TCP_CONN_KEEPINIT(tp));
        tp->iss = tcp_new_isn(tp);
        tcp_sendseqinit(tp);
        if (nstat_collect)
                nstat_route_connect_attempt(inp->inp_route.ro_rt);
 
                TCP_CONN_KEEPINIT(tp));
        tp->iss = tcp_new_isn(tp);
        tcp_sendseqinit(tp);
        if (nstat_collect)
                nstat_route_connect_attempt(inp->inp_route.ro_rt);
 

-       /*
-        * Generate a CC value for this connection and
-        * check whether CC or CCnew should be used.
-        */
-       if ((taop = tcp_gettaocache(tp->t_inpcb)) == NULL) {
-               taop = &tao_noncached;
-               bzero(taop, sizeof(*taop));
-       }
-
-       tp->cc_send = CC_INC(tcp_ccgen);
-       if (taop->tao_ccsent != 0 &&
-           CC_GEQ(tp->cc_send, taop->tao_ccsent)) {
-               taop->tao_ccsent = tp->cc_send;
-       } else {
-               taop->tao_ccsent = 0;
-               tp->t_flags |= TF_SENDCCNEW;
-       }
-

 done:
        if (outif != NULL)
                ifnet_release(outif);
 done:
        if (outif != NULL)
                ifnet_release(outif);


@@ -1393,31 +1497,35 @@ done:
 /*
  * Export TCP internal state information via a struct tcp_info
  */
 /*
  * Export TCP internal state information via a struct tcp_info
  */

-__private_extern__ void
+void

 tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
 {
        struct inpcb *inp = tp->t_inpcb;
 tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
 {
        struct inpcb *inp = tp->t_inpcb;

-       
+

        bzero(ti, sizeof(*ti));
 
        ti->tcpi_state = tp->t_state;
        bzero(ti, sizeof(*ti));
 
        ti->tcpi_state = tp->t_state;

-       
+       ti->tcpi_flowhash = inp->inp_flowhash;
+

        if (tp->t_state > TCPS_LISTEN) {
        if (tp->t_state > TCPS_LISTEN) {

-               if ((tp->t_flags & TF_REQ_TSTMP) && (tp->t_flags & TF_RCVD_TSTMP))
+               if (TSTMP_SUPPORTED(tp))

                        ti->tcpi_options |= TCPI_OPT_TIMESTAMPS;
                        ti->tcpi_options |= TCPI_OPT_TIMESTAMPS;

-               if (tp->t_flags & TF_SACK_PERMIT)
+               if (SACK_ENABLED(tp))

                        ti->tcpi_options |= TCPI_OPT_SACK;
                        ti->tcpi_options |= TCPI_OPT_SACK;

-               if ((tp->t_flags & TF_REQ_SCALE) && (tp->t_flags & TF_RCVD_SCALE)) {
+               if (TCP_WINDOW_SCALE_ENABLED(tp)) {

                        ti->tcpi_options |= TCPI_OPT_WSCALE;
                        ti->tcpi_snd_wscale = tp->snd_scale;
                        ti->tcpi_rcv_wscale = tp->rcv_scale;
                }
                        ti->tcpi_options |= TCPI_OPT_WSCALE;
                        ti->tcpi_snd_wscale = tp->snd_scale;
                        ti->tcpi_rcv_wscale = tp->rcv_scale;
                }

+               if (TCP_ECN_ENABLED(tp))
+                       ti->tcpi_options |= TCPI_OPT_ECN;

 
                /* Are we in retranmission episode */
 
                /* Are we in retranmission episode */

-               if (tp->snd_max != tp->snd_nxt)
+               if (IN_FASTRECOVERY(tp) || tp->t_rxtshift > 0)

                        ti->tcpi_flags |= TCPI_FLAG_LOSSRECOVERY;
                        ti->tcpi_flags |= TCPI_FLAG_LOSSRECOVERY;

-               else
-                       ti->tcpi_flags &= ~TCPI_FLAG_LOSSRECOVERY;
+
+               if (tp->t_flags & TF_STREAMING_ON)
+                       ti->tcpi_flags |= TCPI_FLAG_STREAMING_ON;

 
                ti->tcpi_rto = tp->t_timer[TCPT_REXMT] ? tp->t_rxtcur : 0;
                ti->tcpi_snd_mss = tp->t_maxseg;
 
                ti->tcpi_rto = tp->t_timer[TCPT_REXMT] ? tp->t_rxtcur : 0;
                ti->tcpi_snd_mss = tp->t_maxseg;


@@ -1430,8 +1538,8 @@ tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
 
                ti->tcpi_snd_ssthresh = tp->snd_ssthresh;
                ti->tcpi_snd_cwnd = tp->snd_cwnd;
 
                ti->tcpi_snd_ssthresh = tp->snd_ssthresh;
                ti->tcpi_snd_cwnd = tp->snd_cwnd;

-               ti->tcpi_snd_sbbytes = tp->t_inpcb->inp_socket->so_snd.sb_cc;
-       
+               ti->tcpi_snd_sbbytes = inp->inp_socket->so_snd.sb_cc;
+

                ti->tcpi_rcv_space = tp->rcv_wnd;
 
                ti->tcpi_snd_wnd = tp->snd_wnd;
                ti->tcpi_rcv_space = tp->rcv_wnd;
 
                ti->tcpi_snd_wnd = tp->snd_wnd;


@@ -1443,7 +1551,7 @@ tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
                        tp->t_bwmeas != NULL) {
                        ti->tcpi_snd_bw = (tp->t_bwmeas->bw_sndbw * 8000);
                }
                        tp->t_bwmeas != NULL) {
                        ti->tcpi_snd_bw = (tp->t_bwmeas->bw_sndbw * 8000);
                }

-               
+

                ti->tcpi_last_outif = (tp->t_inpcb->inp_last_outifp == NULL) ? 0 :
                    tp->t_inpcb->inp_last_outifp->if_index;
 
                ti->tcpi_last_outif = (tp->t_inpcb->inp_last_outifp == NULL) ? 0 :
                    tp->t_inpcb->inp_last_outifp->if_index;
 


@@ -1451,8 +1559,9 @@ tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
                ti->tcpi_txpackets = inp->inp_stat->txpackets;
                ti->tcpi_txbytes = inp->inp_stat->txbytes;
                ti->tcpi_txretransmitbytes = tp->t_stat.txretransmitbytes;
                ti->tcpi_txpackets = inp->inp_stat->txpackets;
                ti->tcpi_txbytes = inp->inp_stat->txbytes;
                ti->tcpi_txretransmitbytes = tp->t_stat.txretransmitbytes;

+               ti->tcpi_txretransmitpackets = tp->t_stat.rxmitpkts;

                ti->tcpi_txunacked = tp->snd_max - tp->snd_una;
                ti->tcpi_txunacked = tp->snd_max - tp->snd_una;

-               
+

                //atomic_get_64(ti->tcpi_rxbytes, &inp->inp_stat->rxbytes);
                ti->tcpi_rxpackets = inp->inp_stat->rxpackets;
                ti->tcpi_rxbytes = inp->inp_stat->rxbytes;
                //atomic_get_64(ti->tcpi_rxbytes, &inp->inp_stat->rxbytes);
                ti->tcpi_rxpackets = inp->inp_stat->rxpackets;
                ti->tcpi_rxbytes = inp->inp_stat->rxbytes;


@@ -1471,6 +1580,65 @@ tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
                ti->tcpi_wifi_rxbytes = inp->inp_wstat->rxbytes;
                ti->tcpi_wifi_txpackets = inp->inp_wstat->txpackets;
                ti->tcpi_wifi_txbytes = inp->inp_wstat->txbytes;
                ti->tcpi_wifi_rxbytes = inp->inp_wstat->rxbytes;
                ti->tcpi_wifi_txpackets = inp->inp_wstat->txpackets;
                ti->tcpi_wifi_txbytes = inp->inp_wstat->txbytes;

+
+               ti->tcpi_wired_rxpackets = inp->inp_Wstat->rxpackets;
+               ti->tcpi_wired_rxbytes = inp->inp_Wstat->rxbytes;
+               ti->tcpi_wired_txpackets = inp->inp_Wstat->txpackets;
+               ti->tcpi_wired_txbytes = inp->inp_Wstat->txbytes;
+               tcp_get_connectivity_status(tp, &ti->tcpi_connstatus);
+
+               ti->tcpi_tfo_syn_data_rcv = !!(tp->t_tfo_stats & TFO_S_SYNDATA_RCV);
+               ti->tcpi_tfo_cookie_req_rcv = !!(tp->t_tfo_stats & TFO_S_COOKIEREQ_RECV);
+               ti->tcpi_tfo_cookie_sent = !!(tp->t_tfo_stats & TFO_S_COOKIE_SENT);
+               ti->tcpi_tfo_cookie_invalid = !!(tp->t_tfo_stats & TFO_S_COOKIE_INVALID);
+
+               ti->tcpi_tfo_cookie_req = !!(tp->t_tfo_stats & TFO_S_COOKIE_REQ);
+               ti->tcpi_tfo_cookie_rcv = !!(tp->t_tfo_stats & TFO_S_COOKIE_RCV);
+               ti->tcpi_tfo_syn_data_sent = !!(tp->t_tfo_stats & TFO_S_SYN_DATA_SENT);
+               ti->tcpi_tfo_syn_data_acked = !!(tp->t_tfo_stats & TFO_S_SYN_DATA_ACKED);
+               ti->tcpi_tfo_syn_loss = !!(tp->t_tfo_stats & TFO_S_SYN_LOSS);
+               ti->tcpi_tfo_cookie_wrong = !!(tp->t_tfo_stats & TFO_S_COOKIE_WRONG);
+               ti->tcpi_tfo_no_cookie_rcv = !!(tp->t_tfo_stats & TFO_S_NO_COOKIE_RCV);
+               ti->tcpi_tfo_heuristics_disable = !!(tp->t_tfo_stats & TFO_S_HEURISTICS_DISABLE);
+               ti->tcpi_tfo_send_blackhole = !!(tp->t_tfo_stats & TFO_S_SEND_BLACKHOLE);
+               ti->tcpi_tfo_recv_blackhole = !!(tp->t_tfo_stats & TFO_S_RECV_BLACKHOLE);
+               ti->tcpi_tfo_onebyte_proxy = !!(tp->t_tfo_stats & TFO_S_ONE_BYTE_PROXY);
+
+               ti->tcpi_ecn_client_setup = !!(tp->ecn_flags & TE_SETUPSENT);
+               ti->tcpi_ecn_server_setup = !!(tp->ecn_flags & TE_SETUPRECEIVED);
+               ti->tcpi_ecn_success = (tp->ecn_flags & TE_ECN_ON) == TE_ECN_ON ? 1 : 0;
+               ti->tcpi_ecn_lost_syn = !!(tp->ecn_flags & TE_LOST_SYN);
+               ti->tcpi_ecn_lost_synack = !!(tp->ecn_flags & TE_LOST_SYNACK);
+
+               ti->tcpi_local_peer = !!(tp->t_flags & TF_LOCAL);
+
+               if (tp->t_inpcb->inp_last_outifp != NULL) {
+                       if (IFNET_IS_CELLULAR(tp->t_inpcb->inp_last_outifp))
+                               ti->tcpi_if_cell = 1;
+                       if (IFNET_IS_WIFI(tp->t_inpcb->inp_last_outifp))
+                               ti->tcpi_if_wifi = 1;
+                       if (IFNET_IS_WIRED(tp->t_inpcb->inp_last_outifp))
+                               ti->tcpi_if_wired = 1;
+                       if (IFNET_IS_WIFI_INFRA(tp->t_inpcb->inp_last_outifp))
+                               ti->tcpi_if_wifi_infra = 1;
+                       if (tp->t_inpcb->inp_last_outifp->if_eflags & IFEF_AWDL)
+                               ti->tcpi_if_wifi_awdl = 1;
+               }
+               if (tp->tcp_cc_index == TCP_CC_ALGO_BACKGROUND_INDEX)
+                       ti->tcpi_snd_background = 1;
+               if (tcp_recv_bg == 1 ||
+                   IS_TCP_RECV_BG(tp->t_inpcb->inp_socket))
+                       ti->tcpi_rcv_background = 1;
+
+               ti->tcpi_ecn_recv_ce = tp->t_ecn_recv_ce;
+               ti->tcpi_ecn_recv_cwr = tp->t_ecn_recv_cwr;
+
+               ti->tcpi_rcvoopack = tp->t_rcvoopack;
+               ti->tcpi_pawsdrop = tp->t_pawsdrop;
+               ti->tcpi_sack_recovery_episode = tp->t_sack_recovery_episode;
+               ti->tcpi_reordered_pkts = tp->t_reordered_pkts;
+               ti->tcpi_dsack_sent = tp->t_dsack_sent;
+               ti->tcpi_dsack_recvd = tp->t_dsack_recvd;

        }
 }
 
        }
 }
 


@@ -1481,15 +1649,15 @@ tcp_fill_info_for_info_tuple(struct info_tuple *itpl, struct tcp_info *ti)
        struct inpcb *inp = NULL;
        struct socket *so;
        struct tcpcb *tp;
        struct inpcb *inp = NULL;
        struct socket *so;
        struct tcpcb *tp;

-       
+

        if (itpl->itpl_proto == IPPROTO_TCP)
                pcbinfo = &tcbinfo;
        else
                return EINVAL;
        if (itpl->itpl_proto == IPPROTO_TCP)
                pcbinfo = &tcbinfo;
        else
                return EINVAL;

-       
+

        if (itpl->itpl_local_sa.sa_family == AF_INET &&
                itpl->itpl_remote_sa.sa_family == AF_INET) {
        if (itpl->itpl_local_sa.sa_family == AF_INET &&
                itpl->itpl_remote_sa.sa_family == AF_INET) {

-               inp = in_pcblookup_hash(pcbinfo, 
+               inp = in_pcblookup_hash(pcbinfo,

                        itpl->itpl_remote_sin.sin_addr,
                        itpl->itpl_remote_sin.sin_port,
                        itpl->itpl_local_sin.sin_addr,
                        itpl->itpl_remote_sin.sin_addr,
                        itpl->itpl_remote_sin.sin_port,
                        itpl->itpl_local_sin.sin_addr,


@@ -1499,18 +1667,18 @@ tcp_fill_info_for_info_tuple(struct info_tuple *itpl, struct tcp_info *ti)
                itpl->itpl_remote_sa.sa_family == AF_INET6) {
                struct in6_addr ina6_local;
                struct in6_addr ina6_remote;
                itpl->itpl_remote_sa.sa_family == AF_INET6) {
                struct in6_addr ina6_local;
                struct in6_addr ina6_remote;

-               
+

                ina6_local = itpl->itpl_local_sin6.sin6_addr;
                ina6_local = itpl->itpl_local_sin6.sin6_addr;

-               if (IN6_IS_SCOPE_LINKLOCAL(&ina6_local) && 
+               if (IN6_IS_SCOPE_LINKLOCAL(&ina6_local) &&

                        itpl->itpl_local_sin6.sin6_scope_id)
                        ina6_local.s6_addr16[1] = htons(itpl->itpl_local_sin6.sin6_scope_id);
 
                ina6_remote = itpl->itpl_remote_sin6.sin6_addr;
                        itpl->itpl_local_sin6.sin6_scope_id)
                        ina6_local.s6_addr16[1] = htons(itpl->itpl_local_sin6.sin6_scope_id);
 
                ina6_remote = itpl->itpl_remote_sin6.sin6_addr;

-               if (IN6_IS_SCOPE_LINKLOCAL(&ina6_remote) && 
+               if (IN6_IS_SCOPE_LINKLOCAL(&ina6_remote) &&

                        itpl->itpl_remote_sin6.sin6_scope_id)
                        ina6_remote.s6_addr16[1] = htons(itpl->itpl_remote_sin6.sin6_scope_id);
                        itpl->itpl_remote_sin6.sin6_scope_id)
                        ina6_remote.s6_addr16[1] = htons(itpl->itpl_remote_sin6.sin6_scope_id);

-               
-               inp = in6_pcblookup_hash(pcbinfo, 
+
+               inp = in6_pcblookup_hash(pcbinfo,

                        &ina6_remote,
                        itpl->itpl_remote_sin6.sin6_port,
                        &ina6_local,
                        &ina6_remote,
                        itpl->itpl_remote_sin6.sin6_port,
                        &ina6_local,


@@ -1535,13 +1703,74 @@ tcp_fill_info_for_info_tuple(struct info_tuple *itpl, struct tcp_info *ti)
        return 0;
 }
 
        return 0;
 }
 

+static void
+tcp_connection_fill_info(struct tcpcb *tp, struct tcp_connection_info *tci)
+{
+       struct inpcb *inp = tp->t_inpcb;
+
+       bzero(tci, sizeof(*tci));
+       tci->tcpi_state = tp->t_state;
+       if (tp->t_state > TCPS_LISTEN) {
+               if (TSTMP_SUPPORTED(tp))
+                       tci->tcpi_options |= TCPCI_OPT_TIMESTAMPS;
+               if (SACK_ENABLED(tp))
+                       tci->tcpi_options |= TCPCI_OPT_SACK;
+               if (TCP_WINDOW_SCALE_ENABLED(tp)) {
+                       tci->tcpi_options |= TCPCI_OPT_WSCALE;
+                       tci->tcpi_snd_wscale = tp->snd_scale;
+                       tci->tcpi_rcv_wscale = tp->rcv_scale;
+               }
+               if (TCP_ECN_ENABLED(tp))
+                       tci->tcpi_options |= TCPCI_OPT_ECN;
+               if (IN_FASTRECOVERY(tp) || tp->t_rxtshift > 0)
+                       tci->tcpi_flags |= TCPCI_FLAG_LOSSRECOVERY;
+               if (tp->t_flagsext & TF_PKTS_REORDERED)
+                       tci->tcpi_flags |= TCPCI_FLAG_REORDERING_DETECTED;
+               tci->tcpi_rto = (tp->t_timer[TCPT_REXMT] > 0) ?
+                       tp->t_rxtcur : 0;
+               tci->tcpi_maxseg = tp->t_maxseg;
+               tci->tcpi_snd_ssthresh = tp->snd_ssthresh;
+               tci->tcpi_snd_cwnd = tp->snd_cwnd;
+               tci->tcpi_snd_wnd = tp->snd_wnd;
+               tci->tcpi_snd_sbbytes = inp->inp_socket->so_snd.sb_cc;
+               tci->tcpi_rcv_wnd = tp->rcv_wnd;
+               tci->tcpi_rttcur = tp->t_rttcur;
+               tci->tcpi_srtt = (tp->t_srtt >> TCP_RTT_SHIFT);
+               tci->tcpi_rttvar = (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
+               tci->tcpi_txpackets = inp->inp_stat->txpackets;
+               tci->tcpi_txbytes = inp->inp_stat->txbytes;
+               tci->tcpi_txretransmitbytes = tp->t_stat.txretransmitbytes;
+               tci->tcpi_txretransmitpackets = tp->t_stat.rxmitpkts;
+               tci->tcpi_rxpackets = inp->inp_stat->rxpackets;
+               tci->tcpi_rxbytes = inp->inp_stat->rxbytes;
+               tci->tcpi_rxoutoforderbytes = tp->t_stat.rxoutoforderbytes;
+
+               tci->tcpi_tfo_syn_data_rcv = !!(tp->t_tfo_stats & TFO_S_SYNDATA_RCV);
+               tci->tcpi_tfo_cookie_req_rcv = !!(tp->t_tfo_stats & TFO_S_COOKIEREQ_RECV);
+               tci->tcpi_tfo_cookie_sent = !!(tp->t_tfo_stats & TFO_S_COOKIE_SENT);
+               tci->tcpi_tfo_cookie_invalid = !!(tp->t_tfo_stats & TFO_S_COOKIE_INVALID);
+               tci->tcpi_tfo_cookie_req = !!(tp->t_tfo_stats & TFO_S_COOKIE_REQ);
+               tci->tcpi_tfo_cookie_rcv = !!(tp->t_tfo_stats & TFO_S_COOKIE_RCV);
+               tci->tcpi_tfo_syn_data_sent = !!(tp->t_tfo_stats & TFO_S_SYN_DATA_SENT);
+               tci->tcpi_tfo_syn_data_acked = !!(tp->t_tfo_stats & TFO_S_SYN_DATA_ACKED);
+               tci->tcpi_tfo_syn_loss = !!(tp->t_tfo_stats & TFO_S_SYN_LOSS);
+               tci->tcpi_tfo_cookie_wrong = !!(tp->t_tfo_stats & TFO_S_COOKIE_WRONG);
+               tci->tcpi_tfo_no_cookie_rcv = !!(tp->t_tfo_stats & TFO_S_NO_COOKIE_RCV);
+               tci->tcpi_tfo_heuristics_disable = !!(tp->t_tfo_stats & TFO_S_HEURISTICS_DISABLE);
+               tci->tcpi_tfo_send_blackhole = !!(tp->t_tfo_stats & TFO_S_SEND_BLACKHOLE);
+               tci->tcpi_tfo_recv_blackhole = !!(tp->t_tfo_stats & TFO_S_RECV_BLACKHOLE);
+               tci->tcpi_tfo_onebyte_proxy = !!(tp->t_tfo_stats & TFO_S_ONE_BYTE_PROXY);
+       }
+}
+

 
 

-__private_extern__ int 
+__private_extern__ int

 tcp_sysctl_info(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
 {
        int error;
 tcp_sysctl_info(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
 {
        int error;

-       struct tcp_info ti;
+       struct tcp_info ti = {};

        struct info_tuple itpl;
        struct info_tuple itpl;

+#if !CONFIG_EMBEDDED

        proc_t caller = PROC_NULL;
        proc_t caller_parent = PROC_NULL;
        char command_name[MAXCOMLEN + 1] = "";
        proc_t caller = PROC_NULL;
        proc_t caller_parent = PROC_NULL;
        char command_name[MAXCOMLEN + 1] = "";


@@ -1558,9 +1787,9 @@ tcp_sysctl_info(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused
                        proc_rele(caller_parent);
                }
 
                        proc_rele(caller_parent);
                }
 

-               if ((escape_str(command_name, strlen(command_name),
+               if ((escape_str(command_name, strlen(command_name) + 1,

                    sizeof(command_name)) == 0) &&
                    sizeof(command_name)) == 0) &&

-                   (escape_str(parent_name, strlen(parent_name),
+                   (escape_str(parent_name, strlen(parent_name) + 1,

                    sizeof(parent_name)) == 0)) {
                        kern_asl_msg(LOG_DEBUG, "messagetracer",
                            5,
                    sizeof(parent_name)) == 0)) {
                        kern_asl_msg(LOG_DEBUG, "messagetracer",
                            5,


@@ -1577,6 +1806,7 @@ tcp_sysctl_info(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused
 
        if (caller != PROC_NULL)
                proc_rele(caller);
 
        if (caller != PROC_NULL)
                proc_rele(caller);

+#endif /* !CONFIG_EMBEDDED */

 
        if (req->newptr == USER_ADDR_NULL) {
                return EINVAL;
 
        if (req->newptr == USER_ADDR_NULL) {
                return EINVAL;


@@ -1596,7 +1826,7 @@ tcp_sysctl_info(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused
        if (error != 0) {
                return error;
        }
        if (error != 0) {
                return error;
        }

-       
+

        return 0;
 }
 
        return 0;
 }
 


@@ -1606,32 +1836,36 @@ tcp_lookup_peer_pid_locked(struct socket *so, pid_t *out_pid)
        int error = EHOSTUNREACH;
        *out_pid = -1;
        if ((so->so_state & SS_ISCONNECTED) == 0) return ENOTCONN;
        int error = EHOSTUNREACH;
        *out_pid = -1;
        if ((so->so_state & SS_ISCONNECTED) == 0) return ENOTCONN;

-       
+

        struct inpcb    *inp = (struct inpcb*)so->so_pcb;
        uint16_t                lport = inp->inp_lport;
        uint16_t                fport = inp->inp_fport;
        struct inpcb    *finp = NULL;
        struct inpcb    *inp = (struct inpcb*)so->so_pcb;
        uint16_t                lport = inp->inp_lport;
        uint16_t                fport = inp->inp_fport;
        struct inpcb    *finp = NULL;

-       
+       struct  in6_addr laddr6, faddr6;
+       struct in_addr laddr4, faddr4;
+
+       if (inp->inp_vflag & INP_IPV6) {
+               laddr6 = inp->in6p_laddr;
+               faddr6 = inp->in6p_faddr;
+       } else if (inp->inp_vflag & INP_IPV4) {
+               laddr4 = inp->inp_laddr;
+               faddr4 = inp->inp_faddr;
+       }
+
+       socket_unlock(so, 0);

        if (inp->inp_vflag & INP_IPV6) {
        if (inp->inp_vflag & INP_IPV6) {

-               struct  in6_addr        laddr6 = inp->in6p_laddr;
-               struct  in6_addr        faddr6 = inp->in6p_faddr;
-               socket_unlock(so, 0);

                finp = in6_pcblookup_hash(&tcbinfo, &laddr6, lport, &faddr6, fport, 0, NULL);
                finp = in6_pcblookup_hash(&tcbinfo, &laddr6, lport, &faddr6, fport, 0, NULL);

-               socket_lock(so, 0);

        } else if (inp->inp_vflag & INP_IPV4) {
        } else if (inp->inp_vflag & INP_IPV4) {

-               struct  in_addr laddr4 = inp->inp_laddr;
-               struct  in_addr faddr4 = inp->inp_faddr;
-               socket_unlock(so, 0);

                finp = in_pcblookup_hash(&tcbinfo, laddr4, lport, faddr4, fport, 0, NULL);
                finp = in_pcblookup_hash(&tcbinfo, laddr4, lport, faddr4, fport, 0, NULL);

-               socket_lock(so, 0);

        }
        }

-       
+

        if (finp) {
                *out_pid = finp->inp_socket->last_pid;
                error = 0;
                in_pcb_checkstate(finp, WNT_RELEASE, 0);
        }
        if (finp) {
                *out_pid = finp->inp_socket->last_pid;
                error = 0;
                in_pcb_checkstate(finp, WNT_RELEASE, 0);
        }

-       
+       socket_lock(so, 0);
+

        return error;
 }
 
        return error;
 }
 


@@ -1650,15 +1884,12 @@ tcp_getconninfo(struct socket *so, struct conninfo_tcp *tcp_ci)
  * splnet() any more.  This needs more examination.)
  */
 int
  * splnet() any more.  This needs more examination.)
  */
 int

-tcp_ctloutput(so, sopt)
-       struct socket *so;
-       struct sockopt *sopt;
+tcp_ctloutput(struct socket *so, struct sockopt *sopt)

 {
 {

-       int     error, opt, optval;
+       int     error = 0, opt = 0, optval = 0;

        struct  inpcb *inp;
        struct  tcpcb *tp;
 
        struct  inpcb *inp;
        struct  tcpcb *tp;
 

-       error = 0;

        inp = sotoinpcb(so);
        if (inp == NULL) {
                return (ECONNRESET);
        inp = sotoinpcb(so);
        if (inp == NULL) {
                return (ECONNRESET);


@@ -1714,11 +1945,22 @@ tcp_ctloutput(so, sopt)
                                tp->t_flags &= ~opt;
                        break;
                case TCP_RXT_FINDROP:
                                tp->t_flags &= ~opt;
                        break;
                case TCP_RXT_FINDROP:

+               case TCP_NOTIMEWAIT:

                        error = sooptcopyin(sopt, &optval, sizeof optval,
                                sizeof optval);
                        if (error)
                                break;
                        error = sooptcopyin(sopt, &optval, sizeof optval,
                                sizeof optval);
                        if (error)
                                break;

-                       opt = TF_RXTFINDROP;
+                       switch (sopt->sopt_name) {
+                       case TCP_RXT_FINDROP:
+                               opt = TF_RXTFINDROP;
+                               break;
+                       case TCP_NOTIMEWAIT:
+                               opt = TF_NOTIMEWAIT;
+                               break;
+                       default:
+                               opt = 0;
+                               break;
+                       }

                        if (optval)
                                tp->t_flagsext |= opt;
                        else
                        if (optval)
                                tp->t_flagsext |= opt;
                        else


@@ -1762,7 +2004,7 @@ tcp_ctloutput(so, sopt)
                                error = EINVAL;
                                break;
                        }
                                error = EINVAL;
                                break;
                        }

-                       minpkts = (in.min_burst_size != 0) ? in.min_burst_size : 
+                       minpkts = (in.min_burst_size != 0) ? in.min_burst_size :

                                tp->t_bwmeas->bw_minsizepkts;
                        maxpkts = (in.max_burst_size != 0) ? in.max_burst_size :
                                tp->t_bwmeas->bw_maxsizepkts;
                                tp->t_bwmeas->bw_minsizepkts;
                        maxpkts = (in.max_burst_size != 0) ? in.max_burst_size :
                                tp->t_bwmeas->bw_maxsizepkts;


@@ -1799,7 +2041,7 @@ tcp_ctloutput(so, sopt)
                        } else {
                                tp->t_keepidle = optval * TCP_RETRANSHZ;
                                /* reset the timer to new value */
                        } else {
                                tp->t_keepidle = optval * TCP_RETRANSHZ;
                                /* reset the timer to new value */

-                               tp->t_timer[TCPT_KEEP] = OFFSET_FROM_START(tp, 
+                               tp->t_timer[TCPT_KEEP] = OFFSET_FROM_START(tp,

                                        TCP_CONN_KEEPIDLE(tp));
                                tcp_check_timer_state(tp);
                        }
                                        TCP_CONN_KEEPIDLE(tp));
                                tcp_check_timer_state(tp);
                        }


@@ -1859,6 +2101,21 @@ tcp_ctloutput(so, sopt)
                        }
                        break;
 
                        }
                        break;
 

+               case TCP_KEEPALIVE_OFFLOAD:
+                       error = sooptcopyin(sopt, &optval, sizeof(optval),
+                               sizeof(optval));
+                       if (error)
+                               break;
+                       if (optval < 0 || optval > INT32_MAX) {
+                               error = EINVAL;
+                               break;
+                       }
+                       if (optval != 0)
+                               inp->inp_flags2 |= INP2_KEEPALIVE_OFFLOAD;
+                       else
+                               inp->inp_flags2 &= ~INP2_KEEPALIVE_OFFLOAD;
+                       break;
+

                case PERSIST_TIMEOUT:
                        error = sooptcopyin(sopt, &optval, sizeof optval,
                                                sizeof optval);
                case PERSIST_TIMEOUT:
                        error = sooptcopyin(sopt, &optval, sizeof optval,
                                                sizeof optval);


@@ -1866,7 +2123,7 @@ tcp_ctloutput(so, sopt)
                                break;
                        if (optval < 0)
                                error = EINVAL;
                                break;
                        if (optval < 0)
                                error = EINVAL;

-                       else 
+                       else

                                tp->t_persist_timeout = optval * TCP_RETRANSHZ;
                        break;
                case TCP_RXT_CONNDROPTIME:
                                tp->t_persist_timeout = optval * TCP_RETRANSHZ;
                        break;
                case TCP_RXT_CONNDROPTIME:


@@ -1891,7 +2148,7 @@ tcp_ctloutput(so, sopt)
                                if (optval == 0) {
                                        so->so_flags &= ~(SOF_NOTSENT_LOWAT);
                                        tp->t_notsent_lowat = 0;
                                if (optval == 0) {
                                        so->so_flags &= ~(SOF_NOTSENT_LOWAT);
                                        tp->t_notsent_lowat = 0;

-                               } else { 
+                               } else {

                                        so->so_flags |= SOF_NOTSENT_LOWAT;
                                        tp->t_notsent_lowat = optval;
                                }
                                        so->so_flags |= SOF_NOTSENT_LOWAT;
                                        tp->t_notsent_lowat = optval;
                                }


@@ -1899,27 +2156,30 @@ tcp_ctloutput(so, sopt)
                        break;
                case TCP_ADAPTIVE_READ_TIMEOUT:
                        error = sooptcopyin(sopt, &optval, sizeof (optval),
                        break;
                case TCP_ADAPTIVE_READ_TIMEOUT:
                        error = sooptcopyin(sopt, &optval, sizeof (optval),

-                               sizeof(optval));
+                           sizeof(optval));

                        if (error)
                                break;
                        if (error)
                                break;

-                       if (optval < 0 || 
-                               optval > TCP_ADAPTIVE_TIMEOUT_MAX) {
+                       if (optval < 0 ||
+                           optval > TCP_ADAPTIVE_TIMEOUT_MAX) {

                                error = EINVAL;
                                break;
                        } else if (optval == 0) {
                                tp->t_adaptive_rtimo = 0;
                                tcp_keepalive_reset(tp);
                                error = EINVAL;
                                break;
                        } else if (optval == 0) {
                                tp->t_adaptive_rtimo = 0;
                                tcp_keepalive_reset(tp);

+
+                               if (tp->t_mpsub)
+                                       mptcp_reset_keepalive(tp);

                        } else {
                                tp->t_adaptive_rtimo = optval;
                        }
                        break;
                case TCP_ADAPTIVE_WRITE_TIMEOUT:
                        error = sooptcopyin(sopt, &optval, sizeof (optval),
                        } else {
                                tp->t_adaptive_rtimo = optval;
                        }
                        break;
                case TCP_ADAPTIVE_WRITE_TIMEOUT:
                        error = sooptcopyin(sopt, &optval, sizeof (optval),

-                               sizeof (optval));
+                           sizeof (optval));

                        if (error)
                                break;
                        if (error)
                                break;

-                       if (optval < 0 || 
-                               optval > TCP_ADAPTIVE_TIMEOUT_MAX) {
+                       if (optval < 0 ||
+                           optval > TCP_ADAPTIVE_TIMEOUT_MAX) {

                                error = EINVAL;
                                break;
                        } else {
                                error = EINVAL;
                                break;
                        } else {


@@ -1944,13 +2204,13 @@ tcp_ctloutput(so, sopt)
                                }
 
                                /*
                                }
 
                                /*

-                                * allocate memory for storing message 
+                                * allocate memory for storing message

                                 * related state
                                 */
                                VERIFY(so->so_msg_state == NULL);
                                 * related state
                                 */
                                VERIFY(so->so_msg_state == NULL);

-                               MALLOC(so->so_msg_state, 
+                               MALLOC(so->so_msg_state,

                                        struct msg_state *,
                                        struct msg_state *,

-                                       sizeof(struct msg_state), 
+                                       sizeof(struct msg_state),

                                        M_TEMP, M_WAITOK | M_ZERO);
                                if (so->so_msg_state == NULL) {
                                        error = ENOMEM;
                                        M_TEMP, M_WAITOK | M_ZERO);
                                if (so->so_msg_state == NULL) {
                                        error = ENOMEM;


@@ -1960,9 +2220,9 @@ tcp_ctloutput(so, sopt)
                                /* Enable message delivery */
                                so->so_flags |= SOF_ENABLE_MSGS;
                        } else {
                                /* Enable message delivery */
                                so->so_flags |= SOF_ENABLE_MSGS;
                        } else {

-                               /* 
-                                * Can't disable message delivery on socket 
-                                * because of restrictions imposed by 
+                               /*
+                                * Can't disable message delivery on socket
+                                * because of restrictions imposed by

                                 * encoding/decoding
                                 */
                                error = EINVAL;
                                 * encoding/decoding
                                 */
                                error = EINVAL;


@@ -1981,6 +2241,121 @@ tcp_ctloutput(so, sopt)
                                tp->t_flagsext |= TF_NOSTRETCHACK;
                        }
                        break;
                                tp->t_flagsext |= TF_NOSTRETCHACK;
                        }
                        break;

+               case TCP_DISABLE_BLACKHOLE_DETECTION:
+                       error = sooptcopyin(sopt, &optval, sizeof(optval),
+                               sizeof(optval));
+                       if (error)
+                               break;
+                       if (optval < 0 || optval > 1) {
+                               error = EINVAL;
+                       } else if (optval == 0) {
+                               tp->t_flagsext &= ~TF_NOBLACKHOLE_DETECTION;
+                       } else {
+                               tp->t_flagsext |= TF_NOBLACKHOLE_DETECTION;
+                               if ((tp->t_flags & TF_BLACKHOLE) &&
+                                   tp->t_pmtud_saved_maxopd > 0)
+                                       tcp_pmtud_revert_segment_size(tp);
+                       }
+                       break;
+               case TCP_FASTOPEN:
+                       if (!(tcp_fastopen & TCP_FASTOPEN_SERVER)) {
+                               error = ENOTSUP;
+                               break;
+                       }
+
+                       error = sooptcopyin(sopt, &optval, sizeof(optval),
+                               sizeof(optval));
+                       if (error)
+                               break;
+                       if (optval < 0 || optval > 1) {
+                               error = EINVAL;
+                               break;
+                       }
+                       if (tp->t_state != TCPS_LISTEN) {
+                               error =  EINVAL;
+                               break;
+                       }
+                       if (optval)
+                               tp->t_flagsext |= TF_FASTOPEN;
+                       else
+                               tcp_disable_tfo(tp);
+                       break;
+               case TCP_FASTOPEN_FORCE_HEURISTICS:
+                       error = sooptcopyin(sopt, &optval, sizeof(optval),
+                               sizeof(optval));
+
+                       if (error)
+                               break;
+                       if (optval < 0 || optval > 1) {
+                               error = EINVAL;
+                               break;
+                       }
+
+                       if (tp->t_state != TCPS_CLOSED) {
+                               error =  EINVAL;
+                               break;
+                       }
+                       if (optval)
+                               tp->t_flagsext |= TF_FASTOPEN_HEUR;
+                       else
+                               tp->t_flagsext &= ~TF_FASTOPEN_HEUR;
+
+                       break;
+               case TCP_ENABLE_ECN:
+                       error = sooptcopyin(sopt, &optval, sizeof optval,
+                                           sizeof optval);
+                       if (error)
+                               break;
+                       if (optval) {
+                               tp->ecn_flags |= TE_ECN_MODE_ENABLE;
+                               tp->ecn_flags &= ~TE_ECN_MODE_DISABLE;
+                       } else {
+                               tp->ecn_flags &= ~TE_ECN_MODE_ENABLE;
+                               tp->ecn_flags |= TE_ECN_MODE_DISABLE;
+                       }
+                       break;
+               case TCP_ECN_MODE:
+                       error = sooptcopyin(sopt, &optval, sizeof optval,
+                                           sizeof optval);
+                       if (error)
+                               break;
+                       if (optval == ECN_MODE_DEFAULT) {
+                               tp->ecn_flags &= ~TE_ECN_MODE_ENABLE;
+                               tp->ecn_flags &= ~TE_ECN_MODE_DISABLE;
+                       } else if (optval == ECN_MODE_ENABLE) {
+                               tp->ecn_flags |= TE_ECN_MODE_ENABLE;
+                               tp->ecn_flags &= ~TE_ECN_MODE_DISABLE;
+                       } else if (optval == ECN_MODE_DISABLE) {
+                               tp->ecn_flags &= ~TE_ECN_MODE_ENABLE;
+                               tp->ecn_flags |= TE_ECN_MODE_DISABLE;
+                       } else {
+                               error = EINVAL;
+                       }
+                       break;
+               case TCP_NOTIFY_ACKNOWLEDGEMENT:
+                       error = sooptcopyin(sopt, &optval,
+                           sizeof(optval), sizeof(optval));
+                       if (error)
+                               break;
+                       if (optval <= 0) {
+                               error = EINVAL;
+                               break;
+                       }
+                       if (tp->t_notify_ack_count >= TCP_MAX_NOTIFY_ACK) {
+                               error = ETOOMANYREFS;
+                               break;
+                       }
+
+                       /*
+                        * validate that the given marker id is not
+                        * a duplicate to avoid ambiguity
+                        */
+                       if ((error = tcp_notify_ack_id_valid(tp, so,
+                           optval)) != 0) {
+                               break;
+                       }
+                       error = tcp_add_notify_ack_marker(tp, optval);
+                       break;

                case SO_FLUSH:
                        if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
                            sizeof (optval))) != 0)
                case SO_FLUSH:
                        if ((error = sooptcopyin(sopt, &optval, sizeof (optval),
                            sizeof (optval))) != 0)


@@ -2002,7 +2377,24 @@ tcp_ctloutput(so, sopt)
                                    TRAFFIC_MGT_SO_BACKGROUND);
                        }
                        break;
                                    TRAFFIC_MGT_SO_BACKGROUND);
                        }
                        break;

-
+               case TCP_RXT_MINIMUM_TIMEOUT:
+                       error = sooptcopyin(sopt, &optval, sizeof(optval),
+                           sizeof(optval));
+                       if (error)
+                               break;
+                       if (optval < 0) {
+                               error = EINVAL;
+                               break;
+                       }
+                       if (optval == 0) {
+                               tp->t_rxt_minimum_timeout = 0;
+                       } else {
+                               tp->t_rxt_minimum_timeout = min(optval,
+                                   TCP_RXT_MINIMUM_TIMEOUT_LIMIT);
+                               /* convert to milliseconds */
+                               tp->t_rxt_minimum_timeout *= TCP_RETRANSHZ;
+                       }
+                       break;

                default:
                        error = ENOPROTOOPT;
                        break;
                default:
                        error = ENOPROTOOPT;
                        break;


@@ -2018,13 +2410,25 @@ tcp_ctloutput(so, sopt)
                        optval = tp->t_maxseg;
                        break;
                case TCP_KEEPALIVE:
                        optval = tp->t_maxseg;
                        break;
                case TCP_KEEPALIVE:

-                       optval = tp->t_keepidle / TCP_RETRANSHZ;
+                       if (tp->t_keepidle > 0)
+                               optval = tp->t_keepidle / TCP_RETRANSHZ;
+                       else
+                               optval = tcp_keepidle  / TCP_RETRANSHZ;

                        break;
                case TCP_KEEPINTVL:
                        break;
                case TCP_KEEPINTVL:

-                       optval = tp->t_keepintvl / TCP_RETRANSHZ;
+                       if (tp->t_keepintvl > 0)
+                               optval = tp->t_keepintvl / TCP_RETRANSHZ;
+                       else
+                               optval = tcp_keepintvl / TCP_RETRANSHZ;

                        break;
                case TCP_KEEPCNT:
                        break;
                case TCP_KEEPCNT:

-                       optval = tp->t_keepcnt;
+                       if (tp->t_keepcnt > 0)
+                               optval = tp->t_keepcnt;
+                       else
+                               optval = tcp_keepcnt;
+                       break;
+               case TCP_KEEPALIVE_OFFLOAD:
+                       optval = !!(inp->inp_flags2 & INP2_KEEPALIVE_OFFLOAD);

                        break;
                case TCP_NOOPT:
                        optval = tp->t_flags & TF_NOOPT;
                        break;
                case TCP_NOOPT:
                        optval = tp->t_flags & TF_NOOPT;


@@ -2032,6 +2436,17 @@ tcp_ctloutput(so, sopt)
                case TCP_NOPUSH:
                        optval = tp->t_flags & TF_NOPUSH;
                        break;
                case TCP_NOPUSH:
                        optval = tp->t_flags & TF_NOPUSH;
                        break;

+               case TCP_ENABLE_ECN:
+                       optval = (tp->ecn_flags & TE_ECN_MODE_ENABLE) ? 1 : 0;
+                       break;
+               case TCP_ECN_MODE:
+                       if (tp->ecn_flags & TE_ECN_MODE_ENABLE)
+                               optval = ECN_MODE_ENABLE;
+                       else if (tp->ecn_flags & TE_ECN_MODE_DISABLE)
+                               optval = ECN_MODE_DISABLE;
+                       else
+                               optval = ECN_MODE_DEFAULT;
+                       break;

                case TCP_CONNECTIONTIMEOUT:
                        optval = tp->t_keepinit / TCP_RETRANSHZ;
                        break;
                case TCP_CONNECTIONTIMEOUT:
                        optval = tp->t_keepinit / TCP_RETRANSHZ;
                        break;


@@ -2043,7 +2458,21 @@ tcp_ctloutput(so, sopt)
                        break;
                case TCP_RXT_FINDROP:
                        optval = tp->t_flagsext & TF_RXTFINDROP;
                        break;
                case TCP_RXT_FINDROP:
                        optval = tp->t_flagsext & TF_RXTFINDROP;

-                       break; 
+                       break;
+               case TCP_NOTIMEWAIT:
+                       optval = (tp->t_flagsext & TF_NOTIMEWAIT) ? 1 : 0;
+                       break;
+               case TCP_FASTOPEN:
+                       if (tp->t_state != TCPS_LISTEN ||
+                           !(tcp_fastopen & TCP_FASTOPEN_SERVER)) {
+                               error = ENOTSUP;
+                               break;
+                       }
+                       optval = tfo_enabled(tp);
+                       break;
+               case TCP_FASTOPEN_FORCE_HEURISTICS:
+                       optval = (tp->t_flagsext & TF_FASTOPEN_HEUR) ? 1 : 0;
+                       break;

                case TCP_MEASURE_SND_BW:
                        optval = tp->t_flagsext & TF_MEASURESNDBW;
                        break;
                case TCP_MEASURE_SND_BW:
                        optval = tp->t_flagsext & TF_MEASURESNDBW;
                        break;


@@ -2055,8 +2484,15 @@ tcp_ctloutput(so, sopt)
                        goto done;
                        /* NOT REACHED */
                }
                        goto done;
                        /* NOT REACHED */
                }

+               case TCP_CONNECTION_INFO: {
+                       struct tcp_connection_info tci;
+                       tcp_connection_fill_info(tp, &tci);
+                       error = sooptcopyout(sopt, &tci,
+                           sizeof(struct tcp_connection_info));
+                       goto done;
+               }

                case TCP_MEASURE_BW_BURST: {
                case TCP_MEASURE_BW_BURST: {

-                       struct tcp_measure_bw_burst out;
+                       struct tcp_measure_bw_burst out = {};

                        if ((tp->t_flagsext & TF_MEASURESNDBW) == 0 ||
                                tp->t_bwmeas == NULL) {
                                error = EINVAL;
                        if ((tp->t_flagsext & TF_MEASURESNDBW) == 0 ||
                                tp->t_bwmeas == NULL) {
                                error = EINVAL;


@@ -2088,6 +2524,12 @@ tcp_ctloutput(so, sopt)
                        else
                                optval = 0;
                        break;
                        else
                                optval = 0;
                        break;

+               case TCP_DISABLE_BLACKHOLE_DETECTION:
+                       if (tp->t_flagsext & TF_NOBLACKHOLE_DETECTION)
+                               optval = 1;
+                       else
+                               optval = 0;
+                       break;

                case TCP_PEER_PID: {
                        pid_t   pid;
                        error = tcp_lookup_peer_pid_locked(so, &pid);
                case TCP_PEER_PID: {
                        pid_t   pid;
                        error = tcp_lookup_peer_pid_locked(so, &pid);


@@ -2102,8 +2544,26 @@ tcp_ctloutput(so, sopt)
                        optval = tp->t_adaptive_wtimo;
                        break;
                case SO_TRAFFIC_MGT_BACKGROUND:
                        optval = tp->t_adaptive_wtimo;
                        break;
                case SO_TRAFFIC_MGT_BACKGROUND:

-                       optval = (so->so_traffic_mgt_flags &
-                           TRAFFIC_MGT_SO_BACKGROUND) ? 1 : 0;
+                       optval = (so->so_flags1 &
+                           SOF1_TRAFFIC_MGT_SO_BACKGROUND) ? 1 : 0;
+                       break;
+               case TCP_NOTIFY_ACKNOWLEDGEMENT: {
+                       struct tcp_notify_ack_complete retid;
+
+                       if (sopt->sopt_valsize != sizeof (retid)) {
+                               error = EINVAL;
+                               break;
+                       }
+                       bzero(&retid, sizeof (retid));
+                       tcp_get_notify_ack_count(tp, &retid);
+                       if (retid.notify_complete_count > 0)
+                               tcp_get_notify_ack_ids(tp, &retid);
+
+                       error = sooptcopyout(sopt, &retid, sizeof (retid));
+                       goto done;
+               }
+               case TCP_RXT_MINIMUM_TIMEOUT:
+                       optval = tp->t_rxt_minimum_timeout / TCP_RETRANSHZ;

                        break;
                default:
                        error = ENOPROTOOPT;
                        break;
                default:
                        error = ENOPROTOOPT;


@@ -2129,10 +2589,12 @@ u_int32_t       tcp_recvspace = 1448*384;
  * sb_max in sbreserve. Disallow setting the tcp send and recv space
  * to be more than sb_max because that will cause tcp_attach to fail
  * (see radar 5713060)
  * sb_max in sbreserve. Disallow setting the tcp send and recv space
  * to be more than sb_max because that will cause tcp_attach to fail
  * (see radar 5713060)

- */  
+ */

 static int
 sysctl_tcp_sospace(struct sysctl_oid *oidp, __unused void *arg1,
 static int
 sysctl_tcp_sospace(struct sysctl_oid *oidp, __unused void *arg1,

-       __unused int arg2, struct sysctl_req *req) {
+       int arg2, struct sysctl_req *req)
+{
+#pragma unused(arg2)

        u_int32_t new_value = 0, *space_p = NULL;
        int changed = 0, error = 0;
        u_quad_t sb_effective_max = (sb_max / (MSIZE+MCLBYTES)) * MCLBYTES;
        u_int32_t new_value = 0, *space_p = NULL;
        int changed = 0, error = 0;
        u_quad_t sb_effective_max = (sb_max / (MSIZE+MCLBYTES)) * MCLBYTES;


@@ -2152,6 +2614,7 @@ sysctl_tcp_sospace(struct sysctl_oid *oidp, __unused void *arg1,
        if (changed) {
                if (new_value > 0 && new_value <= sb_effective_max) {
                        *space_p = new_value;
        if (changed) {
                if (new_value > 0 && new_value <= sb_effective_max) {
                        *space_p = new_value;

+                       SYSCTL_SKMEM_UPDATE_AT_OFFSET(arg2, new_value);

                } else {
                        error = ERANGE;
                }
                } else {
                        error = ERANGE;
                }


@@ -2159,11 +2622,21 @@ sysctl_tcp_sospace(struct sysctl_oid *oidp, __unused void *arg1,
        return error;
 }
 
        return error;
 }
 

+#if SYSCTL_SKMEM
+SYSCTL_PROC(_net_inet_tcp, TCPCTL_SENDSPACE, sendspace,
+                       CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_sendspace,
+                       offsetof(skmem_sysctl, tcp.sendspace), sysctl_tcp_sospace,
+                       "IU", "Maximum outgoing TCP datagram size");
+SYSCTL_PROC(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace,
+                       CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED, &tcp_recvspace,
+                       offsetof(skmem_sysctl, tcp.recvspace), sysctl_tcp_sospace,
+                       "IU", "Maximum incoming TCP datagram size");
+#else /* SYSCTL_SKMEM */

 SYSCTL_PROC(_net_inet_tcp, TCPCTL_SENDSPACE, sendspace, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
     &tcp_sendspace , 0, &sysctl_tcp_sospace, "IU", "Maximum outgoing TCP datagram size");
 SYSCTL_PROC(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
     &tcp_recvspace , 0, &sysctl_tcp_sospace, "IU", "Maximum incoming TCP datagram size");
 SYSCTL_PROC(_net_inet_tcp, TCPCTL_SENDSPACE, sendspace, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
     &tcp_sendspace , 0, &sysctl_tcp_sospace, "IU", "Maximum outgoing TCP datagram size");
 SYSCTL_PROC(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
     &tcp_recvspace , 0, &sysctl_tcp_sospace, "IU", "Maximum incoming TCP datagram size");

-
+#endif /* SYSCTL_SKMEM */

 
 /*
  * Attach TCP protocol to socket, allocating
 
 /*
  * Attach TCP protocol to socket, allocating


@@ -2177,11 +2650,9 @@ SYSCTL_PROC(_net_inet_tcp, TCPCTL_RECVSPACE, recvspace, CTLTYPE_INT | CTLFLAG_RW
  *     soreserve:ENOBUFS
  */
 static int
  *     soreserve:ENOBUFS
  */
 static int

-tcp_attach(so, p)
-       struct socket *so;
-       struct proc *p;
+tcp_attach(struct socket *so, struct proc *p)

 {
 {

-       register struct tcpcb *tp;
+       struct tcpcb *tp;

        struct inpcb *inp;
        int error;
 #if INET6
        struct inpcb *inp;
        int error;
 #if INET6


@@ -2199,6 +2670,11 @@ tcp_attach(so, p)
                if (error)
                        return (error);
        }
                if (error)
                        return (error);
        }

+
+       if (so->so_snd.sb_preconn_hiwat == 0) {
+               soreserve_preconnect(so, 2048);
+       }
+

        if ((so->so_rcv.sb_flags & SB_USRSIZE) == 0)
                so->so_rcv.sb_flags |= SB_AUTOSIZE;
        if ((so->so_snd.sb_flags & SB_USRSIZE) == 0)
        if ((so->so_rcv.sb_flags & SB_USRSIZE) == 0)
                so->so_rcv.sb_flags |= SB_AUTOSIZE;
        if ((so->so_snd.sb_flags & SB_USRSIZE) == 0)


@@ -2226,9 +2702,8 @@ tcp_attach(so, p)
                so->so_state |= nofd;
                return (ENOBUFS);
        }
                so->so_state |= nofd;
                return (ENOBUFS);
        }

-       if (nstat_collect) {
+       if (nstat_collect)

                nstat_tcp_new_pcb(inp);
                nstat_tcp_new_pcb(inp);

-       }

        tp->t_state = TCPS_CLOSED;
        return (0);
 }
        tp->t_state = TCPS_CLOSED;
        return (0);
 }


@@ -2242,11 +2717,13 @@ tcp_attach(so, p)
  * send segment to peer (with FIN).
  */
 static struct tcpcb *
  * send segment to peer (with FIN).
  */
 static struct tcpcb *

-tcp_disconnect(tp)
-       register struct tcpcb *tp;
+tcp_disconnect(struct tcpcb *tp)

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

+       if (so->so_rcv.sb_cc != 0 || tp->t_reassqlen != 0)
+               return tcp_drop(tp, 0);
+

        if (tp->t_state < TCPS_ESTABLISHED)
                tp = tcp_close(tp);
        else if ((so->so_options & SO_LINGER) && so->so_linger == 0)
        if (tp->t_state < TCPS_ESTABLISHED)
                tp = tcp_close(tp);
        else if ((so->so_options & SO_LINGER) && so->so_linger == 0)


@@ -2278,34 +2755,32 @@ tcp_disconnect(tp)
  * We can let the user exit from the close as soon as the FIN is acked.
  */
 static struct tcpcb *
  * We can let the user exit from the close as soon as the FIN is acked.
  */
 static struct tcpcb *

-tcp_usrclosed(tp)
-       register struct tcpcb *tp;
+tcp_usrclosed(struct tcpcb *tp)

 {
 {

-

        switch (tp->t_state) {
 
        case TCPS_CLOSED:
        case TCPS_LISTEN:
        switch (tp->t_state) {
 
        case TCPS_CLOSED:
        case TCPS_LISTEN:

+       case TCPS_SYN_SENT:

                tp = tcp_close(tp);
                break;
 
                tp = tcp_close(tp);
                break;
 

-       case TCPS_SYN_SENT:

        case TCPS_SYN_RECEIVED:
                tp->t_flags |= TF_NEEDFIN;
                break;
 
        case TCPS_ESTABLISHED:
        case TCPS_SYN_RECEIVED:
                tp->t_flags |= TF_NEEDFIN;
                break;
 
        case TCPS_ESTABLISHED:

-               DTRACE_TCP4(state__change, void, NULL, 
+               DTRACE_TCP4(state__change, void, NULL,

                        struct inpcb *, tp->t_inpcb,
                        struct inpcb *, tp->t_inpcb,

-                       struct tcpcb *, tp, 
+                       struct tcpcb *, tp,

                        int32_t, TCPS_FIN_WAIT_1);
                tp->t_state = TCPS_FIN_WAIT_1;
                break;
 
        case TCPS_CLOSE_WAIT:
                        int32_t, TCPS_FIN_WAIT_1);
                tp->t_state = TCPS_FIN_WAIT_1;
                break;
 
        case TCPS_CLOSE_WAIT:

-               DTRACE_TCP4(state__change, void, NULL, 
+               DTRACE_TCP4(state__change, void, NULL,

                        struct inpcb *, tp->t_inpcb,
                        struct inpcb *, tp->t_inpcb,

-                       struct tcpcb *, tp, 
+                       struct tcpcb *, tp,

                        int32_t, TCPS_LAST_ACK);
                tp->t_state = TCPS_LAST_ACK;
                break;
                        int32_t, TCPS_LAST_ACK);
                tp->t_state = TCPS_LAST_ACK;
                break;


@@ -2314,7 +2789,7 @@ tcp_usrclosed(tp)
                soisdisconnected(tp->t_inpcb->inp_socket);
                /* To prevent the connection hanging in FIN_WAIT_2 forever. */
                if (tp->t_state == TCPS_FIN_WAIT_2)
                soisdisconnected(tp->t_inpcb->inp_socket);
                /* To prevent the connection hanging in FIN_WAIT_2 forever. */
                if (tp->t_state == TCPS_FIN_WAIT_2)

-                       tp->t_timer[TCPT_2MSL] = OFFSET_FROM_START(tp, 
+                       tp->t_timer[TCPT_2MSL] = OFFSET_FROM_START(tp,

                                TCP_CONN_MAXIDLE(tp));
        }
        return (tp);
                                TCP_CONN_MAXIDLE(tp));
        }
        return (tp);


@@ -2349,12 +2824,12 @@ tcp_out6_cksum_stats(u_int32_t len)
        tcpstat.tcps_snd6_swcsum_bytes += len;
 }
 
        tcpstat.tcps_snd6_swcsum_bytes += len;
 }
 

-/* 
+/*

  * When messages are enabled on a TCP socket, the message priority
  * is sent as a control message. This function will extract it.
  */
 int
  * When messages are enabled on a TCP socket, the message priority
  * is sent as a control message. This function will extract it.
  */
 int

-tcp_get_msg_priority(struct mbuf *control, uint32_t *msgpri) 
+tcp_get_msg_priority(struct mbuf *control, uint32_t *msgpri)

 {
        struct cmsghdr *cm;
        if (control == NULL)
 {
        struct cmsghdr *cm;
        if (control == NULL)


@@ -2373,7 +2848,7 @@ tcp_get_msg_priority(struct mbuf *control, uint32_t *msgpri)
                }
        }
 
                }
        }
 

-       VERIFY(*msgpri >= MSG_PRI_MIN && *msgpri <= MSG_PRI_MAX); 
+       VERIFY(*msgpri >= MSG_PRI_MIN && *msgpri <= MSG_PRI_MAX);

        return (0);
 }
 #endif /* INET6 */
        return (0);
 }
 #endif /* INET6 */