The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet/tcp_usrreq.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1988, 1993
    3  *      The Regents of the University of California.
    4  * Copyright (c) 2006-2007 Robert N. M. Watson
    5  * Copyright (c) 2010-2011 Juniper Networks, Inc.
    6  * All rights reserved.
    7  *
    8  * Portions of this software were developed by Robert N. M. Watson under
    9  * contract to Juniper Networks, Inc.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 4. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      From: @(#)tcp_usrreq.c  8.2 (Berkeley) 1/3/94
   36  */
   37 
   38 #include <sys/cdefs.h>
   39 __FBSDID("$FreeBSD: releng/11.1/sys/netinet/tcp_usrreq.c 338980 2018-09-27 18:34:42Z gordon $");
   40 
   41 #include "opt_ddb.h"
   42 #include "opt_inet.h"
   43 #include "opt_inet6.h"
   44 #include "opt_ipsec.h"
   45 #include "opt_tcpdebug.h"
   46 
   47 #include <sys/param.h>
   48 #include <sys/systm.h>
   49 #include <sys/limits.h>
   50 #include <sys/malloc.h>
   51 #include <sys/refcount.h>
   52 #include <sys/kernel.h>
   53 #include <sys/sysctl.h>
   54 #include <sys/mbuf.h>
   55 #ifdef INET6
   56 #include <sys/domain.h>
   57 #endif /* INET6 */
   58 #include <sys/socket.h>
   59 #include <sys/socketvar.h>
   60 #include <sys/protosw.h>
   61 #include <sys/proc.h>
   62 #include <sys/jail.h>
   63 #include <sys/syslog.h>
   64 
   65 #ifdef DDB
   66 #include <ddb/ddb.h>
   67 #endif
   68 
   69 #include <net/if.h>
   70 #include <net/if_var.h>
   71 #include <net/route.h>
   72 #include <net/vnet.h>
   73 
   74 #include <netinet/in.h>
   75 #include <netinet/in_kdtrace.h>
   76 #include <netinet/in_pcb.h>
   77 #include <netinet/in_systm.h>
   78 #include <netinet/in_var.h>
   79 #include <netinet/ip_var.h>
   80 #ifdef INET6
   81 #include <netinet/ip6.h>
   82 #include <netinet6/in6_pcb.h>
   83 #include <netinet6/ip6_var.h>
   84 #include <netinet6/scope6_var.h>
   85 #endif
   86 #ifdef TCP_RFC7413
   87 #include <netinet/tcp_fastopen.h>
   88 #endif
   89 #include <netinet/tcp.h>
   90 #include <netinet/tcp_fsm.h>
   91 #include <netinet/tcp_seq.h>
   92 #include <netinet/tcp_timer.h>
   93 #include <netinet/tcp_var.h>
   94 #include <netinet/tcpip.h>
   95 #include <netinet/cc/cc.h>
   96 #ifdef TCPPCAP
   97 #include <netinet/tcp_pcap.h>
   98 #endif
   99 #ifdef TCPDEBUG
  100 #include <netinet/tcp_debug.h>
  101 #endif
  102 #ifdef TCP_OFFLOAD
  103 #include <netinet/tcp_offload.h>
  104 #endif
  105 #include <netipsec/ipsec_support.h>
  106 
  107 /*
  108  * TCP protocol interface to socket abstraction.
  109  */
  110 static int      tcp_attach(struct socket *);
  111 #ifdef INET
  112 static int      tcp_connect(struct tcpcb *, struct sockaddr *,
  113                     struct thread *td);
  114 #endif /* INET */
  115 #ifdef INET6
  116 static int      tcp6_connect(struct tcpcb *, struct sockaddr *,
  117                     struct thread *td);
  118 #endif /* INET6 */
  119 static void     tcp_disconnect(struct tcpcb *);
  120 static void     tcp_usrclosed(struct tcpcb *);
  121 static void     tcp_fill_info(struct tcpcb *, struct tcp_info *);
  122 
  123 #ifdef TCPDEBUG
  124 #define TCPDEBUG0       int ostate = 0
  125 #define TCPDEBUG1()     ostate = tp ? tp->t_state : 0
  126 #define TCPDEBUG2(req)  if (tp && (so->so_options & SO_DEBUG)) \
  127                                 tcp_trace(TA_USER, ostate, tp, 0, 0, req)
  128 #else
  129 #define TCPDEBUG0
  130 #define TCPDEBUG1()
  131 #define TCPDEBUG2(req)
  132 #endif
  133 
  134 /*
  135  * TCP attaches to socket via pru_attach(), reserving space,
  136  * and an internet control block.
  137  */
  138 static int
  139 tcp_usr_attach(struct socket *so, int proto, struct thread *td)
  140 {
  141         struct inpcb *inp;
  142         struct tcpcb *tp = NULL;
  143         int error;
  144         TCPDEBUG0;
  145 
  146         inp = sotoinpcb(so);
  147         KASSERT(inp == NULL, ("tcp_usr_attach: inp != NULL"));
  148         TCPDEBUG1();
  149 
  150         error = tcp_attach(so);
  151         if (error)
  152                 goto out;
  153 
  154         if ((so->so_options & SO_LINGER) && so->so_linger == 0)
  155                 so->so_linger = TCP_LINGERTIME;
  156 
  157         inp = sotoinpcb(so);
  158         tp = intotcpcb(inp);
  159 out:
  160         TCPDEBUG2(PRU_ATTACH);
  161         TCP_PROBE2(debug__user, tp, PRU_ATTACH);
  162         return error;
  163 }
  164 
  165 /*
  166  * tcp_detach is called when the socket layer loses its final reference
  167  * to the socket, be it a file descriptor reference, a reference from TCP,
  168  * etc.  At this point, there is only one case in which we will keep around
  169  * inpcb state: time wait.
  170  *
  171  * This function can probably be re-absorbed back into tcp_usr_detach() now
  172  * that there is a single detach path.
  173  */
  174 static void
  175 tcp_detach(struct socket *so, struct inpcb *inp)
  176 {
  177         struct tcpcb *tp;
  178 
  179         INP_INFO_LOCK_ASSERT(&V_tcbinfo);
  180         INP_WLOCK_ASSERT(inp);
  181 
  182         KASSERT(so->so_pcb == inp, ("tcp_detach: so_pcb != inp"));
  183         KASSERT(inp->inp_socket == so, ("tcp_detach: inp_socket != so"));
  184 
  185         tp = intotcpcb(inp);
  186 
  187         if (inp->inp_flags & INP_TIMEWAIT) {
  188                 /*
  189                  * There are two cases to handle: one in which the time wait
  190                  * state is being discarded (INP_DROPPED), and one in which
  191                  * this connection will remain in timewait.  In the former,
  192                  * it is time to discard all state (except tcptw, which has
  193                  * already been discarded by the timewait close code, which
  194                  * should be further up the call stack somewhere).  In the
  195                  * latter case, we detach from the socket, but leave the pcb
  196                  * present until timewait ends.
  197                  *
  198                  * XXXRW: Would it be cleaner to free the tcptw here?
  199                  *
  200                  * Astute question indeed, from twtcp perspective there are
  201                  * three cases to consider:
  202                  *
  203                  * #1 tcp_detach is called at tcptw creation time by
  204                  *  tcp_twstart, then do not discard the newly created tcptw
  205                  *  and leave inpcb present until timewait ends
  206                  * #2 tcp_detach is called at timewait end (or reuse) by
  207                  *  tcp_twclose, then the tcptw has already been discarded
  208                  *  (or reused) and inpcb is freed here
  209                  * #3 tcp_detach is called() after timewait ends (or reuse)
  210                  *  (e.g. by soclose), then tcptw has already been discarded
  211                  *  (or reused) and inpcb is freed here
  212                  *
  213                  *  In all three cases the tcptw should not be freed here.
  214                  */
  215                 if (inp->inp_flags & INP_DROPPED) {
  216                         in_pcbdetach(inp);
  217                         if (__predict_true(tp == NULL)) {
  218                                 in_pcbfree(inp);
  219                         } else {
  220                                 /*
  221                                  * This case should not happen as in TIMEWAIT
  222                                  * state the inp should not be destroyed before
  223                                  * its tcptw.  If INVARIANTS is defined, panic.
  224                                  */
  225 #ifdef INVARIANTS
  226                                 panic("%s: Panic before an inp double-free: "
  227                                     "INP_TIMEWAIT && INP_DROPPED && tp != NULL"
  228                                     , __func__);
  229 #else
  230                                 log(LOG_ERR, "%s: Avoid an inp double-free: "
  231                                     "INP_TIMEWAIT && INP_DROPPED && tp != NULL"
  232                                     , __func__);
  233 #endif
  234                                 INP_WUNLOCK(inp);
  235                         }
  236                 } else {
  237                         in_pcbdetach(inp);
  238                         INP_WUNLOCK(inp);
  239                 }
  240         } else {
  241                 /*
  242                  * If the connection is not in timewait, we consider two
  243                  * two conditions: one in which no further processing is
  244                  * necessary (dropped || embryonic), and one in which TCP is
  245                  * not yet done, but no longer requires the socket, so the
  246                  * pcb will persist for the time being.
  247                  *
  248                  * XXXRW: Does the second case still occur?
  249                  */
  250                 if (inp->inp_flags & INP_DROPPED ||
  251                     tp->t_state < TCPS_SYN_SENT) {
  252                         tcp_discardcb(tp);
  253                         in_pcbdetach(inp);
  254                         in_pcbfree(inp);
  255                 } else {
  256                         in_pcbdetach(inp);
  257                         INP_WUNLOCK(inp);
  258                 }
  259         }
  260 }
  261 
  262 /*
  263  * pru_detach() detaches the TCP protocol from the socket.
  264  * If the protocol state is non-embryonic, then can't
  265  * do this directly: have to initiate a pru_disconnect(),
  266  * which may finish later; embryonic TCB's can just
  267  * be discarded here.
  268  */
  269 static void
  270 tcp_usr_detach(struct socket *so)
  271 {
  272         struct inpcb *inp;
  273         int rlock = 0;
  274 
  275         inp = sotoinpcb(so);
  276         KASSERT(inp != NULL, ("tcp_usr_detach: inp == NULL"));
  277         if (!INP_INFO_WLOCKED(&V_tcbinfo)) {
  278                 INP_INFO_RLOCK(&V_tcbinfo);
  279                 rlock = 1;
  280         }
  281         INP_WLOCK(inp);
  282         KASSERT(inp->inp_socket != NULL,
  283             ("tcp_usr_detach: inp_socket == NULL"));
  284         tcp_detach(so, inp);
  285         if (rlock)
  286                 INP_INFO_RUNLOCK(&V_tcbinfo);
  287 }
  288 
  289 #ifdef INET
  290 /*
  291  * Give the socket an address.
  292  */
  293 static int
  294 tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
  295 {
  296         int error = 0;
  297         struct inpcb *inp;
  298         struct tcpcb *tp = NULL;
  299         struct sockaddr_in *sinp;
  300 
  301         sinp = (struct sockaddr_in *)nam;
  302         if (nam->sa_len != sizeof (*sinp))
  303                 return (EINVAL);
  304         /*
  305          * Must check for multicast addresses and disallow binding
  306          * to them.
  307          */
  308         if (sinp->sin_family == AF_INET &&
  309             IN_MULTICAST(ntohl(sinp->sin_addr.s_addr)))
  310                 return (EAFNOSUPPORT);
  311 
  312         TCPDEBUG0;
  313         inp = sotoinpcb(so);
  314         KASSERT(inp != NULL, ("tcp_usr_bind: inp == NULL"));
  315         INP_WLOCK(inp);
  316         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  317                 error = EINVAL;
  318                 goto out;
  319         }
  320         tp = intotcpcb(inp);
  321         TCPDEBUG1();
  322         INP_HASH_WLOCK(&V_tcbinfo);
  323         error = in_pcbbind(inp, nam, td->td_ucred);
  324         INP_HASH_WUNLOCK(&V_tcbinfo);
  325 out:
  326         TCPDEBUG2(PRU_BIND);
  327         TCP_PROBE2(debug__user, tp, PRU_BIND);
  328         INP_WUNLOCK(inp);
  329 
  330         return (error);
  331 }
  332 #endif /* INET */
  333 
  334 #ifdef INET6
  335 static int
  336 tcp6_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
  337 {
  338         int error = 0;
  339         struct inpcb *inp;
  340         struct tcpcb *tp = NULL;
  341         struct sockaddr_in6 *sin6p;
  342         u_char vflagsav;
  343 
  344         sin6p = (struct sockaddr_in6 *)nam;
  345         if (nam->sa_len != sizeof (*sin6p))
  346                 return (EINVAL);
  347         /*
  348          * Must check for multicast addresses and disallow binding
  349          * to them.
  350          */
  351         if (sin6p->sin6_family == AF_INET6 &&
  352             IN6_IS_ADDR_MULTICAST(&sin6p->sin6_addr))
  353                 return (EAFNOSUPPORT);
  354 
  355         TCPDEBUG0;
  356         inp = sotoinpcb(so);
  357         KASSERT(inp != NULL, ("tcp6_usr_bind: inp == NULL"));
  358         INP_WLOCK(inp);
  359         vflagsav = inp->inp_vflag;
  360         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  361                 error = EINVAL;
  362                 goto out;
  363         }
  364         tp = intotcpcb(inp);
  365         TCPDEBUG1();
  366         INP_HASH_WLOCK(&V_tcbinfo);
  367         inp->inp_vflag &= ~INP_IPV4;
  368         inp->inp_vflag |= INP_IPV6;
  369 #ifdef INET
  370         if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) {
  371                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6p->sin6_addr))
  372                         inp->inp_vflag |= INP_IPV4;
  373                 else if (IN6_IS_ADDR_V4MAPPED(&sin6p->sin6_addr)) {
  374                         struct sockaddr_in sin;
  375 
  376                         in6_sin6_2_sin(&sin, sin6p);
  377                         inp->inp_vflag |= INP_IPV4;
  378                         inp->inp_vflag &= ~INP_IPV6;
  379                         error = in_pcbbind(inp, (struct sockaddr *)&sin,
  380                             td->td_ucred);
  381                         INP_HASH_WUNLOCK(&V_tcbinfo);
  382                         goto out;
  383                 }
  384         }
  385 #endif
  386         error = in6_pcbbind(inp, nam, td->td_ucred);
  387         INP_HASH_WUNLOCK(&V_tcbinfo);
  388 out:
  389         if (error != 0)
  390                 inp->inp_vflag = vflagsav;
  391         TCPDEBUG2(PRU_BIND);
  392         TCP_PROBE2(debug__user, tp, PRU_BIND);
  393         INP_WUNLOCK(inp);
  394         return (error);
  395 }
  396 #endif /* INET6 */
  397 
  398 #ifdef INET
  399 /*
  400  * Prepare to accept connections.
  401  */
  402 static int
  403 tcp_usr_listen(struct socket *so, int backlog, struct thread *td)
  404 {
  405         int error = 0;
  406         struct inpcb *inp;
  407         struct tcpcb *tp = NULL;
  408 
  409         TCPDEBUG0;
  410         inp = sotoinpcb(so);
  411         KASSERT(inp != NULL, ("tcp_usr_listen: inp == NULL"));
  412         INP_WLOCK(inp);
  413         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  414                 error = EINVAL;
  415                 goto out;
  416         }
  417         tp = intotcpcb(inp);
  418         TCPDEBUG1();
  419         SOCK_LOCK(so);
  420         error = solisten_proto_check(so);
  421         INP_HASH_WLOCK(&V_tcbinfo);
  422         if (error == 0 && inp->inp_lport == 0)
  423                 error = in_pcbbind(inp, (struct sockaddr *)0, td->td_ucred);
  424         INP_HASH_WUNLOCK(&V_tcbinfo);
  425         if (error == 0) {
  426                 tcp_state_change(tp, TCPS_LISTEN);
  427                 solisten_proto(so, backlog);
  428 #ifdef TCP_OFFLOAD
  429                 if ((so->so_options & SO_NO_OFFLOAD) == 0)
  430                         tcp_offload_listen_start(tp);
  431 #endif
  432         }
  433         SOCK_UNLOCK(so);
  434 
  435 #ifdef TCP_RFC7413
  436         if (tp->t_flags & TF_FASTOPEN)
  437                 tp->t_tfo_pending = tcp_fastopen_alloc_counter();
  438 #endif
  439 out:
  440         TCPDEBUG2(PRU_LISTEN);
  441         TCP_PROBE2(debug__user, tp, PRU_LISTEN);
  442         INP_WUNLOCK(inp);
  443         return (error);
  444 }
  445 #endif /* INET */
  446 
  447 #ifdef INET6
  448 static int
  449 tcp6_usr_listen(struct socket *so, int backlog, struct thread *td)
  450 {
  451         int error = 0;
  452         struct inpcb *inp;
  453         struct tcpcb *tp = NULL;
  454         u_char vflagsav;
  455 
  456         TCPDEBUG0;
  457         inp = sotoinpcb(so);
  458         KASSERT(inp != NULL, ("tcp6_usr_listen: inp == NULL"));
  459         INP_WLOCK(inp);
  460         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  461                 error = EINVAL;
  462                 goto out;
  463         }
  464         vflagsav = inp->inp_vflag;
  465         tp = intotcpcb(inp);
  466         TCPDEBUG1();
  467         SOCK_LOCK(so);
  468         error = solisten_proto_check(so);
  469         INP_HASH_WLOCK(&V_tcbinfo);
  470         if (error == 0 && inp->inp_lport == 0) {
  471                 inp->inp_vflag &= ~INP_IPV4;
  472                 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0)
  473                         inp->inp_vflag |= INP_IPV4;
  474                 error = in6_pcbbind(inp, (struct sockaddr *)0, td->td_ucred);
  475         }
  476         INP_HASH_WUNLOCK(&V_tcbinfo);
  477         if (error == 0) {
  478                 tcp_state_change(tp, TCPS_LISTEN);
  479                 solisten_proto(so, backlog);
  480 #ifdef TCP_OFFLOAD
  481                 if ((so->so_options & SO_NO_OFFLOAD) == 0)
  482                         tcp_offload_listen_start(tp);
  483 #endif
  484         }
  485         SOCK_UNLOCK(so);
  486 
  487 #ifdef TCP_RFC7413
  488         if (tp->t_flags & TF_FASTOPEN)
  489                 tp->t_tfo_pending = tcp_fastopen_alloc_counter();
  490 #endif
  491         if (error != 0)
  492                 inp->inp_vflag = vflagsav;
  493 
  494 out:
  495         TCPDEBUG2(PRU_LISTEN);
  496         TCP_PROBE2(debug__user, tp, PRU_LISTEN);
  497         INP_WUNLOCK(inp);
  498         return (error);
  499 }
  500 #endif /* INET6 */
  501 
  502 #ifdef INET
  503 /*
  504  * Initiate connection to peer.
  505  * Create a template for use in transmissions on this connection.
  506  * Enter SYN_SENT state, and mark socket as connecting.
  507  * Start keep-alive timer, and seed output sequence space.
  508  * Send initial segment on connection.
  509  */
  510 static int
  511 tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
  512 {
  513         int error = 0;
  514         struct inpcb *inp;
  515         struct tcpcb *tp = NULL;
  516         struct sockaddr_in *sinp;
  517 
  518         sinp = (struct sockaddr_in *)nam;
  519         if (nam->sa_len != sizeof (*sinp))
  520                 return (EINVAL);
  521         /*
  522          * Must disallow TCP ``connections'' to multicast addresses.
  523          */
  524         if (sinp->sin_family == AF_INET
  525             && IN_MULTICAST(ntohl(sinp->sin_addr.s_addr)))
  526                 return (EAFNOSUPPORT);
  527         if ((error = prison_remote_ip4(td->td_ucred, &sinp->sin_addr)) != 0)
  528                 return (error);
  529 
  530         TCPDEBUG0;
  531         inp = sotoinpcb(so);
  532         KASSERT(inp != NULL, ("tcp_usr_connect: inp == NULL"));
  533         INP_WLOCK(inp);
  534         if (inp->inp_flags & INP_TIMEWAIT) {
  535                 error = EADDRINUSE;
  536                 goto out;
  537         }
  538         if (inp->inp_flags & INP_DROPPED) {
  539                 error = ECONNREFUSED;
  540                 goto out;
  541         }
  542         tp = intotcpcb(inp);
  543         TCPDEBUG1();
  544         if ((error = tcp_connect(tp, nam, td)) != 0)
  545                 goto out;
  546 #ifdef TCP_OFFLOAD
  547         if (registered_toedevs > 0 &&
  548             (so->so_options & SO_NO_OFFLOAD) == 0 &&
  549             (error = tcp_offload_connect(so, nam)) == 0)
  550                 goto out;
  551 #endif
  552         tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
  553         error = tp->t_fb->tfb_tcp_output(tp);
  554 out:
  555         TCPDEBUG2(PRU_CONNECT);
  556         TCP_PROBE2(debug__user, tp, PRU_CONNECT);
  557         INP_WUNLOCK(inp);
  558         return (error);
  559 }
  560 #endif /* INET */
  561 
  562 #ifdef INET6
  563 static int
  564 tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
  565 {
  566         int error = 0;
  567         struct inpcb *inp;
  568         struct tcpcb *tp = NULL;
  569         struct sockaddr_in6 *sin6p;
  570         u_int8_t incflagsav;
  571         u_char vflagsav;
  572 
  573         TCPDEBUG0;
  574 
  575         sin6p = (struct sockaddr_in6 *)nam;
  576         if (nam->sa_len != sizeof (*sin6p))
  577                 return (EINVAL);
  578         /*
  579          * Must disallow TCP ``connections'' to multicast addresses.
  580          */
  581         if (sin6p->sin6_family == AF_INET6
  582             && IN6_IS_ADDR_MULTICAST(&sin6p->sin6_addr))
  583                 return (EAFNOSUPPORT);
  584 
  585         inp = sotoinpcb(so);
  586         KASSERT(inp != NULL, ("tcp6_usr_connect: inp == NULL"));
  587         INP_WLOCK(inp);
  588         vflagsav = inp->inp_vflag;
  589         incflagsav = inp->inp_inc.inc_flags;
  590         if (inp->inp_flags & INP_TIMEWAIT) {
  591                 error = EADDRINUSE;
  592                 goto out;
  593         }
  594         if (inp->inp_flags & INP_DROPPED) {
  595                 error = ECONNREFUSED;
  596                 goto out;
  597         }
  598         tp = intotcpcb(inp);
  599         TCPDEBUG1();
  600 #ifdef INET
  601         /*
  602          * XXXRW: Some confusion: V4/V6 flags relate to binding, and
  603          * therefore probably require the hash lock, which isn't held here.
  604          * Is this a significant problem?
  605          */
  606         if (IN6_IS_ADDR_V4MAPPED(&sin6p->sin6_addr)) {
  607                 struct sockaddr_in sin;
  608 
  609                 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0) {
  610                         error = EINVAL;
  611                         goto out;
  612                 }
  613                 if ((inp->inp_vflag & INP_IPV4) == 0) {
  614                         error = EAFNOSUPPORT;
  615                         goto out;
  616                 }
  617 
  618                 in6_sin6_2_sin(&sin, sin6p);
  619                 if ((error = prison_remote_ip4(td->td_ucred,
  620                     &sin.sin_addr)) != 0)
  621                         goto out;
  622                 inp->inp_vflag |= INP_IPV4;
  623                 inp->inp_vflag &= ~INP_IPV6;
  624                 if ((error = tcp_connect(tp, (struct sockaddr *)&sin, td)) != 0)
  625                         goto out;
  626 #ifdef TCP_OFFLOAD
  627                 if (registered_toedevs > 0 &&
  628                     (so->so_options & SO_NO_OFFLOAD) == 0 &&
  629                     (error = tcp_offload_connect(so, nam)) == 0)
  630                         goto out;
  631 #endif
  632                 error = tp->t_fb->tfb_tcp_output(tp);
  633                 goto out;
  634         } else {
  635                 if ((inp->inp_vflag & INP_IPV6) == 0) {
  636                         error = EAFNOSUPPORT;
  637                         goto out;
  638                 }
  639         }
  640 #endif
  641         if ((error = prison_remote_ip6(td->td_ucred, &sin6p->sin6_addr)) != 0)
  642                 goto out;
  643         inp->inp_vflag &= ~INP_IPV4;
  644         inp->inp_vflag |= INP_IPV6;
  645         inp->inp_inc.inc_flags |= INC_ISIPV6;
  646         if ((error = tcp6_connect(tp, nam, td)) != 0)
  647                 goto out;
  648 #ifdef TCP_OFFLOAD
  649         if (registered_toedevs > 0 &&
  650             (so->so_options & SO_NO_OFFLOAD) == 0 &&
  651             (error = tcp_offload_connect(so, nam)) == 0)
  652                 goto out;
  653 #endif
  654         tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
  655         error = tp->t_fb->tfb_tcp_output(tp);
  656 
  657 out:
  658         /*
  659          * If the implicit bind in the connect call fails, restore
  660          * the flags we modified.
  661          */
  662         if (error != 0 && inp->inp_lport == 0) {
  663                 inp->inp_vflag = vflagsav;
  664                 inp->inp_inc.inc_flags = incflagsav;
  665         }
  666 
  667         TCPDEBUG2(PRU_CONNECT);
  668         TCP_PROBE2(debug__user, tp, PRU_CONNECT);
  669         INP_WUNLOCK(inp);
  670         return (error);
  671 }
  672 #endif /* INET6 */
  673 
  674 /*
  675  * Initiate disconnect from peer.
  676  * If connection never passed embryonic stage, just drop;
  677  * else if don't need to let data drain, then can just drop anyways,
  678  * else have to begin TCP shutdown process: mark socket disconnecting,
  679  * drain unread data, state switch to reflect user close, and
  680  * send segment (e.g. FIN) to peer.  Socket will be really disconnected
  681  * when peer sends FIN and acks ours.
  682  *
  683  * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
  684  */
  685 static int
  686 tcp_usr_disconnect(struct socket *so)
  687 {
  688         struct inpcb *inp;
  689         struct tcpcb *tp = NULL;
  690         int error = 0;
  691 
  692         TCPDEBUG0;
  693         INP_INFO_RLOCK(&V_tcbinfo);
  694         inp = sotoinpcb(so);
  695         KASSERT(inp != NULL, ("tcp_usr_disconnect: inp == NULL"));
  696         INP_WLOCK(inp);
  697         if (inp->inp_flags & INP_TIMEWAIT)
  698                 goto out;
  699         if (inp->inp_flags & INP_DROPPED) {
  700                 error = ECONNRESET;
  701                 goto out;
  702         }
  703         tp = intotcpcb(inp);
  704         TCPDEBUG1();
  705         tcp_disconnect(tp);
  706 out:
  707         TCPDEBUG2(PRU_DISCONNECT);
  708         TCP_PROBE2(debug__user, tp, PRU_DISCONNECT);
  709         INP_WUNLOCK(inp);
  710         INP_INFO_RUNLOCK(&V_tcbinfo);
  711         return (error);
  712 }
  713 
  714 #ifdef INET
  715 /*
  716  * Accept a connection.  Essentially all the work is done at higher levels;
  717  * just return the address of the peer, storing through addr.
  718  */
  719 static int
  720 tcp_usr_accept(struct socket *so, struct sockaddr **nam)
  721 {
  722         int error = 0;
  723         struct inpcb *inp = NULL;
  724         struct tcpcb *tp = NULL;
  725         struct in_addr addr;
  726         in_port_t port = 0;
  727         TCPDEBUG0;
  728 
  729         if (so->so_state & SS_ISDISCONNECTED)
  730                 return (ECONNABORTED);
  731 
  732         inp = sotoinpcb(so);
  733         KASSERT(inp != NULL, ("tcp_usr_accept: inp == NULL"));
  734         INP_WLOCK(inp);
  735         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  736                 error = ECONNABORTED;
  737                 goto out;
  738         }
  739         tp = intotcpcb(inp);
  740         TCPDEBUG1();
  741 
  742         /*
  743          * We inline in_getpeeraddr and COMMON_END here, so that we can
  744          * copy the data of interest and defer the malloc until after we
  745          * release the lock.
  746          */
  747         port = inp->inp_fport;
  748         addr = inp->inp_faddr;
  749 
  750 out:
  751         TCPDEBUG2(PRU_ACCEPT);
  752         TCP_PROBE2(debug__user, tp, PRU_ACCEPT);
  753         INP_WUNLOCK(inp);
  754         if (error == 0)
  755                 *nam = in_sockaddr(port, &addr);
  756         return error;
  757 }
  758 #endif /* INET */
  759 
  760 #ifdef INET6
  761 static int
  762 tcp6_usr_accept(struct socket *so, struct sockaddr **nam)
  763 {
  764         struct inpcb *inp = NULL;
  765         int error = 0;
  766         struct tcpcb *tp = NULL;
  767         struct in_addr addr;
  768         struct in6_addr addr6;
  769         in_port_t port = 0;
  770         int v4 = 0;
  771         TCPDEBUG0;
  772 
  773         if (so->so_state & SS_ISDISCONNECTED)
  774                 return (ECONNABORTED);
  775 
  776         inp = sotoinpcb(so);
  777         KASSERT(inp != NULL, ("tcp6_usr_accept: inp == NULL"));
  778         INP_INFO_RLOCK(&V_tcbinfo);
  779         INP_WLOCK(inp);
  780         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  781                 error = ECONNABORTED;
  782                 goto out;
  783         }
  784         tp = intotcpcb(inp);
  785         TCPDEBUG1();
  786 
  787         /*
  788          * We inline in6_mapped_peeraddr and COMMON_END here, so that we can
  789          * copy the data of interest and defer the malloc until after we
  790          * release the lock.
  791          */
  792         if (inp->inp_vflag & INP_IPV4) {
  793                 v4 = 1;
  794                 port = inp->inp_fport;
  795                 addr = inp->inp_faddr;
  796         } else {
  797                 port = inp->inp_fport;
  798                 addr6 = inp->in6p_faddr;
  799         }
  800 
  801 out:
  802         TCPDEBUG2(PRU_ACCEPT);
  803         TCP_PROBE2(debug__user, tp, PRU_ACCEPT);
  804         INP_WUNLOCK(inp);
  805         INP_INFO_RUNLOCK(&V_tcbinfo);
  806         if (error == 0) {
  807                 if (v4)
  808                         *nam = in6_v4mapsin6_sockaddr(port, &addr);
  809                 else
  810                         *nam = in6_sockaddr(port, &addr6);
  811         }
  812         return error;
  813 }
  814 #endif /* INET6 */
  815 
  816 /*
  817  * Mark the connection as being incapable of further output.
  818  */
  819 static int
  820 tcp_usr_shutdown(struct socket *so)
  821 {
  822         int error = 0;
  823         struct inpcb *inp;
  824         struct tcpcb *tp = NULL;
  825 
  826         TCPDEBUG0;
  827         INP_INFO_RLOCK(&V_tcbinfo);
  828         inp = sotoinpcb(so);
  829         KASSERT(inp != NULL, ("inp == NULL"));
  830         INP_WLOCK(inp);
  831         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  832                 error = ECONNRESET;
  833                 goto out;
  834         }
  835         tp = intotcpcb(inp);
  836         TCPDEBUG1();
  837         socantsendmore(so);
  838         tcp_usrclosed(tp);
  839         if (!(inp->inp_flags & INP_DROPPED))
  840                 error = tp->t_fb->tfb_tcp_output(tp);
  841 
  842 out:
  843         TCPDEBUG2(PRU_SHUTDOWN);
  844         TCP_PROBE2(debug__user, tp, PRU_SHUTDOWN);
  845         INP_WUNLOCK(inp);
  846         INP_INFO_RUNLOCK(&V_tcbinfo);
  847 
  848         return (error);
  849 }
  850 
  851 /*
  852  * After a receive, possibly send window update to peer.
  853  */
  854 static int
  855 tcp_usr_rcvd(struct socket *so, int flags)
  856 {
  857         struct inpcb *inp;
  858         struct tcpcb *tp = NULL;
  859         int error = 0;
  860 
  861         TCPDEBUG0;
  862         inp = sotoinpcb(so);
  863         KASSERT(inp != NULL, ("tcp_usr_rcvd: inp == NULL"));
  864         INP_WLOCK(inp);
  865         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  866                 error = ECONNRESET;
  867                 goto out;
  868         }
  869         tp = intotcpcb(inp);
  870         TCPDEBUG1();
  871 #ifdef TCP_RFC7413
  872         /*
  873          * For passively-created TFO connections, don't attempt a window
  874          * update while still in SYN_RECEIVED as this may trigger an early
  875          * SYN|ACK.  It is preferable to have the SYN|ACK be sent along with
  876          * application response data, or failing that, when the DELACK timer
  877          * expires.
  878          */
  879         if ((tp->t_flags & TF_FASTOPEN) &&
  880             (tp->t_state == TCPS_SYN_RECEIVED))
  881                 goto out;
  882 #endif
  883 #ifdef TCP_OFFLOAD
  884         if (tp->t_flags & TF_TOE)
  885                 tcp_offload_rcvd(tp);
  886         else
  887 #endif
  888         tp->t_fb->tfb_tcp_output(tp);
  889 
  890 out:
  891         TCPDEBUG2(PRU_RCVD);
  892         TCP_PROBE2(debug__user, tp, PRU_RCVD);
  893         INP_WUNLOCK(inp);
  894         return (error);
  895 }
  896 
  897 /*
  898  * Do a send by putting data in output queue and updating urgent
  899  * marker if URG set.  Possibly send more data.  Unlike the other
  900  * pru_*() routines, the mbuf chains are our responsibility.  We
  901  * must either enqueue them or free them.  The other pru_* routines
  902  * generally are caller-frees.
  903  */
  904 static int
  905 tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
  906     struct sockaddr *nam, struct mbuf *control, struct thread *td)
  907 {
  908         int error = 0;
  909         struct inpcb *inp;
  910         struct tcpcb *tp = NULL;
  911 #ifdef INET6
  912         int isipv6;
  913 #endif
  914         TCPDEBUG0;
  915 
  916         /*
  917          * We require the pcbinfo lock if we will close the socket as part of
  918          * this call.
  919          */
  920         if (flags & PRUS_EOF)
  921                 INP_INFO_RLOCK(&V_tcbinfo);
  922         inp = sotoinpcb(so);
  923         KASSERT(inp != NULL, ("tcp_usr_send: inp == NULL"));
  924         INP_WLOCK(inp);
  925         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
  926                 if (control)
  927                         m_freem(control);
  928                 /*
  929                  * In case of PRUS_NOTREADY, tcp_usr_ready() is responsible
  930                  * for freeing memory.
  931                  */
  932                 if (m && (flags & PRUS_NOTREADY) == 0)
  933                         m_freem(m);
  934                 error = ECONNRESET;
  935                 goto out;
  936         }
  937 #ifdef INET6
  938         isipv6 = nam && nam->sa_family == AF_INET6;
  939 #endif /* INET6 */
  940         tp = intotcpcb(inp);
  941         TCPDEBUG1();
  942         if (control) {
  943                 /* TCP doesn't do control messages (rights, creds, etc) */
  944                 if (control->m_len) {
  945                         m_freem(control);
  946                         if (m)
  947                                 m_freem(m);
  948                         error = EINVAL;
  949                         goto out;
  950                 }
  951                 m_freem(control);       /* empty control, just free it */
  952         }
  953         if (!(flags & PRUS_OOB)) {
  954                 sbappendstream(&so->so_snd, m, flags);
  955                 if (nam && tp->t_state < TCPS_SYN_SENT) {
  956                         /*
  957                          * Do implied connect if not yet connected,
  958                          * initialize window to default value, and
  959                          * initialize maxseg using peer's cached MSS.
  960                          */
  961 #ifdef INET6
  962                         if (isipv6)
  963                                 error = tcp6_connect(tp, nam, td);
  964 #endif /* INET6 */
  965 #if defined(INET6) && defined(INET)
  966                         else
  967 #endif
  968 #ifdef INET
  969                                 error = tcp_connect(tp, nam, td);
  970 #endif
  971                         if (error)
  972                                 goto out;
  973                         tp->snd_wnd = TTCP_CLIENT_SND_WND;
  974                         tcp_mss(tp, -1);
  975                 }
  976                 if (flags & PRUS_EOF) {
  977                         /*
  978                          * Close the send side of the connection after
  979                          * the data is sent.
  980                          */
  981                         INP_INFO_RLOCK_ASSERT(&V_tcbinfo);
  982                         socantsendmore(so);
  983                         tcp_usrclosed(tp);
  984                 }
  985                 if (!(inp->inp_flags & INP_DROPPED) &&
  986                     !(flags & PRUS_NOTREADY)) {
  987                         if (flags & PRUS_MORETOCOME)
  988                                 tp->t_flags |= TF_MORETOCOME;
  989                         error = tp->t_fb->tfb_tcp_output(tp);
  990                         if (flags & PRUS_MORETOCOME)
  991                                 tp->t_flags &= ~TF_MORETOCOME;
  992                 }
  993         } else {
  994                 /*
  995                  * XXXRW: PRUS_EOF not implemented with PRUS_OOB?
  996                  */
  997                 SOCKBUF_LOCK(&so->so_snd);
  998                 if (sbspace(&so->so_snd) < -512) {
  999                         SOCKBUF_UNLOCK(&so->so_snd);
 1000                         m_freem(m);
 1001                         error = ENOBUFS;
 1002                         goto out;
 1003                 }
 1004                 /*
 1005                  * According to RFC961 (Assigned Protocols),
 1006                  * the urgent pointer points to the last octet
 1007                  * of urgent data.  We continue, however,
 1008                  * to consider it to indicate the first octet
 1009                  * of data past the urgent section.
 1010                  * Otherwise, snd_up should be one lower.
 1011                  */
 1012                 sbappendstream_locked(&so->so_snd, m, flags);
 1013                 SOCKBUF_UNLOCK(&so->so_snd);
 1014                 if (nam && tp->t_state < TCPS_SYN_SENT) {
 1015                         /*
 1016                          * Do implied connect if not yet connected,
 1017                          * initialize window to default value, and
 1018                          * initialize maxseg using peer's cached MSS.
 1019                          */
 1020 #ifdef INET6
 1021                         if (isipv6)
 1022                                 error = tcp6_connect(tp, nam, td);
 1023 #endif /* INET6 */
 1024 #if defined(INET6) && defined(INET)
 1025                         else
 1026 #endif
 1027 #ifdef INET
 1028                                 error = tcp_connect(tp, nam, td);
 1029 #endif
 1030                         if (error)
 1031                                 goto out;
 1032                         tp->snd_wnd = TTCP_CLIENT_SND_WND;
 1033                         tcp_mss(tp, -1);
 1034                 }
 1035                 tp->snd_up = tp->snd_una + sbavail(&so->so_snd);
 1036                 if (!(flags & PRUS_NOTREADY)) {
 1037                         tp->t_flags |= TF_FORCEDATA;
 1038                         error = tp->t_fb->tfb_tcp_output(tp);
 1039                         tp->t_flags &= ~TF_FORCEDATA;
 1040                 }
 1041         }
 1042 out:
 1043         TCPDEBUG2((flags & PRUS_OOB) ? PRU_SENDOOB :
 1044                   ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
 1045         TCP_PROBE2(debug__user, tp, (flags & PRUS_OOB) ? PRU_SENDOOB :
 1046                    ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
 1047         INP_WUNLOCK(inp);
 1048         if (flags & PRUS_EOF)
 1049                 INP_INFO_RUNLOCK(&V_tcbinfo);
 1050         return (error);
 1051 }
 1052 
 1053 static int
 1054 tcp_usr_ready(struct socket *so, struct mbuf *m, int count)
 1055 {
 1056         struct inpcb *inp;
 1057         struct tcpcb *tp;
 1058         int error;
 1059 
 1060         inp = sotoinpcb(so);
 1061         INP_WLOCK(inp);
 1062         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
 1063                 INP_WUNLOCK(inp);
 1064                 for (int i = 0; i < count; i++)
 1065                         m = m_free(m);
 1066                 return (ECONNRESET);
 1067         }
 1068         tp = intotcpcb(inp);
 1069 
 1070         SOCKBUF_LOCK(&so->so_snd);
 1071         error = sbready(&so->so_snd, m, count);
 1072         SOCKBUF_UNLOCK(&so->so_snd);
 1073         if (error == 0)
 1074                 error = tp->t_fb->tfb_tcp_output(tp);
 1075         INP_WUNLOCK(inp);
 1076 
 1077         return (error);
 1078 }
 1079 
 1080 /*
 1081  * Abort the TCP.  Drop the connection abruptly.
 1082  */
 1083 static void
 1084 tcp_usr_abort(struct socket *so)
 1085 {
 1086         struct inpcb *inp;
 1087         struct tcpcb *tp = NULL;
 1088         TCPDEBUG0;
 1089 
 1090         inp = sotoinpcb(so);
 1091         KASSERT(inp != NULL, ("tcp_usr_abort: inp == NULL"));
 1092 
 1093         INP_INFO_RLOCK(&V_tcbinfo);
 1094         INP_WLOCK(inp);
 1095         KASSERT(inp->inp_socket != NULL,
 1096             ("tcp_usr_abort: inp_socket == NULL"));
 1097 
 1098         /*
 1099          * If we still have full TCP state, and we're not dropped, drop.
 1100          */
 1101         if (!(inp->inp_flags & INP_TIMEWAIT) &&
 1102             !(inp->inp_flags & INP_DROPPED)) {
 1103                 tp = intotcpcb(inp);
 1104                 TCPDEBUG1();
 1105                 tcp_drop(tp, ECONNABORTED);
 1106                 TCPDEBUG2(PRU_ABORT);
 1107                 TCP_PROBE2(debug__user, tp, PRU_ABORT);
 1108         }
 1109         if (!(inp->inp_flags & INP_DROPPED)) {
 1110                 SOCK_LOCK(so);
 1111                 so->so_state |= SS_PROTOREF;
 1112                 SOCK_UNLOCK(so);
 1113                 inp->inp_flags |= INP_SOCKREF;
 1114         }
 1115         INP_WUNLOCK(inp);
 1116         INP_INFO_RUNLOCK(&V_tcbinfo);
 1117 }
 1118 
 1119 /*
 1120  * TCP socket is closed.  Start friendly disconnect.
 1121  */
 1122 static void
 1123 tcp_usr_close(struct socket *so)
 1124 {
 1125         struct inpcb *inp;
 1126         struct tcpcb *tp = NULL;
 1127         TCPDEBUG0;
 1128 
 1129         inp = sotoinpcb(so);
 1130         KASSERT(inp != NULL, ("tcp_usr_close: inp == NULL"));
 1131 
 1132         INP_INFO_RLOCK(&V_tcbinfo);
 1133         INP_WLOCK(inp);
 1134         KASSERT(inp->inp_socket != NULL,
 1135             ("tcp_usr_close: inp_socket == NULL"));
 1136 
 1137         /*
 1138          * If we still have full TCP state, and we're not dropped, initiate
 1139          * a disconnect.
 1140          */
 1141         if (!(inp->inp_flags & INP_TIMEWAIT) &&
 1142             !(inp->inp_flags & INP_DROPPED)) {
 1143                 tp = intotcpcb(inp);
 1144                 TCPDEBUG1();
 1145                 tcp_disconnect(tp);
 1146                 TCPDEBUG2(PRU_CLOSE);
 1147                 TCP_PROBE2(debug__user, tp, PRU_CLOSE);
 1148         }
 1149         if (!(inp->inp_flags & INP_DROPPED)) {
 1150                 SOCK_LOCK(so);
 1151                 so->so_state |= SS_PROTOREF;
 1152                 SOCK_UNLOCK(so);
 1153                 inp->inp_flags |= INP_SOCKREF;
 1154         }
 1155         INP_WUNLOCK(inp);
 1156         INP_INFO_RUNLOCK(&V_tcbinfo);
 1157 }
 1158 
 1159 /*
 1160  * Receive out-of-band data.
 1161  */
 1162 static int
 1163 tcp_usr_rcvoob(struct socket *so, struct mbuf *m, int flags)
 1164 {
 1165         int error = 0;
 1166         struct inpcb *inp;
 1167         struct tcpcb *tp = NULL;
 1168 
 1169         TCPDEBUG0;
 1170         inp = sotoinpcb(so);
 1171         KASSERT(inp != NULL, ("tcp_usr_rcvoob: inp == NULL"));
 1172         INP_WLOCK(inp);
 1173         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
 1174                 error = ECONNRESET;
 1175                 goto out;
 1176         }
 1177         tp = intotcpcb(inp);
 1178         TCPDEBUG1();
 1179         if ((so->so_oobmark == 0 &&
 1180              (so->so_rcv.sb_state & SBS_RCVATMARK) == 0) ||
 1181             so->so_options & SO_OOBINLINE ||
 1182             tp->t_oobflags & TCPOOB_HADDATA) {
 1183                 error = EINVAL;
 1184                 goto out;
 1185         }
 1186         if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
 1187                 error = EWOULDBLOCK;
 1188                 goto out;
 1189         }
 1190         m->m_len = 1;
 1191         *mtod(m, caddr_t) = tp->t_iobc;
 1192         if ((flags & MSG_PEEK) == 0)
 1193                 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
 1194 
 1195 out:
 1196         TCPDEBUG2(PRU_RCVOOB);
 1197         TCP_PROBE2(debug__user, tp, PRU_RCVOOB);
 1198         INP_WUNLOCK(inp);
 1199         return (error);
 1200 }
 1201 
 1202 #ifdef INET
 1203 struct pr_usrreqs tcp_usrreqs = {
 1204         .pru_abort =            tcp_usr_abort,
 1205         .pru_accept =           tcp_usr_accept,
 1206         .pru_attach =           tcp_usr_attach,
 1207         .pru_bind =             tcp_usr_bind,
 1208         .pru_connect =          tcp_usr_connect,
 1209         .pru_control =          in_control,
 1210         .pru_detach =           tcp_usr_detach,
 1211         .pru_disconnect =       tcp_usr_disconnect,
 1212         .pru_listen =           tcp_usr_listen,
 1213         .pru_peeraddr =         in_getpeeraddr,
 1214         .pru_rcvd =             tcp_usr_rcvd,
 1215         .pru_rcvoob =           tcp_usr_rcvoob,
 1216         .pru_send =             tcp_usr_send,
 1217         .pru_ready =            tcp_usr_ready,
 1218         .pru_shutdown =         tcp_usr_shutdown,
 1219         .pru_sockaddr =         in_getsockaddr,
 1220         .pru_sosetlabel =       in_pcbsosetlabel,
 1221         .pru_close =            tcp_usr_close,
 1222 };
 1223 #endif /* INET */
 1224 
 1225 #ifdef INET6
 1226 struct pr_usrreqs tcp6_usrreqs = {
 1227         .pru_abort =            tcp_usr_abort,
 1228         .pru_accept =           tcp6_usr_accept,
 1229         .pru_attach =           tcp_usr_attach,
 1230         .pru_bind =             tcp6_usr_bind,
 1231         .pru_connect =          tcp6_usr_connect,
 1232         .pru_control =          in6_control,
 1233         .pru_detach =           tcp_usr_detach,
 1234         .pru_disconnect =       tcp_usr_disconnect,
 1235         .pru_listen =           tcp6_usr_listen,
 1236         .pru_peeraddr =         in6_mapped_peeraddr,
 1237         .pru_rcvd =             tcp_usr_rcvd,
 1238         .pru_rcvoob =           tcp_usr_rcvoob,
 1239         .pru_send =             tcp_usr_send,
 1240         .pru_ready =            tcp_usr_ready,
 1241         .pru_shutdown =         tcp_usr_shutdown,
 1242         .pru_sockaddr =         in6_mapped_sockaddr,
 1243         .pru_sosetlabel =       in_pcbsosetlabel,
 1244         .pru_close =            tcp_usr_close,
 1245 };
 1246 #endif /* INET6 */
 1247 
 1248 #ifdef INET
 1249 /*
 1250  * Common subroutine to open a TCP connection to remote host specified
 1251  * by struct sockaddr_in in mbuf *nam.  Call in_pcbbind to assign a local
 1252  * port number if needed.  Call in_pcbconnect_setup to do the routing and
 1253  * to choose a local host address (interface).  If there is an existing
 1254  * incarnation of the same connection in TIME-WAIT state and if the remote
 1255  * host was sending CC options and if the connection duration was < MSL, then
 1256  * truncate the previous TIME-WAIT state and proceed.
 1257  * Initialize connection parameters and enter SYN-SENT state.
 1258  */
 1259 static int
 1260 tcp_connect(struct tcpcb *tp, struct sockaddr *nam, struct thread *td)
 1261 {
 1262         struct inpcb *inp = tp->t_inpcb, *oinp;
 1263         struct socket *so = inp->inp_socket;
 1264         struct in_addr laddr;
 1265         u_short lport;
 1266         int error;
 1267 
 1268         INP_WLOCK_ASSERT(inp);
 1269         INP_HASH_WLOCK(&V_tcbinfo);
 1270 
 1271         if (inp->inp_lport == 0) {
 1272                 error = in_pcbbind(inp, (struct sockaddr *)0, td->td_ucred);
 1273                 if (error)
 1274                         goto out;
 1275         }
 1276 
 1277         /*
 1278          * Cannot simply call in_pcbconnect, because there might be an
 1279          * earlier incarnation of this same connection still in
 1280          * TIME_WAIT state, creating an ADDRINUSE error.
 1281          */
 1282         laddr = inp->inp_laddr;
 1283         lport = inp->inp_lport;
 1284         error = in_pcbconnect_setup(inp, nam, &laddr.s_addr, &lport,
 1285             &inp->inp_faddr.s_addr, &inp->inp_fport, &oinp, td->td_ucred);
 1286         if (error && oinp == NULL)
 1287                 goto out;
 1288         if (oinp) {
 1289                 error = EADDRINUSE;
 1290                 goto out;
 1291         }
 1292         inp->inp_laddr = laddr;
 1293         in_pcbrehash(inp);
 1294         INP_HASH_WUNLOCK(&V_tcbinfo);
 1295 
 1296         /*
 1297          * Compute window scaling to request:
 1298          * Scale to fit into sweet spot.  See tcp_syncache.c.
 1299          * XXX: This should move to tcp_output().
 1300          */
 1301         while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
 1302             (TCP_MAXWIN << tp->request_r_scale) < sb_max)
 1303                 tp->request_r_scale++;
 1304 
 1305         soisconnecting(so);
 1306         TCPSTAT_INC(tcps_connattempt);
 1307         tcp_state_change(tp, TCPS_SYN_SENT);
 1308         tp->iss = tcp_new_isn(tp);
 1309         tcp_sendseqinit(tp);
 1310 
 1311         return 0;
 1312 
 1313 out:
 1314         INP_HASH_WUNLOCK(&V_tcbinfo);
 1315         return (error);
 1316 }
 1317 #endif /* INET */
 1318 
 1319 #ifdef INET6
 1320 static int
 1321 tcp6_connect(struct tcpcb *tp, struct sockaddr *nam, struct thread *td)
 1322 {
 1323         struct inpcb *inp = tp->t_inpcb;
 1324         int error;
 1325 
 1326         INP_WLOCK_ASSERT(inp);
 1327         INP_HASH_WLOCK(&V_tcbinfo);
 1328 
 1329         if (inp->inp_lport == 0) {
 1330                 error = in6_pcbbind(inp, (struct sockaddr *)0, td->td_ucred);
 1331                 if (error)
 1332                         goto out;
 1333         }
 1334         error = in6_pcbconnect(inp, nam, td->td_ucred);
 1335         if (error != 0)
 1336                 goto out;
 1337         INP_HASH_WUNLOCK(&V_tcbinfo);
 1338 
 1339         /* Compute window scaling to request.  */
 1340         while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
 1341             (TCP_MAXWIN << tp->request_r_scale) < sb_max)
 1342                 tp->request_r_scale++;
 1343 
 1344         soisconnecting(inp->inp_socket);
 1345         TCPSTAT_INC(tcps_connattempt);
 1346         tcp_state_change(tp, TCPS_SYN_SENT);
 1347         tp->iss = tcp_new_isn(tp);
 1348         tcp_sendseqinit(tp);
 1349 
 1350         return 0;
 1351 
 1352 out:
 1353         INP_HASH_WUNLOCK(&V_tcbinfo);
 1354         return error;
 1355 }
 1356 #endif /* INET6 */
 1357 
 1358 /*
 1359  * Export TCP internal state information via a struct tcp_info, based on the
 1360  * Linux 2.6 API.  Not ABI compatible as our constants are mapped differently
 1361  * (TCP state machine, etc).  We export all information using FreeBSD-native
 1362  * constants -- for example, the numeric values for tcpi_state will differ
 1363  * from Linux.
 1364  */
 1365 static void
 1366 tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
 1367 {
 1368 
 1369         INP_WLOCK_ASSERT(tp->t_inpcb);
 1370         bzero(ti, sizeof(*ti));
 1371 
 1372         ti->tcpi_state = tp->t_state;
 1373         if ((tp->t_flags & TF_REQ_TSTMP) && (tp->t_flags & TF_RCVD_TSTMP))
 1374                 ti->tcpi_options |= TCPI_OPT_TIMESTAMPS;
 1375         if (tp->t_flags & TF_SACK_PERMIT)
 1376                 ti->tcpi_options |= TCPI_OPT_SACK;
 1377         if ((tp->t_flags & TF_REQ_SCALE) && (tp->t_flags & TF_RCVD_SCALE)) {
 1378                 ti->tcpi_options |= TCPI_OPT_WSCALE;
 1379                 ti->tcpi_snd_wscale = tp->snd_scale;
 1380                 ti->tcpi_rcv_wscale = tp->rcv_scale;
 1381         }
 1382         if (tp->t_flags & TF_ECN_PERMIT)
 1383                 ti->tcpi_options |= TCPI_OPT_ECN;
 1384 
 1385         ti->tcpi_rto = tp->t_rxtcur * tick;
 1386         ti->tcpi_last_data_recv = (long)(ticks - (int)tp->t_rcvtime) * tick;
 1387         ti->tcpi_rtt = ((u_int64_t)tp->t_srtt * tick) >> TCP_RTT_SHIFT;
 1388         ti->tcpi_rttvar = ((u_int64_t)tp->t_rttvar * tick) >> TCP_RTTVAR_SHIFT;
 1389 
 1390         ti->tcpi_snd_ssthresh = tp->snd_ssthresh;
 1391         ti->tcpi_snd_cwnd = tp->snd_cwnd;
 1392 
 1393         /*
 1394          * FreeBSD-specific extension fields for tcp_info.
 1395          */
 1396         ti->tcpi_rcv_space = tp->rcv_wnd;
 1397         ti->tcpi_rcv_nxt = tp->rcv_nxt;
 1398         ti->tcpi_snd_wnd = tp->snd_wnd;
 1399         ti->tcpi_snd_bwnd = 0;          /* Unused, kept for compat. */
 1400         ti->tcpi_snd_nxt = tp->snd_nxt;
 1401         ti->tcpi_snd_mss = tp->t_maxseg;
 1402         ti->tcpi_rcv_mss = tp->t_maxseg;
 1403         if (tp->t_flags & TF_TOE)
 1404                 ti->tcpi_options |= TCPI_OPT_TOE;
 1405         ti->tcpi_snd_rexmitpack = tp->t_sndrexmitpack;
 1406         ti->tcpi_rcv_ooopack = tp->t_rcvoopack;
 1407         ti->tcpi_snd_zerowin = tp->t_sndzerowin;
 1408 }
 1409 
 1410 /*
 1411  * tcp_ctloutput() must drop the inpcb lock before performing copyin on
 1412  * socket option arguments.  When it re-acquires the lock after the copy, it
 1413  * has to revalidate that the connection is still valid for the socket
 1414  * option.
 1415  */
 1416 #define INP_WLOCK_RECHECK_CLEANUP(inp, cleanup) do {                    \
 1417         INP_WLOCK(inp);                                                 \
 1418         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {            \
 1419                 INP_WUNLOCK(inp);                                       \
 1420                 cleanup;                                                \
 1421                 return (ECONNRESET);                                    \
 1422         }                                                               \
 1423         tp = intotcpcb(inp);                                            \
 1424 } while(0)
 1425 #define INP_WLOCK_RECHECK(inp) INP_WLOCK_RECHECK_CLEANUP((inp), /* noop */)
 1426 
 1427 int
 1428 tcp_ctloutput(struct socket *so, struct sockopt *sopt)
 1429 {
 1430         int     error;
 1431         struct  inpcb *inp;
 1432         struct  tcpcb *tp;
 1433         struct tcp_function_block *blk;
 1434         struct tcp_function_set fsn;
 1435 
 1436         error = 0;
 1437         inp = sotoinpcb(so);
 1438         KASSERT(inp != NULL, ("tcp_ctloutput: inp == NULL"));
 1439         INP_WLOCK(inp);
 1440         if (sopt->sopt_level != IPPROTO_TCP) {
 1441 #ifdef INET6
 1442                 if (inp->inp_vflag & INP_IPV6PROTO) {
 1443                         INP_WUNLOCK(inp);
 1444                         error = ip6_ctloutput(so, sopt);
 1445                 }
 1446 #endif /* INET6 */
 1447 #if defined(INET6) && defined(INET)
 1448                 else
 1449 #endif
 1450 #ifdef INET
 1451                 {
 1452                         INP_WUNLOCK(inp);
 1453                         error = ip_ctloutput(so, sopt);
 1454                 }
 1455 #endif
 1456                 return (error);
 1457         }
 1458         if (inp->inp_flags & (INP_TIMEWAIT | INP_DROPPED)) {
 1459                 INP_WUNLOCK(inp);
 1460                 return (ECONNRESET);
 1461         }
 1462         tp = intotcpcb(inp);
 1463         /*
 1464          * Protect the TCP option TCP_FUNCTION_BLK so
 1465          * that a sub-function can *never* overwrite this.
 1466          */
 1467         if ((sopt->sopt_dir == SOPT_SET) && 
 1468             (sopt->sopt_name == TCP_FUNCTION_BLK)) {
 1469                 INP_WUNLOCK(inp);
 1470                 error = sooptcopyin(sopt, &fsn, sizeof fsn,
 1471                     sizeof fsn);
 1472                 if (error)
 1473                         return (error);
 1474                 INP_WLOCK_RECHECK(inp);
 1475                 if (tp->t_state != TCPS_CLOSED) {
 1476                         /* 
 1477                          * The user has advanced the state
 1478                          * past the initial point, we can't
 1479                          * switch since we are down the road
 1480                          * and a new set of functions may
 1481                          * not be compatibile.
 1482                          */
 1483                         INP_WUNLOCK(inp);
 1484                         return(EINVAL);
 1485                 }
 1486                 blk = find_and_ref_tcp_functions(&fsn);
 1487                 if (blk == NULL) {
 1488                         INP_WUNLOCK(inp);
 1489                         return (ENOENT);
 1490                 }
 1491                 if (tp->t_fb != blk) {
 1492                         if (blk->tfb_flags & TCP_FUNC_BEING_REMOVED) {
 1493                                 refcount_release(&blk->tfb_refcnt);
 1494                                 INP_WUNLOCK(inp);
 1495                                 return (ENOENT);
 1496                         }
 1497                         /* 
 1498                          * Release the old refcnt, the
 1499                          * lookup acquires a ref on the
 1500                          * new one.
 1501                          */
 1502                         if (tp->t_fb->tfb_tcp_fb_fini)
 1503                                 (*tp->t_fb->tfb_tcp_fb_fini)(tp);
 1504                         refcount_release(&tp->t_fb->tfb_refcnt);
 1505                         tp->t_fb = blk;
 1506                         if (tp->t_fb->tfb_tcp_fb_init) {
 1507                                 (*tp->t_fb->tfb_tcp_fb_init)(tp);
 1508                         }
 1509                 }
 1510 #ifdef TCP_OFFLOAD
 1511                 if (tp->t_flags & TF_TOE) {
 1512                         tcp_offload_ctloutput(tp, sopt->sopt_dir,
 1513                              sopt->sopt_name);
 1514                 }
 1515 #endif
 1516                 INP_WUNLOCK(inp);
 1517                 return (error);
 1518         } else if ((sopt->sopt_dir == SOPT_GET) && 
 1519             (sopt->sopt_name == TCP_FUNCTION_BLK)) {
 1520                 strncpy(fsn.function_set_name, tp->t_fb->tfb_tcp_block_name,
 1521                     TCP_FUNCTION_NAME_LEN_MAX);
 1522                 fsn.function_set_name[TCP_FUNCTION_NAME_LEN_MAX - 1] = '\0';
 1523                 fsn.pcbcnt = tp->t_fb->tfb_refcnt;
 1524                 INP_WUNLOCK(inp);
 1525                 error = sooptcopyout(sopt, &fsn, sizeof fsn);
 1526                 return (error);
 1527         }
 1528         /* Pass in the INP locked, called must unlock it */
 1529         return (tp->t_fb->tfb_tcp_ctloutput(so, sopt, inp, tp));
 1530 }
 1531 
 1532 int
 1533 tcp_default_ctloutput(struct socket *so, struct sockopt *sopt, struct inpcb *inp, struct tcpcb *tp)
 1534 {
 1535         int     error, opt, optval;
 1536         u_int   ui;
 1537         struct  tcp_info ti;
 1538         struct cc_algo *algo;
 1539         char    *pbuf, buf[TCP_CA_NAME_MAX];
 1540         size_t  len;
 1541 
 1542         /*
 1543          * For TCP_CCALGOOPT forward the control to CC module, for both
 1544          * SOPT_SET and SOPT_GET.
 1545          */
 1546         switch (sopt->sopt_name) {
 1547         case TCP_CCALGOOPT:
 1548                 INP_WUNLOCK(inp);
 1549                 pbuf = malloc(sopt->sopt_valsize, M_TEMP, M_WAITOK | M_ZERO);
 1550                 error = sooptcopyin(sopt, pbuf, sopt->sopt_valsize,
 1551                     sopt->sopt_valsize);
 1552                 if (error) {
 1553                         free(pbuf, M_TEMP);
 1554                         return (error);
 1555                 }
 1556                 INP_WLOCK_RECHECK_CLEANUP(inp, free(pbuf, M_TEMP));
 1557                 if (CC_ALGO(tp)->ctl_output != NULL)
 1558                         error = CC_ALGO(tp)->ctl_output(tp->ccv, sopt, pbuf);
 1559                 else
 1560                         error = ENOENT;
 1561                 INP_WUNLOCK(inp);
 1562                 if (error == 0 && sopt->sopt_dir == SOPT_GET)
 1563                         error = sooptcopyout(sopt, pbuf, sopt->sopt_valsize);
 1564                 free(pbuf, M_TEMP);
 1565                 return (error);
 1566         }
 1567 
 1568         switch (sopt->sopt_dir) {
 1569         case SOPT_SET:
 1570                 switch (sopt->sopt_name) {
 1571 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
 1572                 case TCP_MD5SIG:
 1573                         if (!TCPMD5_ENABLED()) {
 1574                                 INP_WUNLOCK(inp);
 1575                                 return (ENOPROTOOPT);
 1576                         }
 1577                         error = TCPMD5_PCBCTL(inp, sopt);
 1578                         if (error)
 1579                                 return (error);
 1580                         goto unlock_and_done;
 1581 #endif /* IPSEC */
 1582 
 1583                 case TCP_NODELAY:
 1584                 case TCP_NOOPT:
 1585                         INP_WUNLOCK(inp);
 1586                         error = sooptcopyin(sopt, &optval, sizeof optval,
 1587                             sizeof optval);
 1588                         if (error)
 1589                                 return (error);
 1590 
 1591                         INP_WLOCK_RECHECK(inp);
 1592                         switch (sopt->sopt_name) {
 1593                         case TCP_NODELAY:
 1594                                 opt = TF_NODELAY;
 1595                                 break;
 1596                         case TCP_NOOPT:
 1597                                 opt = TF_NOOPT;
 1598                                 break;
 1599                         default:
 1600                                 opt = 0; /* dead code to fool gcc */
 1601                                 break;
 1602                         }
 1603 
 1604                         if (optval)
 1605                                 tp->t_flags |= opt;
 1606                         else
 1607                                 tp->t_flags &= ~opt;
 1608 unlock_and_done:
 1609 #ifdef TCP_OFFLOAD
 1610                         if (tp->t_flags & TF_TOE) {
 1611                                 tcp_offload_ctloutput(tp, sopt->sopt_dir,
 1612                                     sopt->sopt_name);
 1613                         }
 1614 #endif
 1615                         INP_WUNLOCK(inp);
 1616                         break;
 1617 
 1618                 case TCP_NOPUSH:
 1619                         INP_WUNLOCK(inp);
 1620                         error = sooptcopyin(sopt, &optval, sizeof optval,
 1621                             sizeof optval);
 1622                         if (error)
 1623                                 return (error);
 1624 
 1625                         INP_WLOCK_RECHECK(inp);
 1626                         if (optval)
 1627                                 tp->t_flags |= TF_NOPUSH;
 1628                         else if (tp->t_flags & TF_NOPUSH) {
 1629                                 tp->t_flags &= ~TF_NOPUSH;
 1630                                 if (TCPS_HAVEESTABLISHED(tp->t_state))
 1631                                         error = tp->t_fb->tfb_tcp_output(tp);
 1632                         }
 1633                         goto unlock_and_done;
 1634 
 1635                 case TCP_MAXSEG:
 1636                         INP_WUNLOCK(inp);
 1637                         error = sooptcopyin(sopt, &optval, sizeof optval,
 1638                             sizeof optval);
 1639                         if (error)
 1640                                 return (error);
 1641 
 1642                         INP_WLOCK_RECHECK(inp);
 1643                         if (optval > 0 && optval <= tp->t_maxseg &&
 1644                             optval + 40 >= V_tcp_minmss)
 1645                                 tp->t_maxseg = optval;
 1646                         else
 1647                                 error = EINVAL;
 1648                         goto unlock_and_done;
 1649 
 1650                 case TCP_INFO:
 1651                         INP_WUNLOCK(inp);
 1652                         error = EINVAL;
 1653                         break;
 1654 
 1655                 case TCP_CONGESTION:
 1656                         INP_WUNLOCK(inp);
 1657                         error = sooptcopyin(sopt, buf, TCP_CA_NAME_MAX - 1, 1);
 1658                         if (error)
 1659                                 break;
 1660                         buf[sopt->sopt_valsize] = '\0';
 1661                         INP_WLOCK_RECHECK(inp);
 1662                         CC_LIST_RLOCK();
 1663                         STAILQ_FOREACH(algo, &cc_list, entries)
 1664                                 if (strncmp(buf, algo->name,
 1665                                     TCP_CA_NAME_MAX) == 0)
 1666                                         break;
 1667                         CC_LIST_RUNLOCK();
 1668                         if (algo == NULL) {
 1669                                 INP_WUNLOCK(inp);
 1670                                 error = EINVAL;
 1671                                 break;
 1672                         }
 1673                         /*
 1674                          * We hold a write lock over the tcb so it's safe to
 1675                          * do these things without ordering concerns.
 1676                          */
 1677                         if (CC_ALGO(tp)->cb_destroy != NULL)
 1678                                 CC_ALGO(tp)->cb_destroy(tp->ccv);
 1679                         CC_ALGO(tp) = algo;
 1680                         /*
 1681                          * If something goes pear shaped initialising the new
 1682                          * algo, fall back to newreno (which does not
 1683                          * require initialisation).
 1684                          */
 1685                         if (algo->cb_init != NULL &&
 1686                             algo->cb_init(tp->ccv) != 0) {
 1687                                 CC_ALGO(tp) = &newreno_cc_algo;
 1688                                 /*
 1689                                  * The only reason init should fail is
 1690                                  * because of malloc.
 1691                                  */
 1692                                 error = ENOMEM;
 1693                         }
 1694                         INP_WUNLOCK(inp);
 1695                         break;
 1696 
 1697                 case TCP_KEEPIDLE:
 1698                 case TCP_KEEPINTVL:
 1699                 case TCP_KEEPINIT:
 1700                         INP_WUNLOCK(inp);
 1701                         error = sooptcopyin(sopt, &ui, sizeof(ui), sizeof(ui));
 1702                         if (error)
 1703                                 return (error);
 1704 
 1705                         if (ui > (UINT_MAX / hz)) {
 1706                                 error = EINVAL;
 1707                                 break;
 1708                         }
 1709                         ui *= hz;
 1710 
 1711                         INP_WLOCK_RECHECK(inp);
 1712                         switch (sopt->sopt_name) {
 1713                         case TCP_KEEPIDLE:
 1714                                 tp->t_keepidle = ui;
 1715                                 /*
 1716                                  * XXX: better check current remaining
 1717                                  * timeout and "merge" it with new value.
 1718                                  */
 1719                                 if ((tp->t_state > TCPS_LISTEN) &&
 1720                                     (tp->t_state <= TCPS_CLOSING))
 1721                                         tcp_timer_activate(tp, TT_KEEP,
 1722                                             TP_KEEPIDLE(tp));
 1723                                 break;
 1724                         case TCP_KEEPINTVL:
 1725                                 tp->t_keepintvl = ui;
 1726                                 if ((tp->t_state == TCPS_FIN_WAIT_2) &&
 1727                                     (TP_MAXIDLE(tp) > 0))
 1728                                         tcp_timer_activate(tp, TT_2MSL,
 1729                                             TP_MAXIDLE(tp));
 1730                                 break;
 1731                         case TCP_KEEPINIT:
 1732                                 tp->t_keepinit = ui;
 1733                                 if (tp->t_state == TCPS_SYN_RECEIVED ||
 1734                                     tp->t_state == TCPS_SYN_SENT)
 1735                                         tcp_timer_activate(tp, TT_KEEP,
 1736                                             TP_KEEPINIT(tp));
 1737                                 break;
 1738                         }
 1739                         goto unlock_and_done;
 1740 
 1741                 case TCP_KEEPCNT:
 1742                         INP_WUNLOCK(inp);
 1743                         error = sooptcopyin(sopt, &ui, sizeof(ui), sizeof(ui));
 1744                         if (error)
 1745                                 return (error);
 1746 
 1747                         INP_WLOCK_RECHECK(inp);
 1748                         tp->t_keepcnt = ui;
 1749                         if ((tp->t_state == TCPS_FIN_WAIT_2) &&
 1750                             (TP_MAXIDLE(tp) > 0))
 1751                                 tcp_timer_activate(tp, TT_2MSL,
 1752                                     TP_MAXIDLE(tp));
 1753                         goto unlock_and_done;
 1754 
 1755 #ifdef TCPPCAP
 1756                 case TCP_PCAP_OUT:
 1757                 case TCP_PCAP_IN:
 1758                         INP_WUNLOCK(inp);
 1759                         error = sooptcopyin(sopt, &optval, sizeof optval,
 1760                             sizeof optval);
 1761                         if (error)
 1762                                 return (error);
 1763 
 1764                         INP_WLOCK_RECHECK(inp);
 1765                         if (optval >= 0)
 1766                                 tcp_pcap_set_sock_max(TCP_PCAP_OUT ?
 1767                                         &(tp->t_outpkts) : &(tp->t_inpkts),
 1768                                         optval);
 1769                         else
 1770                                 error = EINVAL;
 1771                         goto unlock_and_done;
 1772 #endif
 1773 
 1774 #ifdef TCP_RFC7413
 1775                 case TCP_FASTOPEN:
 1776                         INP_WUNLOCK(inp);
 1777                         if (!V_tcp_fastopen_enabled)
 1778                                 return (EPERM);
 1779 
 1780                         error = sooptcopyin(sopt, &optval, sizeof optval,
 1781                             sizeof optval);
 1782                         if (error)
 1783                                 return (error);
 1784 
 1785                         INP_WLOCK_RECHECK(inp);
 1786                         if (optval) {
 1787                                 tp->t_flags |= TF_FASTOPEN;
 1788                                 if ((tp->t_state == TCPS_LISTEN) &&
 1789                                     (tp->t_tfo_pending == NULL))
 1790                                         tp->t_tfo_pending =
 1791                                             tcp_fastopen_alloc_counter();
 1792                         } else
 1793                                 tp->t_flags &= ~TF_FASTOPEN;
 1794                         goto unlock_and_done;
 1795 #endif
 1796 
 1797                 default:
 1798                         INP_WUNLOCK(inp);
 1799                         error = ENOPROTOOPT;
 1800                         break;
 1801                 }
 1802                 break;
 1803 
 1804         case SOPT_GET:
 1805                 tp = intotcpcb(inp);
 1806                 switch (sopt->sopt_name) {
 1807 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
 1808                 case TCP_MD5SIG:
 1809                         if (!TCPMD5_ENABLED()) {
 1810                                 INP_WUNLOCK(inp);
 1811                                 return (ENOPROTOOPT);
 1812                         }
 1813                         error = TCPMD5_PCBCTL(inp, sopt);
 1814                         break;
 1815 #endif
 1816 
 1817                 case TCP_NODELAY:
 1818                         optval = tp->t_flags & TF_NODELAY;
 1819                         INP_WUNLOCK(inp);
 1820                         error = sooptcopyout(sopt, &optval, sizeof optval);
 1821                         break;
 1822                 case TCP_MAXSEG:
 1823                         optval = tp->t_maxseg;
 1824                         INP_WUNLOCK(inp);
 1825                         error = sooptcopyout(sopt, &optval, sizeof optval);
 1826                         break;
 1827                 case TCP_NOOPT:
 1828                         optval = tp->t_flags & TF_NOOPT;
 1829                         INP_WUNLOCK(inp);
 1830                         error = sooptcopyout(sopt, &optval, sizeof optval);
 1831                         break;
 1832                 case TCP_NOPUSH:
 1833                         optval = tp->t_flags & TF_NOPUSH;
 1834                         INP_WUNLOCK(inp);
 1835                         error = sooptcopyout(sopt, &optval, sizeof optval);
 1836                         break;
 1837                 case TCP_INFO:
 1838                         tcp_fill_info(tp, &ti);
 1839                         INP_WUNLOCK(inp);
 1840                         error = sooptcopyout(sopt, &ti, sizeof ti);
 1841                         break;
 1842                 case TCP_CONGESTION:
 1843                         len = strlcpy(buf, CC_ALGO(tp)->name, TCP_CA_NAME_MAX);
 1844                         INP_WUNLOCK(inp);
 1845                         error = sooptcopyout(sopt, buf, len + 1);
 1846                         break;
 1847                 case TCP_KEEPIDLE:
 1848                 case TCP_KEEPINTVL:
 1849                 case TCP_KEEPINIT:
 1850                 case TCP_KEEPCNT:
 1851                         switch (sopt->sopt_name) {
 1852                         case TCP_KEEPIDLE:
 1853                                 ui = TP_KEEPIDLE(tp) / hz;
 1854                                 break;
 1855                         case TCP_KEEPINTVL:
 1856                                 ui = TP_KEEPINTVL(tp) / hz;
 1857                                 break;
 1858                         case TCP_KEEPINIT:
 1859                                 ui = TP_KEEPINIT(tp) / hz;
 1860                                 break;
 1861                         case TCP_KEEPCNT:
 1862                                 ui = TP_KEEPCNT(tp);
 1863                                 break;
 1864                         }
 1865                         INP_WUNLOCK(inp);
 1866                         error = sooptcopyout(sopt, &ui, sizeof(ui));
 1867                         break;
 1868 #ifdef TCPPCAP
 1869                 case TCP_PCAP_OUT:
 1870                 case TCP_PCAP_IN:
 1871                         optval = tcp_pcap_get_sock_max(TCP_PCAP_OUT ?
 1872                                         &(tp->t_outpkts) : &(tp->t_inpkts));
 1873                         INP_WUNLOCK(inp);
 1874                         error = sooptcopyout(sopt, &optval, sizeof optval);
 1875                         break;
 1876 #endif
 1877 
 1878 #ifdef TCP_RFC7413
 1879                 case TCP_FASTOPEN:
 1880                         optval = tp->t_flags & TF_FASTOPEN;
 1881                         INP_WUNLOCK(inp);
 1882                         error = sooptcopyout(sopt, &optval, sizeof optval);
 1883                         break;
 1884 #endif
 1885                 default:
 1886                         INP_WUNLOCK(inp);
 1887                         error = ENOPROTOOPT;
 1888                         break;
 1889                 }
 1890                 break;
 1891         }
 1892         return (error);
 1893 }
 1894 #undef INP_WLOCK_RECHECK
 1895 #undef INP_WLOCK_RECHECK_CLEANUP
 1896 
 1897 /*
 1898  * Attach TCP protocol to socket, allocating
 1899  * internet protocol control block, tcp control block,
 1900  * bufer space, and entering LISTEN state if to accept connections.
 1901  */
 1902 static int
 1903 tcp_attach(struct socket *so)
 1904 {
 1905         struct tcpcb *tp;
 1906         struct inpcb *inp;
 1907         int error;
 1908 
 1909         if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
 1910                 error = soreserve(so, V_tcp_sendspace, V_tcp_recvspace);
 1911                 if (error)
 1912                         return (error);
 1913         }
 1914         so->so_rcv.sb_flags |= SB_AUTOSIZE;
 1915         so->so_snd.sb_flags |= SB_AUTOSIZE;
 1916         INP_INFO_RLOCK(&V_tcbinfo);
 1917         error = in_pcballoc(so, &V_tcbinfo);
 1918         if (error) {
 1919                 INP_INFO_RUNLOCK(&V_tcbinfo);
 1920                 return (error);
 1921         }
 1922         inp = sotoinpcb(so);
 1923 #ifdef INET6
 1924         if (inp->inp_vflag & INP_IPV6PROTO) {
 1925                 inp->inp_vflag |= INP_IPV6;
 1926                 inp->in6p_hops = -1;    /* use kernel default */
 1927         }
 1928         else
 1929 #endif
 1930         inp->inp_vflag |= INP_IPV4;
 1931         tp = tcp_newtcpcb(inp);
 1932         if (tp == NULL) {
 1933                 in_pcbdetach(inp);
 1934                 in_pcbfree(inp);
 1935                 INP_INFO_RUNLOCK(&V_tcbinfo);
 1936                 return (ENOBUFS);
 1937         }
 1938         tp->t_state = TCPS_CLOSED;
 1939         INP_WUNLOCK(inp);
 1940         INP_INFO_RUNLOCK(&V_tcbinfo);
 1941         TCPSTATES_INC(TCPS_CLOSED);
 1942         return (0);
 1943 }
 1944 
 1945 /*
 1946  * Initiate (or continue) disconnect.
 1947  * If embryonic state, just send reset (once).
 1948  * If in ``let data drain'' option and linger null, just drop.
 1949  * Otherwise (hard), mark socket disconnecting and drop
 1950  * current input data; switch states based on user close, and
 1951  * send segment to peer (with FIN).
 1952  */
 1953 static void
 1954 tcp_disconnect(struct tcpcb *tp)
 1955 {
 1956         struct inpcb *inp = tp->t_inpcb;
 1957         struct socket *so = inp->inp_socket;
 1958 
 1959         INP_INFO_RLOCK_ASSERT(&V_tcbinfo);
 1960         INP_WLOCK_ASSERT(inp);
 1961 
 1962         /*
 1963          * Neither tcp_close() nor tcp_drop() should return NULL, as the
 1964          * socket is still open.
 1965          */
 1966         if (tp->t_state < TCPS_ESTABLISHED) {
 1967                 tp = tcp_close(tp);
 1968                 KASSERT(tp != NULL,
 1969                     ("tcp_disconnect: tcp_close() returned NULL"));
 1970         } else if ((so->so_options & SO_LINGER) && so->so_linger == 0) {
 1971                 tp = tcp_drop(tp, 0);
 1972                 KASSERT(tp != NULL,
 1973                     ("tcp_disconnect: tcp_drop() returned NULL"));
 1974         } else {
 1975                 soisdisconnecting(so);
 1976                 sbflush(&so->so_rcv);
 1977                 tcp_usrclosed(tp);
 1978                 if (!(inp->inp_flags & INP_DROPPED))
 1979                         tp->t_fb->tfb_tcp_output(tp);
 1980         }
 1981 }
 1982 
 1983 /*
 1984  * User issued close, and wish to trail through shutdown states:
 1985  * if never received SYN, just forget it.  If got a SYN from peer,
 1986  * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
 1987  * If already got a FIN from peer, then almost done; go to LAST_ACK
 1988  * state.  In all other cases, have already sent FIN to peer (e.g.
 1989  * after PRU_SHUTDOWN), and just have to play tedious game waiting
 1990  * for peer to send FIN or not respond to keep-alives, etc.
 1991  * We can let the user exit from the close as soon as the FIN is acked.
 1992  */
 1993 static void
 1994 tcp_usrclosed(struct tcpcb *tp)
 1995 {
 1996 
 1997         INP_INFO_RLOCK_ASSERT(&V_tcbinfo);
 1998         INP_WLOCK_ASSERT(tp->t_inpcb);
 1999 
 2000         switch (tp->t_state) {
 2001         case TCPS_LISTEN:
 2002 #ifdef TCP_OFFLOAD
 2003                 tcp_offload_listen_stop(tp);
 2004 #endif
 2005                 tcp_state_change(tp, TCPS_CLOSED);
 2006                 /* FALLTHROUGH */
 2007         case TCPS_CLOSED:
 2008                 tp = tcp_close(tp);
 2009                 /*
 2010                  * tcp_close() should never return NULL here as the socket is
 2011                  * still open.
 2012                  */
 2013                 KASSERT(tp != NULL,
 2014                     ("tcp_usrclosed: tcp_close() returned NULL"));
 2015                 break;
 2016 
 2017         case TCPS_SYN_SENT:
 2018         case TCPS_SYN_RECEIVED:
 2019                 tp->t_flags |= TF_NEEDFIN;
 2020                 break;
 2021 
 2022         case TCPS_ESTABLISHED:
 2023                 tcp_state_change(tp, TCPS_FIN_WAIT_1);
 2024                 break;
 2025 
 2026         case TCPS_CLOSE_WAIT:
 2027                 tcp_state_change(tp, TCPS_LAST_ACK);
 2028                 break;
 2029         }
 2030         if (tp->t_state >= TCPS_FIN_WAIT_2) {
 2031                 soisdisconnected(tp->t_inpcb->inp_socket);
 2032                 /* Prevent the connection hanging in FIN_WAIT_2 forever. */
 2033                 if (tp->t_state == TCPS_FIN_WAIT_2) {
 2034                         int timeout;
 2035 
 2036                         timeout = (tcp_fast_finwait2_recycle) ? 
 2037                             tcp_finwait2_timeout : TP_MAXIDLE(tp);
 2038                         tcp_timer_activate(tp, TT_2MSL, timeout);
 2039                 }
 2040         }
 2041 }
 2042 
 2043 #ifdef DDB
 2044 static void
 2045 db_print_indent(int indent)
 2046 {
 2047         int i;
 2048 
 2049         for (i = 0; i < indent; i++)
 2050                 db_printf(" ");
 2051 }
 2052 
 2053 static void
 2054 db_print_tstate(int t_state)
 2055 {
 2056 
 2057         switch (t_state) {
 2058         case TCPS_CLOSED:
 2059                 db_printf("TCPS_CLOSED");
 2060                 return;
 2061 
 2062         case TCPS_LISTEN:
 2063                 db_printf("TCPS_LISTEN");
 2064                 return;
 2065 
 2066         case TCPS_SYN_SENT:
 2067                 db_printf("TCPS_SYN_SENT");
 2068                 return;
 2069 
 2070         case TCPS_SYN_RECEIVED:
 2071                 db_printf("TCPS_SYN_RECEIVED");
 2072                 return;
 2073 
 2074         case TCPS_ESTABLISHED:
 2075                 db_printf("TCPS_ESTABLISHED");
 2076                 return;
 2077 
 2078         case TCPS_CLOSE_WAIT:
 2079                 db_printf("TCPS_CLOSE_WAIT");
 2080                 return;
 2081 
 2082         case TCPS_FIN_WAIT_1:
 2083                 db_printf("TCPS_FIN_WAIT_1");
 2084                 return;
 2085 
 2086         case TCPS_CLOSING:
 2087                 db_printf("TCPS_CLOSING");
 2088                 return;
 2089 
 2090         case TCPS_LAST_ACK:
 2091                 db_printf("TCPS_LAST_ACK");
 2092                 return;
 2093 
 2094         case TCPS_FIN_WAIT_2:
 2095                 db_printf("TCPS_FIN_WAIT_2");
 2096                 return;
 2097 
 2098         case TCPS_TIME_WAIT:
 2099                 db_printf("TCPS_TIME_WAIT");
 2100                 return;
 2101 
 2102         default:
 2103                 db_printf("unknown");
 2104                 return;
 2105         }
 2106 }
 2107 
 2108 static void
 2109 db_print_tflags(u_int t_flags)
 2110 {
 2111         int comma;
 2112 
 2113         comma = 0;
 2114         if (t_flags & TF_ACKNOW) {
 2115                 db_printf("%sTF_ACKNOW", comma ? ", " : "");
 2116                 comma = 1;
 2117         }
 2118         if (t_flags & TF_DELACK) {
 2119                 db_printf("%sTF_DELACK", comma ? ", " : "");
 2120                 comma = 1;
 2121         }
 2122         if (t_flags & TF_NODELAY) {
 2123                 db_printf("%sTF_NODELAY", comma ? ", " : "");
 2124                 comma = 1;
 2125         }
 2126         if (t_flags & TF_NOOPT) {
 2127                 db_printf("%sTF_NOOPT", comma ? ", " : "");
 2128                 comma = 1;
 2129         }
 2130         if (t_flags & TF_SENTFIN) {
 2131                 db_printf("%sTF_SENTFIN", comma ? ", " : "");
 2132                 comma = 1;
 2133         }
 2134         if (t_flags & TF_REQ_SCALE) {
 2135                 db_printf("%sTF_REQ_SCALE", comma ? ", " : "");
 2136                 comma = 1;
 2137         }
 2138         if (t_flags & TF_RCVD_SCALE) {
 2139                 db_printf("%sTF_RECVD_SCALE", comma ? ", " : "");
 2140                 comma = 1;
 2141         }
 2142         if (t_flags & TF_REQ_TSTMP) {
 2143                 db_printf("%sTF_REQ_TSTMP", comma ? ", " : "");
 2144                 comma = 1;
 2145         }
 2146         if (t_flags & TF_RCVD_TSTMP) {
 2147                 db_printf("%sTF_RCVD_TSTMP", comma ? ", " : "");
 2148                 comma = 1;
 2149         }
 2150         if (t_flags & TF_SACK_PERMIT) {
 2151                 db_printf("%sTF_SACK_PERMIT", comma ? ", " : "");
 2152                 comma = 1;
 2153         }
 2154         if (t_flags & TF_NEEDSYN) {
 2155                 db_printf("%sTF_NEEDSYN", comma ? ", " : "");
 2156                 comma = 1;
 2157         }
 2158         if (t_flags & TF_NEEDFIN) {
 2159                 db_printf("%sTF_NEEDFIN", comma ? ", " : "");
 2160                 comma = 1;
 2161         }
 2162         if (t_flags & TF_NOPUSH) {
 2163                 db_printf("%sTF_NOPUSH", comma ? ", " : "");
 2164                 comma = 1;
 2165         }
 2166         if (t_flags & TF_MORETOCOME) {
 2167                 db_printf("%sTF_MORETOCOME", comma ? ", " : "");
 2168                 comma = 1;
 2169         }
 2170         if (t_flags & TF_LQ_OVERFLOW) {
 2171                 db_printf("%sTF_LQ_OVERFLOW", comma ? ", " : "");
 2172                 comma = 1;
 2173         }
 2174         if (t_flags & TF_LASTIDLE) {
 2175                 db_printf("%sTF_LASTIDLE", comma ? ", " : "");
 2176                 comma = 1;
 2177         }
 2178         if (t_flags & TF_RXWIN0SENT) {
 2179                 db_printf("%sTF_RXWIN0SENT", comma ? ", " : "");
 2180                 comma = 1;
 2181         }
 2182         if (t_flags & TF_FASTRECOVERY) {
 2183                 db_printf("%sTF_FASTRECOVERY", comma ? ", " : "");
 2184                 comma = 1;
 2185         }
 2186         if (t_flags & TF_CONGRECOVERY) {
 2187                 db_printf("%sTF_CONGRECOVERY", comma ? ", " : "");
 2188                 comma = 1;
 2189         }
 2190         if (t_flags & TF_WASFRECOVERY) {
 2191                 db_printf("%sTF_WASFRECOVERY", comma ? ", " : "");
 2192                 comma = 1;
 2193         }
 2194         if (t_flags & TF_SIGNATURE) {
 2195                 db_printf("%sTF_SIGNATURE", comma ? ", " : "");
 2196                 comma = 1;
 2197         }
 2198         if (t_flags & TF_FORCEDATA) {
 2199                 db_printf("%sTF_FORCEDATA", comma ? ", " : "");
 2200                 comma = 1;
 2201         }
 2202         if (t_flags & TF_TSO) {
 2203                 db_printf("%sTF_TSO", comma ? ", " : "");
 2204                 comma = 1;
 2205         }
 2206         if (t_flags & TF_ECN_PERMIT) {
 2207                 db_printf("%sTF_ECN_PERMIT", comma ? ", " : "");
 2208                 comma = 1;
 2209         }
 2210         if (t_flags & TF_FASTOPEN) {
 2211                 db_printf("%sTF_FASTOPEN", comma ? ", " : "");
 2212                 comma = 1;
 2213         }
 2214 }
 2215 
 2216 static void
 2217 db_print_toobflags(char t_oobflags)
 2218 {
 2219         int comma;
 2220 
 2221         comma = 0;
 2222         if (t_oobflags & TCPOOB_HAVEDATA) {
 2223                 db_printf("%sTCPOOB_HAVEDATA", comma ? ", " : "");
 2224                 comma = 1;
 2225         }
 2226         if (t_oobflags & TCPOOB_HADDATA) {
 2227                 db_printf("%sTCPOOB_HADDATA", comma ? ", " : "");
 2228                 comma = 1;
 2229         }
 2230 }
 2231 
 2232 static void
 2233 db_print_tcpcb(struct tcpcb *tp, const char *name, int indent)
 2234 {
 2235 
 2236         db_print_indent(indent);
 2237         db_printf("%s at %p\n", name, tp);
 2238 
 2239         indent += 2;
 2240 
 2241         db_print_indent(indent);
 2242         db_printf("t_segq first: %p   t_segqlen: %d   t_dupacks: %d\n",
 2243            LIST_FIRST(&tp->t_segq), tp->t_segqlen, tp->t_dupacks);
 2244 
 2245         db_print_indent(indent);
 2246         db_printf("tt_rexmt: %p   tt_persist: %p   tt_keep: %p\n",
 2247             &tp->t_timers->tt_rexmt, &tp->t_timers->tt_persist, &tp->t_timers->tt_keep);
 2248 
 2249         db_print_indent(indent);
 2250         db_printf("tt_2msl: %p   tt_delack: %p   t_inpcb: %p\n", &tp->t_timers->tt_2msl,
 2251             &tp->t_timers->tt_delack, tp->t_inpcb);
 2252 
 2253         db_print_indent(indent);
 2254         db_printf("t_state: %d (", tp->t_state);
 2255         db_print_tstate(tp->t_state);
 2256         db_printf(")\n");
 2257 
 2258         db_print_indent(indent);
 2259         db_printf("t_flags: 0x%x (", tp->t_flags);
 2260         db_print_tflags(tp->t_flags);
 2261         db_printf(")\n");
 2262 
 2263         db_print_indent(indent);
 2264         db_printf("snd_una: 0x%08x   snd_max: 0x%08x   snd_nxt: x0%08x\n",
 2265             tp->snd_una, tp->snd_max, tp->snd_nxt);
 2266 
 2267         db_print_indent(indent);
 2268         db_printf("snd_up: 0x%08x   snd_wl1: 0x%08x   snd_wl2: 0x%08x\n",
 2269            tp->snd_up, tp->snd_wl1, tp->snd_wl2);
 2270 
 2271         db_print_indent(indent);
 2272         db_printf("iss: 0x%08x   irs: 0x%08x   rcv_nxt: 0x%08x\n",
 2273             tp->iss, tp->irs, tp->rcv_nxt);
 2274 
 2275         db_print_indent(indent);
 2276         db_printf("rcv_adv: 0x%08x   rcv_wnd: %lu   rcv_up: 0x%08x\n",
 2277             tp->rcv_adv, tp->rcv_wnd, tp->rcv_up);
 2278 
 2279         db_print_indent(indent);
 2280         db_printf("snd_wnd: %lu   snd_cwnd: %lu\n",
 2281            tp->snd_wnd, tp->snd_cwnd);
 2282 
 2283         db_print_indent(indent);
 2284         db_printf("snd_ssthresh: %lu   snd_recover: "
 2285             "0x%08x\n", tp->snd_ssthresh, tp->snd_recover);
 2286 
 2287         db_print_indent(indent);
 2288         db_printf("t_rcvtime: %u   t_startime: %u\n",
 2289             tp->t_rcvtime, tp->t_starttime);
 2290 
 2291         db_print_indent(indent);
 2292         db_printf("t_rttime: %u   t_rtsq: 0x%08x\n",
 2293             tp->t_rtttime, tp->t_rtseq);
 2294 
 2295         db_print_indent(indent);
 2296         db_printf("t_rxtcur: %d   t_maxseg: %u   t_srtt: %d\n",
 2297             tp->t_rxtcur, tp->t_maxseg, tp->t_srtt);
 2298 
 2299         db_print_indent(indent);
 2300         db_printf("t_rttvar: %d   t_rxtshift: %d   t_rttmin: %u   "
 2301             "t_rttbest: %u\n", tp->t_rttvar, tp->t_rxtshift, tp->t_rttmin,
 2302             tp->t_rttbest);
 2303 
 2304         db_print_indent(indent);
 2305         db_printf("t_rttupdated: %lu   max_sndwnd: %lu   t_softerror: %d\n",
 2306             tp->t_rttupdated, tp->max_sndwnd, tp->t_softerror);
 2307 
 2308         db_print_indent(indent);
 2309         db_printf("t_oobflags: 0x%x (", tp->t_oobflags);
 2310         db_print_toobflags(tp->t_oobflags);
 2311         db_printf(")   t_iobc: 0x%02x\n", tp->t_iobc);
 2312 
 2313         db_print_indent(indent);
 2314         db_printf("snd_scale: %u   rcv_scale: %u   request_r_scale: %u\n",
 2315             tp->snd_scale, tp->rcv_scale, tp->request_r_scale);
 2316 
 2317         db_print_indent(indent);
 2318         db_printf("ts_recent: %u   ts_recent_age: %u\n",
 2319             tp->ts_recent, tp->ts_recent_age);
 2320 
 2321         db_print_indent(indent);
 2322         db_printf("ts_offset: %u   last_ack_sent: 0x%08x   snd_cwnd_prev: "
 2323             "%lu\n", tp->ts_offset, tp->last_ack_sent, tp->snd_cwnd_prev);
 2324 
 2325         db_print_indent(indent);
 2326         db_printf("snd_ssthresh_prev: %lu   snd_recover_prev: 0x%08x   "
 2327             "t_badrxtwin: %u\n", tp->snd_ssthresh_prev,
 2328             tp->snd_recover_prev, tp->t_badrxtwin);
 2329 
 2330         db_print_indent(indent);
 2331         db_printf("snd_numholes: %d  snd_holes first: %p\n",
 2332             tp->snd_numholes, TAILQ_FIRST(&tp->snd_holes));
 2333 
 2334         db_print_indent(indent);
 2335         db_printf("snd_fack: 0x%08x   rcv_numsacks: %d   sack_newdata: "
 2336             "0x%08x\n", tp->snd_fack, tp->rcv_numsacks, tp->sack_newdata);
 2337 
 2338         /* Skip sackblks, sackhint. */
 2339 
 2340         db_print_indent(indent);
 2341         db_printf("t_rttlow: %d   rfbuf_ts: %u   rfbuf_cnt: %d\n",
 2342             tp->t_rttlow, tp->rfbuf_ts, tp->rfbuf_cnt);
 2343 }
 2344 
 2345 DB_SHOW_COMMAND(tcpcb, db_show_tcpcb)
 2346 {
 2347         struct tcpcb *tp;
 2348 
 2349         if (!have_addr) {
 2350                 db_printf("usage: show tcpcb <addr>\n");
 2351                 return;
 2352         }
 2353         tp = (struct tcpcb *)addr;
 2354 
 2355         db_print_tcpcb(tp, "tcpcb", 0);
 2356 }
 2357 #endif

Cache object: bb94916827a544cf8308bc207fc0b506


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.