sys/netinet/tcp_usrreq.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1988, 1993
   5  *      The Regents of the University of California.
   6  * Copyright (c) 2006-2007 Robert N. M. Watson
   7  * Copyright (c) 2010-2011 Juniper Networks, Inc.
   8  * All rights reserved.
   9  *
  10  * Portions of this software were developed by Robert N. M. Watson under
  11  * contract to Juniper Networks, Inc.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. Neither the name of the University nor the names of its contributors
  22  *    may be used to endorse or promote products derived from this software
  23  *    without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  35  * SUCH DAMAGE.
  36  *
  37  *      From: @(#)tcp_usrreq.c  8.2 (Berkeley) 1/3/94
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include "opt_ddb.h"
  44 #include "opt_inet.h"
  45 #include "opt_inet6.h"
  46 #include "opt_ipsec.h"
  47 #include "opt_kern_tls.h"
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/arb.h>
  52 #include <sys/limits.h>
  53 #include <sys/malloc.h>
  54 #include <sys/refcount.h>
  55 #include <sys/kernel.h>
  56 #include <sys/ktls.h>
  57 #include <sys/qmath.h>
  58 #include <sys/sysctl.h>
  59 #include <sys/mbuf.h>
  60 #ifdef INET6
  61 #include <sys/domain.h>
  62 #endif /* INET6 */
  63 #include <sys/socket.h>
  64 #include <sys/socketvar.h>
  65 #include <sys/protosw.h>
  66 #include <sys/proc.h>
  67 #include <sys/jail.h>
  68 #include <sys/stats.h>
  69
  70 #ifdef DDB
  71 #include <ddb/ddb.h>
  72 #endif
  73
  74 #include <net/if.h>
  75 #include <net/if_var.h>
  76 #include <net/route.h>
  77 #include <net/vnet.h>
  78
  79 #include <netinet/in.h>
  80 #include <netinet/in_kdtrace.h>
  81 #include <netinet/in_pcb.h>
  82 #include <netinet/in_systm.h>
  83 #include <netinet/in_var.h>
  84 #include <netinet/ip.h>
  85 #include <netinet/ip_var.h>
  86 #ifdef INET6
  87 #include <netinet/ip6.h>
  88 #include <netinet6/in6_pcb.h>
  89 #include <netinet6/ip6_var.h>
  90 #include <netinet6/scope6_var.h>
  91 #endif
  92 #include <netinet/tcp.h>
  93 #include <netinet/tcp_fsm.h>
  94 #include <netinet/tcp_seq.h>
  95 #include <netinet/tcp_timer.h>
  96 #include <netinet/tcp_var.h>
  97 #include <netinet/tcp_log_buf.h>
  98 #include <netinet/tcpip.h>
  99 #include <netinet/cc/cc.h>
 100 #include <netinet/tcp_fastopen.h>
 101 #include <netinet/tcp_hpts.h>
 102 #ifdef TCPPCAP
 103 #include <netinet/tcp_pcap.h>
 104 #endif
 105 #ifdef TCP_OFFLOAD
 106 #include <netinet/tcp_offload.h>
 107 #endif
 108 #include <netipsec/ipsec_support.h>
 109
 110 #include <vm/vm.h>
 111 #include <vm/vm_param.h>
 112 #include <vm/pmap.h>
 113 #include <vm/vm_extern.h>
 114 #include <vm/vm_map.h>
 115 #include <vm/vm_page.h>
 116
 117 /*
 118  * TCP protocol interface to socket abstraction.
 119  */
 120 #ifdef INET
 121 static int      tcp_connect(struct tcpcb *, struct sockaddr_in *,
 122                     struct thread *td);
 123 #endif /* INET */
 124 #ifdef INET6
 125 static int      tcp6_connect(struct tcpcb *, struct sockaddr_in6 *,
 126                     struct thread *td);
 127 #endif /* INET6 */
 128 static void     tcp_disconnect(struct tcpcb *);
 129 static void     tcp_usrclosed(struct tcpcb *);
 130 static void     tcp_fill_info(struct tcpcb *, struct tcp_info *);
 131
 132 static int      tcp_pru_options_support(struct tcpcb *tp, int flags);
 133
 134 static void
 135 tcp_bblog_pru(struct tcpcb *tp, uint32_t pru, int error)
 136 {
 137         struct tcp_log_buffer *lgb;
 138
 139         KASSERT(tp != NULL, ("tcp_bblog_pru: tp == NULL"));
 140         INP_WLOCK_ASSERT(tptoinpcb(tp));
 141         if (tcp_bblogging_on(tp)) {
 142                 lgb = tcp_log_event(tp, NULL, NULL, NULL, TCP_LOG_PRU, error,
 143                     0, NULL, false, NULL, NULL, 0, NULL);
 144         } else {
 145                 lgb = NULL;
 146         }
 147         if (lgb != NULL) {
 148                 if (error >= 0) {
 149                         lgb->tlb_errno = (uint32_t)error;
 150                 }
 151                 lgb->tlb_flex1 = pru;
 152         }
 153 }
 154
 155 /*
 156  * TCP attaches to socket via pru_attach(), reserving space,
 157  * and an internet control block.
 158  */
 159 static int
 160 tcp_usr_attach(struct socket *so, int proto, struct thread *td)
 161 {
 162         struct inpcb *inp;
 163         struct tcpcb *tp = NULL;
 164         int error;
 165
 166         inp = sotoinpcb(so);
 167         KASSERT(inp == NULL, ("tcp_usr_attach: inp != NULL"));
 168
 169         error = soreserve(so, V_tcp_sendspace, V_tcp_recvspace);
 170         if (error)
 171                 goto out;
 172
 173         so->so_rcv.sb_flags |= SB_AUTOSIZE;
 174         so->so_snd.sb_flags |= SB_AUTOSIZE;
 175         error = in_pcballoc(so, &V_tcbinfo);
 176         if (error)
 177                 goto out;
 178         inp = sotoinpcb(so);
 179         tp = tcp_newtcpcb(inp);
 180         if (tp == NULL) {
 181                 error = ENOBUFS;
 182                 in_pcbdetach(inp);
 183                 in_pcbfree(inp);
 184                 goto out;
 185         }
 186         tp->t_state = TCPS_CLOSED;
 187         tcp_bblog_pru(tp, PRU_ATTACH, error);
 188         INP_WUNLOCK(inp);
 189         TCPSTATES_INC(TCPS_CLOSED);
 190 out:
 191         TCP_PROBE2(debug__user, tp, PRU_ATTACH);
 192         return (error);
 193 }
 194
 195 /*
 196  * tcp_usr_detach is called when the socket layer loses its final reference
 197  * to the socket, be it a file descriptor reference, a reference from TCP,
 198  * etc.  At this point, there is only one case in which we will keep around
 199  * inpcb state: time wait.
 200  */
 201 static void
 202 tcp_usr_detach(struct socket *so)
 203 {
 204         struct inpcb *inp;
 205         struct tcpcb *tp;
 206
 207         inp = sotoinpcb(so);
 208         KASSERT(inp != NULL, ("%s: inp == NULL", __func__));
 209         INP_WLOCK(inp);
 210         KASSERT(so->so_pcb == inp && inp->inp_socket == so,
 211                 ("%s: socket %p inp %p mismatch", __func__, so, inp));
 212
 213         tp = intotcpcb(inp);
 214
 215         KASSERT(inp->inp_flags & INP_DROPPED ||
 216             tp->t_state < TCPS_SYN_SENT,
 217             ("%s: inp %p not dropped or embryonic", __func__, inp));
 218
 219         tcp_discardcb(tp);
 220         in_pcbdetach(inp);
 221         in_pcbfree(inp);
 222 }
 223
 224 #ifdef INET
 225 /*
 226  * Give the socket an address.
 227  */
 228 static int
 229 tcp_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
 230 {
 231         int error = 0;
 232         struct inpcb *inp;
 233         struct tcpcb *tp;
 234         struct sockaddr_in *sinp;
 235
 236         inp = sotoinpcb(so);
 237         KASSERT(inp != NULL, ("tcp_usr_bind: inp == NULL"));
 238         INP_WLOCK(inp);
 239         if (inp->inp_flags & INP_DROPPED) {
 240                 INP_WUNLOCK(inp);
 241                 return (EINVAL);
 242         }
 243         tp = intotcpcb(inp);
 244
 245         sinp = (struct sockaddr_in *)nam;
 246         if (nam->sa_family != AF_INET) {
 247                 /*
 248                  * Preserve compatibility with old programs.
 249                  */
 250                 if (nam->sa_family != AF_UNSPEC ||
 251                     nam->sa_len < offsetof(struct sockaddr_in, sin_zero) ||
 252                     sinp->sin_addr.s_addr != INADDR_ANY) {
 253                         error = EAFNOSUPPORT;
 254                         goto out;
 255                 }
 256                 nam->sa_family = AF_INET;
 257         }
 258         if (nam->sa_len != sizeof(*sinp)) {
 259                 error = EINVAL;
 260                 goto out;
 261         }
 262         /*
 263          * Must check for multicast addresses and disallow binding
 264          * to them.
 265          */
 266         if (IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
 267                 error = EAFNOSUPPORT;
 268                 goto out;
 269         }
 270         INP_HASH_WLOCK(&V_tcbinfo);
 271         error = in_pcbbind(inp, sinp, td->td_ucred);
 272         INP_HASH_WUNLOCK(&V_tcbinfo);
 273 out:
 274         tcp_bblog_pru(tp, PRU_BIND, error);
 275         TCP_PROBE2(debug__user, tp, PRU_BIND);
 276         INP_WUNLOCK(inp);
 277
 278         return (error);
 279 }
 280 #endif /* INET */
 281
 282 #ifdef INET6
 283 static int
 284 tcp6_usr_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
 285 {
 286         int error = 0;
 287         struct inpcb *inp;
 288         struct tcpcb *tp;
 289         struct sockaddr_in6 *sin6;
 290         u_char vflagsav;
 291
 292         inp = sotoinpcb(so);
 293         KASSERT(inp != NULL, ("tcp6_usr_bind: inp == NULL"));
 294         INP_WLOCK(inp);
 295         if (inp->inp_flags & INP_DROPPED) {
 296                 INP_WUNLOCK(inp);
 297                 return (EINVAL);
 298         }
 299         tp = intotcpcb(inp);
 300
 301         vflagsav = inp->inp_vflag;
 302
 303         sin6 = (struct sockaddr_in6 *)nam;
 304         if (nam->sa_family != AF_INET6) {
 305                 error = EAFNOSUPPORT;
 306                 goto out;
 307         }
 308         if (nam->sa_len != sizeof(*sin6)) {
 309                 error = EINVAL;
 310                 goto out;
 311         }
 312         /*
 313          * Must check for multicast addresses and disallow binding
 314          * to them.
 315          */
 316         if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
 317                 error = EAFNOSUPPORT;
 318                 goto out;
 319         }
 320
 321         INP_HASH_WLOCK(&V_tcbinfo);
 322         inp->inp_vflag &= ~INP_IPV4;
 323         inp->inp_vflag |= INP_IPV6;
 324 #ifdef INET
 325         if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0) {
 326                 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
 327                         inp->inp_vflag |= INP_IPV4;
 328                 else if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
 329                         struct sockaddr_in sin;
 330
 331                         in6_sin6_2_sin(&sin, sin6);
 332                         if (IN_MULTICAST(ntohl(sin.sin_addr.s_addr))) {
 333                                 error = EAFNOSUPPORT;
 334                                 INP_HASH_WUNLOCK(&V_tcbinfo);
 335                                 goto out;
 336                         }
 337                         inp->inp_vflag |= INP_IPV4;
 338                         inp->inp_vflag &= ~INP_IPV6;
 339                         error = in_pcbbind(inp, &sin, td->td_ucred);
 340                         INP_HASH_WUNLOCK(&V_tcbinfo);
 341                         goto out;
 342                 }
 343         }
 344 #endif
 345         error = in6_pcbbind(inp, sin6, td->td_ucred);
 346         INP_HASH_WUNLOCK(&V_tcbinfo);
 347 out:
 348         if (error != 0)
 349                 inp->inp_vflag = vflagsav;
 350         tcp_bblog_pru(tp, PRU_BIND, error);
 351         TCP_PROBE2(debug__user, tp, PRU_BIND);
 352         INP_WUNLOCK(inp);
 353         return (error);
 354 }
 355 #endif /* INET6 */
 356
 357 #ifdef INET
 358 /*
 359  * Prepare to accept connections.
 360  */
 361 static int
 362 tcp_usr_listen(struct socket *so, int backlog, struct thread *td)
 363 {
 364         int error = 0;
 365         struct inpcb *inp;
 366         struct tcpcb *tp;
 367
 368         inp = sotoinpcb(so);
 369         KASSERT(inp != NULL, ("tcp_usr_listen: inp == NULL"));
 370         INP_WLOCK(inp);
 371         if (inp->inp_flags & INP_DROPPED) {
 372                 INP_WUNLOCK(inp);
 373                 return (EINVAL);
 374         }
 375         tp = intotcpcb(inp);
 376
 377         SOCK_LOCK(so);
 378         error = solisten_proto_check(so);
 379         if (error != 0) {
 380                 SOCK_UNLOCK(so);
 381                 goto out;
 382         }
 383         if (inp->inp_lport == 0) {
 384                 INP_HASH_WLOCK(&V_tcbinfo);
 385                 error = in_pcbbind(inp, NULL, td->td_ucred);
 386                 INP_HASH_WUNLOCK(&V_tcbinfo);
 387         }
 388         if (error == 0) {
 389                 tcp_state_change(tp, TCPS_LISTEN);
 390                 solisten_proto(so, backlog);
 391 #ifdef TCP_OFFLOAD
 392                 if ((so->so_options & SO_NO_OFFLOAD) == 0)
 393                         tcp_offload_listen_start(tp);
 394 #endif
 395         } else {
 396                 solisten_proto_abort(so);
 397         }
 398         SOCK_UNLOCK(so);
 399
 400         if (IS_FASTOPEN(tp->t_flags))
 401                 tp->t_tfo_pending = tcp_fastopen_alloc_counter();
 402
 403 out:
 404         tcp_bblog_pru(tp, PRU_LISTEN, error);
 405         TCP_PROBE2(debug__user, tp, PRU_LISTEN);
 406         INP_WUNLOCK(inp);
 407         return (error);
 408 }
 409 #endif /* INET */
 410
 411 #ifdef INET6
 412 static int
 413 tcp6_usr_listen(struct socket *so, int backlog, struct thread *td)
 414 {
 415         int error = 0;
 416         struct inpcb *inp;
 417         struct tcpcb *tp;
 418         u_char vflagsav;
 419
 420         inp = sotoinpcb(so);
 421         KASSERT(inp != NULL, ("tcp6_usr_listen: inp == NULL"));
 422         INP_WLOCK(inp);
 423         if (inp->inp_flags & INP_DROPPED) {
 424                 INP_WUNLOCK(inp);
 425                 return (EINVAL);
 426         }
 427         tp = intotcpcb(inp);
 428
 429         vflagsav = inp->inp_vflag;
 430
 431         SOCK_LOCK(so);
 432         error = solisten_proto_check(so);
 433         if (error != 0) {
 434                 SOCK_UNLOCK(so);
 435                 goto out;
 436         }
 437         INP_HASH_WLOCK(&V_tcbinfo);
 438         if (inp->inp_lport == 0) {
 439                 inp->inp_vflag &= ~INP_IPV4;
 440                 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) == 0)
 441                         inp->inp_vflag |= INP_IPV4;
 442                 error = in6_pcbbind(inp, NULL, td->td_ucred);
 443         }
 444         INP_HASH_WUNLOCK(&V_tcbinfo);
 445         if (error == 0) {
 446                 tcp_state_change(tp, TCPS_LISTEN);
 447                 solisten_proto(so, backlog);
 448 #ifdef TCP_OFFLOAD
 449                 if ((so->so_options & SO_NO_OFFLOAD) == 0)
 450                         tcp_offload_listen_start(tp);
 451 #endif
 452         } else {
 453                 solisten_proto_abort(so);
 454         }
 455         SOCK_UNLOCK(so);
 456
 457         if (IS_FASTOPEN(tp->t_flags))
 458                 tp->t_tfo_pending = tcp_fastopen_alloc_counter();
 459
 460         if (error != 0)
 461                 inp->inp_vflag = vflagsav;
 462
 463 out:
 464         tcp_bblog_pru(tp, PRU_LISTEN, error);
 465         TCP_PROBE2(debug__user, tp, PRU_LISTEN);
 466         INP_WUNLOCK(inp);
 467         return (error);
 468 }
 469 #endif /* INET6 */
 470
 471 #ifdef INET
 472 /*
 473  * Initiate connection to peer.
 474  * Create a template for use in transmissions on this connection.
 475  * Enter SYN_SENT state, and mark socket as connecting.
 476  * Start keep-alive timer, and seed output sequence space.
 477  * Send initial segment on connection.
 478  */
 479 static int
 480 tcp_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
 481 {
 482         struct epoch_tracker et;
 483         int error = 0;
 484         struct inpcb *inp;
 485         struct tcpcb *tp;
 486         struct sockaddr_in *sinp;
 487
 488         inp = sotoinpcb(so);
 489         KASSERT(inp != NULL, ("tcp_usr_connect: inp == NULL"));
 490         INP_WLOCK(inp);
 491         if (inp->inp_flags & INP_DROPPED) {
 492                 INP_WUNLOCK(inp);
 493                 return (ECONNREFUSED);
 494         }
 495         tp = intotcpcb(inp);
 496
 497         sinp = (struct sockaddr_in *)nam;
 498         if (nam->sa_family != AF_INET) {
 499                 error = EAFNOSUPPORT;
 500                 goto out;
 501         }
 502         if (nam->sa_len != sizeof (*sinp)) {
 503                 error = EINVAL;
 504                 goto out;
 505         }
 506         /*
 507          * Must disallow TCP ``connections'' to multicast addresses.
 508          */
 509         if (IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
 510                 error = EAFNOSUPPORT;
 511                 goto out;
 512         }
 513         if (ntohl(sinp->sin_addr.s_addr) == INADDR_BROADCAST) {
 514                 error = EACCES;
 515                 goto out;
 516         }
 517         if ((error = prison_remote_ip4(td->td_ucred, &sinp->sin_addr)) != 0)
 518                 goto out;
 519         if (SOLISTENING(so)) {
 520                 error = EOPNOTSUPP;
 521                 goto out;
 522         }
 523         NET_EPOCH_ENTER(et);
 524         if ((error = tcp_connect(tp, sinp, td)) != 0)
 525                 goto out_in_epoch;
 526 #ifdef TCP_OFFLOAD
 527         if (registered_toedevs > 0 &&
 528             (so->so_options & SO_NO_OFFLOAD) == 0 &&
 529             (error = tcp_offload_connect(so, nam)) == 0)
 530                 goto out_in_epoch;
 531 #endif
 532         tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
 533         error = tcp_output(tp);
 534         KASSERT(error >= 0, ("TCP stack %s requested tcp_drop(%p) at connect()"
 535             ", error code %d", tp->t_fb->tfb_tcp_block_name, tp, -error));
 536 out_in_epoch:
 537         NET_EPOCH_EXIT(et);
 538 out:
 539         tcp_bblog_pru(tp, PRU_CONNECT, error);
 540         TCP_PROBE2(debug__user, tp, PRU_CONNECT);
 541         INP_WUNLOCK(inp);
 542         return (error);
 543 }
 544 #endif /* INET */
 545
 546 #ifdef INET6
 547 static int
 548 tcp6_usr_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
 549 {
 550         struct epoch_tracker et;
 551         int error = 0;
 552         struct inpcb *inp;
 553         struct tcpcb *tp;
 554         struct sockaddr_in6 *sin6;
 555         u_int8_t incflagsav;
 556         u_char vflagsav;
 557
 558         inp = sotoinpcb(so);
 559         KASSERT(inp != NULL, ("tcp6_usr_connect: inp == NULL"));
 560         INP_WLOCK(inp);
 561         if (inp->inp_flags & INP_DROPPED) {
 562                 INP_WUNLOCK(inp);
 563                 return (ECONNREFUSED);
 564         }
 565         tp = intotcpcb(inp);
 566
 567         vflagsav = inp->inp_vflag;
 568         incflagsav = inp->inp_inc.inc_flags;
 569
 570         sin6 = (struct sockaddr_in6 *)nam;
 571         if (nam->sa_family != AF_INET6) {
 572                 error = EAFNOSUPPORT;
 573                 goto out;
 574         }
 575         if (nam->sa_len != sizeof (*sin6)) {
 576                 error = EINVAL;
 577                 goto out;
 578         }
 579         /*
 580          * Must disallow TCP ``connections'' to multicast addresses.
 581          */
 582         if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
 583                 error = EAFNOSUPPORT;
 584                 goto out;
 585         }
 586         if (SOLISTENING(so)) {
 587                 error = EINVAL;
 588                 goto out;
 589         }
 590 #ifdef INET
 591         /*
 592          * XXXRW: Some confusion: V4/V6 flags relate to binding, and
 593          * therefore probably require the hash lock, which isn't held here.
 594          * Is this a significant problem?
 595          */
 596         if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
 597                 struct sockaddr_in sin;
 598
 599                 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0) {
 600                         error = EINVAL;
 601                         goto out;
 602                 }
 603                 if ((inp->inp_vflag & INP_IPV4) == 0) {
 604                         error = EAFNOSUPPORT;
 605                         goto out;
 606                 }
 607
 608                 in6_sin6_2_sin(&sin, sin6);
 609                 if (IN_MULTICAST(ntohl(sin.sin_addr.s_addr))) {
 610                         error = EAFNOSUPPORT;
 611                         goto out;
 612                 }
 613                 if (ntohl(sin.sin_addr.s_addr) == INADDR_BROADCAST) {
 614                         error = EACCES;
 615                         goto out;
 616                 }
 617                 if ((error = prison_remote_ip4(td->td_ucred,
 618                     &sin.sin_addr)) != 0)
 619                         goto out;
 620                 inp->inp_vflag |= INP_IPV4;
 621                 inp->inp_vflag &= ~INP_IPV6;
 622                 NET_EPOCH_ENTER(et);
 623                 if ((error = tcp_connect(tp, &sin, td)) != 0)
 624                         goto out_in_epoch;
 625 #ifdef TCP_OFFLOAD
 626                 if (registered_toedevs > 0 &&
 627                     (so->so_options & SO_NO_OFFLOAD) == 0 &&
 628                     (error = tcp_offload_connect(so, nam)) == 0)
 629                         goto out_in_epoch;
 630 #endif
 631                 error = tcp_output(tp);
 632                 goto out_in_epoch;
 633         } else {
 634                 if ((inp->inp_vflag & INP_IPV6) == 0) {
 635                         error = EAFNOSUPPORT;
 636                         goto out;
 637                 }
 638         }
 639 #endif
 640         if ((error = prison_remote_ip6(td->td_ucred, &sin6->sin6_addr)) != 0)
 641                 goto out;
 642         inp->inp_vflag &= ~INP_IPV4;
 643         inp->inp_vflag |= INP_IPV6;
 644         inp->inp_inc.inc_flags |= INC_ISIPV6;
 645         NET_EPOCH_ENTER(et);
 646         if ((error = tcp6_connect(tp, sin6, td)) != 0)
 647                 goto out_in_epoch;
 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_in_epoch;
 653 #endif
 654         tcp_timer_activate(tp, TT_KEEP, TP_KEEPINIT(tp));
 655         error = tcp_output(tp);
 656 out_in_epoch:
 657         NET_EPOCH_EXIT(et);
 658 out:
 659         KASSERT(error >= 0, ("TCP stack %s requested tcp_drop(%p) at connect()"
 660             ", error code %d", tp->t_fb->tfb_tcp_block_name, tp, -error));
 661         /*
 662          * If the implicit bind in the connect call fails, restore
 663          * the flags we modified.
 664          */
 665         if (error != 0 && inp->inp_lport == 0) {
 666                 inp->inp_vflag = vflagsav;
 667                 inp->inp_inc.inc_flags = incflagsav;
 668         }
 669
 670         tcp_bblog_pru(tp, PRU_CONNECT, error);
 671         TCP_PROBE2(debug__user, tp, PRU_CONNECT);
 672         INP_WUNLOCK(inp);
 673         return (error);
 674 }
 675 #endif /* INET6 */
 676
 677 /*
 678  * Initiate disconnect from peer.
 679  * If connection never passed embryonic stage, just drop;
 680  * else if don't need to let data drain, then can just drop anyways,
 681  * else have to begin TCP shutdown process: mark socket disconnecting,
 682  * drain unread data, state switch to reflect user close, and
 683  * send segment (e.g. FIN) to peer.  Socket will be really disconnected
 684  * when peer sends FIN and acks ours.
 685  *
 686  * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
 687  */
 688 static int
 689 tcp_usr_disconnect(struct socket *so)
 690 {
 691         struct inpcb *inp;
 692         struct tcpcb *tp = NULL;
 693         struct epoch_tracker et;
 694         int error = 0;
 695
 696         NET_EPOCH_ENTER(et);
 697         inp = sotoinpcb(so);
 698         KASSERT(inp != NULL, ("tcp_usr_disconnect: inp == NULL"));
 699         INP_WLOCK(inp);
 700         if (inp->inp_flags & INP_DROPPED) {
 701                 INP_WUNLOCK(inp);
 702                 NET_EPOCH_EXIT(et);
 703                 return (ECONNRESET);
 704         }
 705         tp = intotcpcb(inp);
 706
 707         if (tp->t_state == TCPS_TIME_WAIT)
 708                 goto out;
 709         tcp_disconnect(tp);
 710 out:
 711         tcp_bblog_pru(tp, PRU_DISCONNECT, error);
 712         TCP_PROBE2(debug__user, tp, PRU_DISCONNECT);
 713         INP_WUNLOCK(inp);
 714         NET_EPOCH_EXIT(et);
 715         return (error);
 716 }
 717
 718 #ifdef INET
 719 /*
 720  * Accept a connection.  Essentially all the work is done at higher levels;
 721  * just return the address of the peer, storing through addr.
 722  */
 723 static int
 724 tcp_usr_accept(struct socket *so, struct sockaddr **nam)
 725 {
 726         int error = 0;
 727         struct inpcb *inp;
 728         struct tcpcb *tp;
 729         struct in_addr addr;
 730         in_port_t port = 0;
 731
 732         inp = sotoinpcb(so);
 733         KASSERT(inp != NULL, ("tcp_usr_accept: inp == NULL"));
 734         INP_WLOCK(inp);
 735         if (inp->inp_flags & INP_DROPPED) {
 736                 INP_WUNLOCK(inp);
 737                 return (ECONNABORTED);
 738         }
 739         tp = intotcpcb(inp);
 740
 741         if (so->so_state & SS_ISDISCONNECTED) {
 742                 error = ECONNABORTED;
 743                 goto out;
 744         }
 745         /*
 746          * We inline in_getpeeraddr and COMMON_END here, so that we can
 747          * copy the data of interest and defer the malloc until after we
 748          * release the lock.
 749          */
 750         port = inp->inp_fport;
 751         addr = inp->inp_faddr;
 752
 753 out:
 754         tcp_bblog_pru(tp, PRU_ACCEPT, error);
 755         TCP_PROBE2(debug__user, tp, PRU_ACCEPT);
 756         INP_WUNLOCK(inp);
 757         if (error == 0)
 758                 *nam = in_sockaddr(port, &addr);
 759         return error;
 760 }
 761 #endif /* INET */
 762
 763 #ifdef INET6
 764 static int
 765 tcp6_usr_accept(struct socket *so, struct sockaddr **nam)
 766 {
 767         struct inpcb *inp;
 768         int error = 0;
 769         struct tcpcb *tp;
 770         struct in_addr addr;
 771         struct in6_addr addr6;
 772         struct epoch_tracker et;
 773         in_port_t port = 0;
 774         int v4 = 0;
 775
 776         inp = sotoinpcb(so);
 777         KASSERT(inp != NULL, ("tcp6_usr_accept: inp == NULL"));
 778         NET_EPOCH_ENTER(et); /* XXXMT Why is this needed? */
 779         INP_WLOCK(inp);
 780         if (inp->inp_flags & INP_DROPPED) {
 781                 INP_WUNLOCK(inp);
 782                 NET_EPOCH_EXIT(et);
 783                 return (ECONNABORTED);
 784         }
 785         tp = intotcpcb(inp);
 786
 787         if (so->so_state & SS_ISDISCONNECTED) {
 788                 error = ECONNABORTED;
 789                 goto out;
 790         }
 791         /*
 792          * We inline in6_mapped_peeraddr and COMMON_END here, so that we can
 793          * copy the data of interest and defer the malloc until after we
 794          * release the lock.
 795          */
 796         if (inp->inp_vflag & INP_IPV4) {
 797                 v4 = 1;
 798                 port = inp->inp_fport;
 799                 addr = inp->inp_faddr;
 800         } else {
 801                 port = inp->inp_fport;
 802                 addr6 = inp->in6p_faddr;
 803         }
 804
 805 out:
 806         tcp_bblog_pru(tp, PRU_ACCEPT, error);
 807         TCP_PROBE2(debug__user, tp, PRU_ACCEPT);
 808         INP_WUNLOCK(inp);
 809         NET_EPOCH_EXIT(et);
 810         if (error == 0) {
 811                 if (v4)
 812                         *nam = in6_v4mapsin6_sockaddr(port, &addr);
 813                 else
 814                         *nam = in6_sockaddr(port, &addr6);
 815         }
 816         return error;
 817 }
 818 #endif /* INET6 */
 819
 820 /*
 821  * Mark the connection as being incapable of further output.
 822  */
 823 static int
 824 tcp_usr_shutdown(struct socket *so)
 825 {
 826         int error = 0;
 827         struct inpcb *inp;
 828         struct tcpcb *tp;
 829         struct epoch_tracker et;
 830
 831         inp = sotoinpcb(so);
 832         KASSERT(inp != NULL, ("inp == NULL"));
 833         INP_WLOCK(inp);
 834         if (inp->inp_flags & INP_DROPPED) {
 835                 INP_WUNLOCK(inp);
 836                 return (ECONNRESET);
 837         }
 838         tp = intotcpcb(inp);
 839
 840         NET_EPOCH_ENTER(et);
 841         socantsendmore(so);
 842         tcp_usrclosed(tp);
 843         if (!(inp->inp_flags & INP_DROPPED))
 844                 error = tcp_output_nodrop(tp);
 845         tcp_bblog_pru(tp, PRU_SHUTDOWN, error);
 846         TCP_PROBE2(debug__user, tp, PRU_SHUTDOWN);
 847         error = tcp_unlock_or_drop(tp, error);
 848         NET_EPOCH_EXIT(et);
 849
 850         return (error);
 851 }
 852
 853 /*
 854  * After a receive, possibly send window update to peer.
 855  */
 856 static int
 857 tcp_usr_rcvd(struct socket *so, int flags)
 858 {
 859         struct epoch_tracker et;
 860         struct inpcb *inp;
 861         struct tcpcb *tp;
 862         int outrv = 0, error = 0;
 863
 864         inp = sotoinpcb(so);
 865         KASSERT(inp != NULL, ("tcp_usr_rcvd: inp == NULL"));
 866         INP_WLOCK(inp);
 867         if (inp->inp_flags & INP_DROPPED) {
 868                 INP_WUNLOCK(inp);
 869                 return (ECONNRESET);
 870         }
 871         tp = intotcpcb(inp);
 872
 873         NET_EPOCH_ENTER(et);
 874         /*
 875          * For passively-created TFO connections, don't attempt a window
 876          * update while still in SYN_RECEIVED as this may trigger an early
 877          * SYN|ACK.  It is preferable to have the SYN|ACK be sent along with
 878          * application response data, or failing that, when the DELACK timer
 879          * expires.
 880          */
 881         if (IS_FASTOPEN(tp->t_flags) &&
 882             (tp->t_state == TCPS_SYN_RECEIVED))
 883                 goto out;
 884 #ifdef TCP_OFFLOAD
 885         if (tp->t_flags & TF_TOE)
 886                 tcp_offload_rcvd(tp);
 887         else
 888 #endif
 889                 outrv = tcp_output_nodrop(tp);
 890 out:
 891         tcp_bblog_pru(tp, PRU_RCVD, error);
 892         TCP_PROBE2(debug__user, tp, PRU_RCVD);
 893         (void) tcp_unlock_or_drop(tp, outrv);
 894         NET_EPOCH_EXIT(et);
 895         return (error);
 896 }
 897
 898 /*
 899  * Do a send by putting data in output queue and updating urgent
 900  * marker if URG set.  Possibly send more data.  Unlike the other
 901  * pru_*() routines, the mbuf chains are our responsibility.  We
 902  * must either enqueue them or free them.  The other pru_* routines
 903  * generally are caller-frees.
 904  */
 905 static int
 906 tcp_usr_send(struct socket *so, int flags, struct mbuf *m,
 907     struct sockaddr *nam, struct mbuf *control, struct thread *td)
 908 {
 909         struct epoch_tracker et;
 910         int error = 0;
 911         struct inpcb *inp;
 912         struct tcpcb *tp;
 913 #ifdef INET
 914 #ifdef INET6
 915         struct sockaddr_in sin;
 916 #endif
 917         struct sockaddr_in *sinp;
 918 #endif
 919 #ifdef INET6
 920         struct sockaddr_in6 *sin6;
 921         int isipv6;
 922 #endif
 923         u_int8_t incflagsav;
 924         u_char vflagsav;
 925         bool restoreflags;
 926
 927         inp = sotoinpcb(so);
 928         KASSERT(inp != NULL, ("tcp_usr_send: inp == NULL"));
 929         INP_WLOCK(inp);
 930         if (inp->inp_flags & INP_DROPPED) {
 931                 if (m != NULL && (flags & PRUS_NOTREADY) == 0)
 932                         m_freem(m);
 933                 INP_WUNLOCK(inp);
 934                 return (ECONNRESET);
 935         }
 936         tp = intotcpcb(inp);
 937
 938         vflagsav = inp->inp_vflag;
 939         incflagsav = inp->inp_inc.inc_flags;
 940         restoreflags = false;
 941
 942         NET_EPOCH_ENTER(et);
 943         if (control != NULL) {
 944                 /* TCP doesn't do control messages (rights, creds, etc) */
 945                 if (control->m_len > 0) {
 946                         m_freem(control);
 947                         error = EINVAL;
 948                         goto out;
 949                 }
 950                 m_freem(control);       /* empty control, just free it */
 951         }
 952
 953         if ((flags & PRUS_OOB) != 0 &&
 954             (error = tcp_pru_options_support(tp, PRUS_OOB)) != 0)
 955                 goto out;
 956
 957         if (nam != NULL && tp->t_state < TCPS_SYN_SENT) {
 958                 if (tp->t_state == TCPS_LISTEN) {
 959                         error = EINVAL;
 960                         goto out;
 961                 }
 962                 switch (nam->sa_family) {
 963 #ifdef INET
 964                 case AF_INET:
 965                         sinp = (struct sockaddr_in *)nam;
 966                         if (sinp->sin_len != sizeof(struct sockaddr_in)) {
 967                                 error = EINVAL;
 968                                 goto out;
 969                         }
 970                         if ((inp->inp_vflag & INP_IPV6) != 0) {
 971                                 error = EAFNOSUPPORT;
 972                                 goto out;
 973                         }
 974                         if (IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
 975                                 error = EAFNOSUPPORT;
 976                                 goto out;
 977                         }
 978                         if (ntohl(sinp->sin_addr.s_addr) == INADDR_BROADCAST) {
 979                                 error = EACCES;
 980                                 goto out;
 981                         }
 982                         if ((error = prison_remote_ip4(td->td_ucred,
 983                             &sinp->sin_addr)))
 984                                 goto out;
 985 #ifdef INET6
 986                         isipv6 = 0;
 987 #endif
 988                         break;
 989 #endif /* INET */
 990 #ifdef INET6
 991                 case AF_INET6:
 992                         sin6 = (struct sockaddr_in6 *)nam;
 993                         if (sin6->sin6_len != sizeof(*sin6)) {
 994                                 error = EINVAL;
 995                                 goto out;
 996                         }
 997                         if ((inp->inp_vflag & INP_IPV6PROTO) == 0) {
 998                                 error = EAFNOSUPPORT;
 999                                 goto out;
1000                         }
1001                         if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
1002                                 error = EAFNOSUPPORT;
1003                                 goto out;
1004                         }
1005                         if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
1006 #ifdef INET
1007                                 if ((inp->inp_flags & IN6P_IPV6_V6ONLY) != 0) {
1008                                         error = EINVAL;
1009                                         goto out;
1010                                 }
1011                                 if ((inp->inp_vflag & INP_IPV4) == 0) {
1012                                         error = EAFNOSUPPORT;
1013                                         goto out;
1014                                 }
1015                                 restoreflags = true;
1016                                 inp->inp_vflag &= ~INP_IPV6;
1017                                 sinp = &sin;
1018                                 in6_sin6_2_sin(sinp, sin6);
1019                                 if (IN_MULTICAST(
1020                                     ntohl(sinp->sin_addr.s_addr))) {
1021                                         error = EAFNOSUPPORT;
1022                                         goto out;
1023                                 }
1024                                 if ((error = prison_remote_ip4(td->td_ucred,
1025                                     &sinp->sin_addr)))
1026                                         goto out;
1027                                 isipv6 = 0;
1028 #else /* !INET */
1029                                 error = EAFNOSUPPORT;
1030                                 goto out;
1031 #endif /* INET */
1032                         } else {
1033                                 if ((inp->inp_vflag & INP_IPV6) == 0) {
1034                                         error = EAFNOSUPPORT;
1035                                         goto out;
1036                                 }
1037                                 restoreflags = true;
1038                                 inp->inp_vflag &= ~INP_IPV4;
1039                                 inp->inp_inc.inc_flags |= INC_ISIPV6;
1040                                 if ((error = prison_remote_ip6(td->td_ucred,
1041                                     &sin6->sin6_addr)))
1042                                         goto out;
1043                                 isipv6 = 1;
1044                         }
1045                         break;
1046 #endif /* INET6 */
1047                 default:
1048                         error = EAFNOSUPPORT;
1049                         goto out;
1050                 }
1051         }
1052         if (!(flags & PRUS_OOB)) {
1053                 if (tp->t_acktime == 0)
1054                         tp->t_acktime = ticks;
1055                 sbappendstream(&so->so_snd, m, flags);
1056                 m = NULL;
1057                 if (nam && tp->t_state < TCPS_SYN_SENT) {
1058                         KASSERT(tp->t_state == TCPS_CLOSED,
1059                             ("%s: tp %p is listening", __func__, tp));
1060
1061                         /*
1062                          * Do implied connect if not yet connected,
1063                          * initialize window to default value, and
1064                          * initialize maxseg using peer's cached MSS.
1065                          */
1066 #ifdef INET6
1067                         if (isipv6)
1068                                 error = tcp6_connect(tp, sin6, td);
1069 #endif /* INET6 */
1070 #if defined(INET6) && defined(INET)
1071                         else
1072 #endif
1073 #ifdef INET
1074                                 error = tcp_connect(tp, sinp, td);
1075 #endif
1076                         /*
1077                          * The bind operation in tcp_connect succeeded. We
1078                          * no longer want to restore the flags if later
1079                          * operations fail.
1080                          */
1081                         if (error == 0 || inp->inp_lport != 0)
1082                                 restoreflags = false;
1083
1084                         if (error) {
1085                                 /* m is freed if PRUS_NOTREADY is unset. */
1086                                 sbflush(&so->so_snd);
1087                                 goto out;
1088                         }
1089                         if (IS_FASTOPEN(tp->t_flags))
1090                                 tcp_fastopen_connect(tp);
1091                         else {
1092                                 tp->snd_wnd = TTCP_CLIENT_SND_WND;
1093                                 tcp_mss(tp, -1);
1094                         }
1095                 }
1096                 if (flags & PRUS_EOF) {
1097                         /*
1098                          * Close the send side of the connection after
1099                          * the data is sent.
1100                          */
1101                         socantsendmore(so);
1102                         tcp_usrclosed(tp);
1103                 }
1104                 if (TCPS_HAVEESTABLISHED(tp->t_state) &&
1105                     ((tp->t_flags2 & TF2_FBYTES_COMPLETE) == 0) &&
1106                     (tp->t_fbyte_out == 0) &&
1107                     (so->so_snd.sb_ccc > 0)) {
1108                         tp->t_fbyte_out = ticks;
1109                         if (tp->t_fbyte_out == 0)
1110                                 tp->t_fbyte_out = 1;
1111                         if (tp->t_fbyte_out && tp->t_fbyte_in)
1112                                 tp->t_flags2 |= TF2_FBYTES_COMPLETE;
1113                 }
1114                 if (!(inp->inp_flags & INP_DROPPED) &&
1115                     !(flags & PRUS_NOTREADY)) {
1116                         if (flags & PRUS_MORETOCOME)
1117                                 tp->t_flags |= TF_MORETOCOME;
1118                         error = tcp_output_nodrop(tp);
1119                         if (flags & PRUS_MORETOCOME)
1120                                 tp->t_flags &= ~TF_MORETOCOME;
1121                 }
1122         } else {
1123                 /*
1124                  * XXXRW: PRUS_EOF not implemented with PRUS_OOB?
1125                  */
1126                 SOCKBUF_LOCK(&so->so_snd);
1127                 if (sbspace(&so->so_snd) < -512) {
1128                         SOCKBUF_UNLOCK(&so->so_snd);
1129                         error = ENOBUFS;
1130                         goto out;
1131                 }
1132                 /*
1133                  * According to RFC961 (Assigned Protocols),
1134                  * the urgent pointer points to the last octet
1135                  * of urgent data.  We continue, however,
1136                  * to consider it to indicate the first octet
1137                  * of data past the urgent section.
1138                  * Otherwise, snd_up should be one lower.
1139                  */
1140                 if (tp->t_acktime == 0)
1141                         tp->t_acktime = ticks;
1142                 sbappendstream_locked(&so->so_snd, m, flags);
1143                 SOCKBUF_UNLOCK(&so->so_snd);
1144                 m = NULL;
1145                 if (nam && tp->t_state < TCPS_SYN_SENT) {
1146                         /*
1147                          * Do implied connect if not yet connected,
1148                          * initialize window to default value, and
1149                          * initialize maxseg using peer's cached MSS.
1150                          */
1151
1152                         /*
1153                          * Not going to contemplate SYN|URG
1154                          */
1155                         if (IS_FASTOPEN(tp->t_flags))
1156                                 tp->t_flags &= ~TF_FASTOPEN;
1157 #ifdef INET6
1158                         if (isipv6)
1159                                 error = tcp6_connect(tp, sin6, td);
1160 #endif /* INET6 */
1161 #if defined(INET6) && defined(INET)
1162                         else
1163 #endif
1164 #ifdef INET
1165                                 error = tcp_connect(tp, sinp, td);
1166 #endif
1167                         /*
1168                          * The bind operation in tcp_connect succeeded. We
1169                          * no longer want to restore the flags if later
1170                          * operations fail.
1171                          */
1172                         if (error == 0 || inp->inp_lport != 0)
1173                                 restoreflags = false;
1174
1175                         if (error != 0) {
1176                                 /* m is freed if PRUS_NOTREADY is unset. */
1177                                 sbflush(&so->so_snd);
1178                                 goto out;
1179                         }
1180                         tp->snd_wnd = TTCP_CLIENT_SND_WND;
1181                         tcp_mss(tp, -1);
1182                 }
1183                 tp->snd_up = tp->snd_una + sbavail(&so->so_snd);
1184                 if ((flags & PRUS_NOTREADY) == 0) {
1185                         tp->t_flags |= TF_FORCEDATA;
1186                         error = tcp_output_nodrop(tp);
1187                         tp->t_flags &= ~TF_FORCEDATA;
1188                 }
1189         }
1190         TCP_LOG_EVENT(tp, NULL,
1191             &inp->inp_socket->so_rcv,
1192             &inp->inp_socket->so_snd,
1193             TCP_LOG_USERSEND, error,
1194             0, NULL, false);
1195
1196 out:
1197         /*
1198          * In case of PRUS_NOTREADY, the caller or tcp_usr_ready() is
1199          * responsible for freeing memory.
1200          */
1201         if (m != NULL && (flags & PRUS_NOTREADY) == 0)
1202                 m_freem(m);
1203
1204         /*
1205          * If the request was unsuccessful and we changed flags,
1206          * restore the original flags.
1207          */
1208         if (error != 0 && restoreflags) {
1209                 inp->inp_vflag = vflagsav;
1210                 inp->inp_inc.inc_flags = incflagsav;
1211         }
1212         tcp_bblog_pru(tp, (flags & PRUS_OOB) ? PRU_SENDOOB :
1213                       ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND), error);
1214         TCP_PROBE2(debug__user, tp, (flags & PRUS_OOB) ? PRU_SENDOOB :
1215                    ((flags & PRUS_EOF) ? PRU_SEND_EOF : PRU_SEND));
1216         error = tcp_unlock_or_drop(tp, error);
1217         NET_EPOCH_EXIT(et);
1218         return (error);
1219 }
1220
1221 static int
1222 tcp_usr_ready(struct socket *so, struct mbuf *m, int count)
1223 {
1224         struct epoch_tracker et;
1225         struct inpcb *inp;
1226         struct tcpcb *tp;
1227         int error;
1228
1229         inp = sotoinpcb(so);
1230         INP_WLOCK(inp);
1231         if (inp->inp_flags & INP_DROPPED) {
1232                 INP_WUNLOCK(inp);
1233                 mb_free_notready(m, count);
1234                 return (ECONNRESET);
1235         }
1236         tp = intotcpcb(inp);
1237
1238         SOCKBUF_LOCK(&so->so_snd);
1239         error = sbready(&so->so_snd, m, count);
1240         SOCKBUF_UNLOCK(&so->so_snd);
1241         if (error) {
1242                 INP_WUNLOCK(inp);
1243                 return (error);
1244         }
1245         NET_EPOCH_ENTER(et);
1246         error = tcp_output_unlock(tp);
1247         NET_EPOCH_EXIT(et);
1248
1249         return (error);
1250 }
1251
1252 /*
1253  * Abort the TCP.  Drop the connection abruptly.
1254  */
1255 static void
1256 tcp_usr_abort(struct socket *so)
1257 {
1258         struct inpcb *inp;
1259         struct tcpcb *tp;
1260         struct epoch_tracker et;
1261
1262         inp = sotoinpcb(so);
1263         KASSERT(inp != NULL, ("tcp_usr_abort: inp == NULL"));
1264
1265         NET_EPOCH_ENTER(et);
1266         INP_WLOCK(inp);
1267         KASSERT(inp->inp_socket != NULL,
1268             ("tcp_usr_abort: inp_socket == NULL"));
1269
1270         /*
1271          * If we still have full TCP state, and we're not dropped, drop.
1272          */
1273         if (!(inp->inp_flags & INP_DROPPED)) {
1274                 tp = intotcpcb(inp);
1275                 tp = tcp_drop(tp, ECONNABORTED);
1276                 if (tp == NULL)
1277                         goto dropped;
1278                 tcp_bblog_pru(tp, PRU_ABORT, 0);
1279                 TCP_PROBE2(debug__user, tp, PRU_ABORT);
1280         }
1281         if (!(inp->inp_flags & INP_DROPPED)) {
1282                 soref(so);
1283                 inp->inp_flags |= INP_SOCKREF;
1284         }
1285         INP_WUNLOCK(inp);
1286 dropped:
1287         NET_EPOCH_EXIT(et);
1288 }
1289
1290 /*
1291  * TCP socket is closed.  Start friendly disconnect.
1292  */
1293 static void
1294 tcp_usr_close(struct socket *so)
1295 {
1296         struct inpcb *inp;
1297         struct tcpcb *tp;
1298         struct epoch_tracker et;
1299
1300         inp = sotoinpcb(so);
1301         KASSERT(inp != NULL, ("tcp_usr_close: inp == NULL"));
1302
1303         NET_EPOCH_ENTER(et);
1304         INP_WLOCK(inp);
1305         KASSERT(inp->inp_socket != NULL,
1306             ("tcp_usr_close: inp_socket == NULL"));
1307
1308         /*
1309          * If we are still connected and we're not dropped, initiate
1310          * a disconnect.
1311          */
1312         if (!(inp->inp_flags & INP_DROPPED)) {
1313                 tp = intotcpcb(inp);
1314                 if (tp->t_state != TCPS_TIME_WAIT) {
1315                         tp->t_flags |= TF_CLOSED;
1316                         tcp_disconnect(tp);
1317                         tcp_bblog_pru(tp, PRU_CLOSE, 0);
1318                         TCP_PROBE2(debug__user, tp, PRU_CLOSE);
1319                 }
1320         }
1321         if (!(inp->inp_flags & INP_DROPPED)) {
1322                 soref(so);
1323                 inp->inp_flags |= INP_SOCKREF;
1324         }
1325         INP_WUNLOCK(inp);
1326         NET_EPOCH_EXIT(et);
1327 }
1328
1329 static int
1330 tcp_pru_options_support(struct tcpcb *tp, int flags)
1331 {
1332         /*
1333          * If the specific TCP stack has a pru_options
1334          * specified then it does not always support
1335          * all the PRU_XX options and we must ask it.
1336          * If the function is not specified then all
1337          * of the PRU_XX options are supported.
1338          */
1339         int ret = 0;
1340
1341         if (tp->t_fb->tfb_pru_options) {
1342                 ret = (*tp->t_fb->tfb_pru_options)(tp, flags);
1343         }
1344         return (ret);
1345 }
1346
1347 /*
1348  * Receive out-of-band data.
1349  */
1350 static int
1351 tcp_usr_rcvoob(struct socket *so, struct mbuf *m, int flags)
1352 {
1353         int error = 0;
1354         struct inpcb *inp;
1355         struct tcpcb *tp;
1356
1357         inp = sotoinpcb(so);
1358         KASSERT(inp != NULL, ("tcp_usr_rcvoob: inp == NULL"));
1359         INP_WLOCK(inp);
1360         if (inp->inp_flags & INP_DROPPED) {
1361                 INP_WUNLOCK(inp);
1362                 return (ECONNRESET);
1363         }
1364         tp = intotcpcb(inp);
1365
1366         error = tcp_pru_options_support(tp, PRUS_OOB);
1367         if (error) {
1368                 goto out;
1369         }
1370         if ((so->so_oobmark == 0 &&
1371              (so->so_rcv.sb_state & SBS_RCVATMARK) == 0) ||
1372             so->so_options & SO_OOBINLINE ||
1373             tp->t_oobflags & TCPOOB_HADDATA) {
1374                 error = EINVAL;
1375                 goto out;
1376         }
1377         if ((tp->t_oobflags & TCPOOB_HAVEDATA) == 0) {
1378                 error = EWOULDBLOCK;
1379                 goto out;
1380         }
1381         m->m_len = 1;
1382         *mtod(m, caddr_t) = tp->t_iobc;
1383         if ((flags & MSG_PEEK) == 0)
1384                 tp->t_oobflags ^= (TCPOOB_HAVEDATA | TCPOOB_HADDATA);
1385
1386 out:
1387         tcp_bblog_pru(tp, PRU_RCVOOB, error);
1388         TCP_PROBE2(debug__user, tp, PRU_RCVOOB);
1389         INP_WUNLOCK(inp);
1390         return (error);
1391 }
1392
1393 #ifdef INET
1394 struct protosw tcp_protosw = {
1395         .pr_type =              SOCK_STREAM,
1396         .pr_protocol =          IPPROTO_TCP,
1397         .pr_flags =             PR_CONNREQUIRED | PR_IMPLOPCL | PR_WANTRCVD |
1398                                     PR_CAPATTACH,
1399         .pr_ctloutput =         tcp_ctloutput,
1400         .pr_abort =             tcp_usr_abort,
1401         .pr_accept =            tcp_usr_accept,
1402         .pr_attach =            tcp_usr_attach,
1403         .pr_bind =              tcp_usr_bind,
1404         .pr_connect =           tcp_usr_connect,
1405         .pr_control =           in_control,
1406         .pr_detach =            tcp_usr_detach,
1407         .pr_disconnect =        tcp_usr_disconnect,
1408         .pr_listen =            tcp_usr_listen,
1409         .pr_peeraddr =          in_getpeeraddr,
1410         .pr_rcvd =              tcp_usr_rcvd,
1411         .pr_rcvoob =            tcp_usr_rcvoob,
1412         .pr_send =              tcp_usr_send,
1413         .pr_ready =             tcp_usr_ready,
1414         .pr_shutdown =          tcp_usr_shutdown,
1415         .pr_sockaddr =          in_getsockaddr,
1416         .pr_sosetlabel =        in_pcbsosetlabel,
1417         .pr_close =             tcp_usr_close,
1418 };
1419 #endif /* INET */
1420
1421 #ifdef INET6
1422 struct protosw tcp6_protosw = {
1423         .pr_type =              SOCK_STREAM,
1424         .pr_protocol =          IPPROTO_TCP,
1425         .pr_flags =             PR_CONNREQUIRED | PR_IMPLOPCL |PR_WANTRCVD |
1426                                     PR_CAPATTACH,
1427         .pr_ctloutput =         tcp_ctloutput,
1428         .pr_abort =             tcp_usr_abort,
1429         .pr_accept =            tcp6_usr_accept,
1430         .pr_attach =            tcp_usr_attach,
1431         .pr_bind =              tcp6_usr_bind,
1432         .pr_connect =           tcp6_usr_connect,
1433         .pr_control =           in6_control,
1434         .pr_detach =            tcp_usr_detach,
1435         .pr_disconnect =        tcp_usr_disconnect,
1436         .pr_listen =            tcp6_usr_listen,
1437         .pr_peeraddr =          in6_mapped_peeraddr,
1438         .pr_rcvd =              tcp_usr_rcvd,
1439         .pr_rcvoob =            tcp_usr_rcvoob,
1440         .pr_send =              tcp_usr_send,
1441         .pr_ready =             tcp_usr_ready,
1442         .pr_shutdown =          tcp_usr_shutdown,
1443         .pr_sockaddr =          in6_mapped_sockaddr,
1444         .pr_sosetlabel =        in_pcbsosetlabel,
1445         .pr_close =             tcp_usr_close,
1446 };
1447 #endif /* INET6 */
1448
1449 #ifdef INET
1450 /*
1451  * Common subroutine to open a TCP connection to remote host specified
1452  * by struct sockaddr_in.  Call in_pcbconnect() to choose local host address
1453  * and assign a local port number and install the inpcb into the hash.
1454  * Initialize connection parameters and enter SYN-SENT state.
1455  */
1456 static int
1457 tcp_connect(struct tcpcb *tp, struct sockaddr_in *sin, struct thread *td)
1458 {
1459         struct inpcb *inp = tptoinpcb(tp);
1460         struct socket *so = tptosocket(tp);
1461         int error;
1462
1463         NET_EPOCH_ASSERT();
1464         INP_WLOCK_ASSERT(inp);
1465
1466         if (__predict_false((so->so_state &
1467             (SS_ISCONNECTING | SS_ISCONNECTED | SS_ISDISCONNECTING |
1468             SS_ISDISCONNECTED)) != 0))
1469                 return (EISCONN);
1470
1471         INP_HASH_WLOCK(&V_tcbinfo);
1472         error = in_pcbconnect(inp, sin, td->td_ucred, true);
1473         INP_HASH_WUNLOCK(&V_tcbinfo);
1474         if (error != 0)
1475                 return (error);
1476
1477         /*
1478          * Compute window scaling to request:
1479          * Scale to fit into sweet spot.  See tcp_syncache.c.
1480          * XXX: This should move to tcp_output().
1481          */
1482         while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
1483             (TCP_MAXWIN << tp->request_r_scale) < sb_max)
1484                 tp->request_r_scale++;
1485
1486         soisconnecting(so);
1487         TCPSTAT_INC(tcps_connattempt);
1488         tcp_state_change(tp, TCPS_SYN_SENT);
1489         tp->iss = tcp_new_isn(&inp->inp_inc);
1490         if (tp->t_flags & TF_REQ_TSTMP)
1491                 tp->ts_offset = tcp_new_ts_offset(&inp->inp_inc);
1492         tcp_sendseqinit(tp);
1493
1494         return (0);
1495 }
1496 #endif /* INET */
1497
1498 #ifdef INET6
1499 static int
1500 tcp6_connect(struct tcpcb *tp, struct sockaddr_in6 *sin6, struct thread *td)
1501 {
1502         struct inpcb *inp = tptoinpcb(tp);
1503         struct socket *so = tptosocket(tp);
1504         int error;
1505
1506         NET_EPOCH_ASSERT();
1507         INP_WLOCK_ASSERT(inp);
1508
1509         if (__predict_false((so->so_state &
1510             (SS_ISCONNECTING | SS_ISCONNECTED)) != 0))
1511                 return (EISCONN);
1512
1513         INP_HASH_WLOCK(&V_tcbinfo);
1514         error = in6_pcbconnect(inp, sin6, td->td_ucred, true);
1515         INP_HASH_WUNLOCK(&V_tcbinfo);
1516         if (error != 0)
1517                 return (error);
1518
1519         /* Compute window scaling to request.  */
1520         while (tp->request_r_scale < TCP_MAX_WINSHIFT &&
1521             (TCP_MAXWIN << tp->request_r_scale) < sb_max)
1522                 tp->request_r_scale++;
1523
1524         soisconnecting(so);
1525         TCPSTAT_INC(tcps_connattempt);
1526         tcp_state_change(tp, TCPS_SYN_SENT);
1527         tp->iss = tcp_new_isn(&inp->inp_inc);
1528         if (tp->t_flags & TF_REQ_TSTMP)
1529                 tp->ts_offset = tcp_new_ts_offset(&inp->inp_inc);
1530         tcp_sendseqinit(tp);
1531
1532         return (0);
1533 }
1534 #endif /* INET6 */
1535
1536 /*
1537  * Export TCP internal state information via a struct tcp_info, based on the
1538  * Linux 2.6 API.  Not ABI compatible as our constants are mapped differently
1539  * (TCP state machine, etc).  We export all information using FreeBSD-native
1540  * constants -- for example, the numeric values for tcpi_state will differ
1541  * from Linux.
1542  */
1543 static void
1544 tcp_fill_info(struct tcpcb *tp, struct tcp_info *ti)
1545 {
1546
1547         INP_WLOCK_ASSERT(tptoinpcb(tp));
1548         bzero(ti, sizeof(*ti));
1549
1550         ti->tcpi_state = tp->t_state;
1551         if ((tp->t_flags & TF_REQ_TSTMP) && (tp->t_flags & TF_RCVD_TSTMP))
1552                 ti->tcpi_options |= TCPI_OPT_TIMESTAMPS;
1553         if (tp->t_flags & TF_SACK_PERMIT)
1554                 ti->tcpi_options |= TCPI_OPT_SACK;
1555         if ((tp->t_flags & TF_REQ_SCALE) && (tp->t_flags & TF_RCVD_SCALE)) {
1556                 ti->tcpi_options |= TCPI_OPT_WSCALE;
1557                 ti->tcpi_snd_wscale = tp->snd_scale;
1558                 ti->tcpi_rcv_wscale = tp->rcv_scale;
1559         }
1560         switch (tp->t_flags2 & (TF2_ECN_PERMIT | TF2_ACE_PERMIT)) {
1561                 case TF2_ECN_PERMIT:
1562                         ti->tcpi_options |= TCPI_OPT_ECN;
1563                         break;
1564                 case TF2_ACE_PERMIT:
1565                         /* FALLTHROUGH */
1566                 case TF2_ECN_PERMIT | TF2_ACE_PERMIT:
1567                         ti->tcpi_options |= TCPI_OPT_ACE;
1568                         break;
1569                 default:
1570                         break;
1571         }
1572         if (IS_FASTOPEN(tp->t_flags))
1573                 ti->tcpi_options |= TCPI_OPT_TFO;
1574
1575         ti->tcpi_rto = tp->t_rxtcur * tick;
1576         ti->tcpi_last_data_recv = ((uint32_t)ticks - tp->t_rcvtime) * tick;
1577         ti->tcpi_rtt = ((u_int64_t)tp->t_srtt * tick) >> TCP_RTT_SHIFT;
1578         ti->tcpi_rttvar = ((u_int64_t)tp->t_rttvar * tick) >> TCP_RTTVAR_SHIFT;
1579
1580         ti->tcpi_snd_ssthresh = tp->snd_ssthresh;
1581         ti->tcpi_snd_cwnd = tp->snd_cwnd;
1582
1583         /*
1584          * FreeBSD-specific extension fields for tcp_info.
1585          */
1586         ti->tcpi_rcv_space = tp->rcv_wnd;
1587         ti->tcpi_rcv_nxt = tp->rcv_nxt;
1588         ti->tcpi_snd_wnd = tp->snd_wnd;
1589         ti->tcpi_snd_bwnd = 0;          /* Unused, kept for compat. */
1590         ti->tcpi_snd_nxt = tp->snd_nxt;
1591         ti->tcpi_snd_mss = tp->t_maxseg;
1592         ti->tcpi_rcv_mss = tp->t_maxseg;
1593         ti->tcpi_snd_rexmitpack = tp->t_sndrexmitpack;
1594         ti->tcpi_rcv_ooopack = tp->t_rcvoopack;
1595         ti->tcpi_snd_zerowin = tp->t_sndzerowin;
1596 #ifdef TCP_OFFLOAD
1597         if (tp->t_flags & TF_TOE) {
1598                 ti->tcpi_options |= TCPI_OPT_TOE;
1599                 tcp_offload_tcp_info(tp, ti);
1600         }
1601 #endif
1602         /*
1603          * AccECN related counters.
1604          */
1605         if ((tp->t_flags2 & (TF2_ECN_PERMIT | TF2_ACE_PERMIT)) ==
1606             (TF2_ECN_PERMIT | TF2_ACE_PERMIT))
1607                 /*
1608                  * Internal counter starts at 5 for AccECN
1609                  * but 0 for RFC3168 ECN.
1610                  */
1611                 ti->tcpi_delivered_ce = tp->t_scep - 5;
1612         else
1613                 ti->tcpi_delivered_ce = tp->t_scep;
1614         ti->tcpi_received_ce = tp->t_rcep;
1615 }
1616
1617 /*
1618  * tcp_ctloutput() must drop the inpcb lock before performing copyin on
1619  * socket option arguments.  When it re-acquires the lock after the copy, it
1620  * has to revalidate that the connection is still valid for the socket
1621  * option.
1622  */
1623 #define INP_WLOCK_RECHECK_CLEANUP(inp, cleanup) do {                    \
1624         INP_WLOCK(inp);                                                 \
1625         if (inp->inp_flags & INP_DROPPED) {                             \
1626                 INP_WUNLOCK(inp);                                       \
1627                 cleanup;                                                \
1628                 return (ECONNRESET);                                    \
1629         }                                                               \
1630         tp = intotcpcb(inp);                                            \
1631 } while(0)
1632 #define INP_WLOCK_RECHECK(inp) INP_WLOCK_RECHECK_CLEANUP((inp), /* noop */)
1633
1634 int
1635 tcp_ctloutput_set(struct inpcb *inp, struct sockopt *sopt)
1636 {
1637         struct socket *so = inp->inp_socket;
1638         struct tcpcb *tp = intotcpcb(inp);
1639         int error = 0;
1640
1641         MPASS(sopt->sopt_dir == SOPT_SET);
1642         INP_WLOCK_ASSERT(inp);
1643         KASSERT((inp->inp_flags & INP_DROPPED) == 0,
1644             ("inp_flags == %x", inp->inp_flags));
1645         KASSERT(so != NULL, ("inp_socket == NULL"));
1646
1647         if (sopt->sopt_level != IPPROTO_TCP) {
1648                 INP_WUNLOCK(inp);
1649 #ifdef INET6
1650                 if (inp->inp_vflag & INP_IPV6PROTO)
1651                         error = ip6_ctloutput(so, sopt);
1652 #endif
1653 #if defined(INET6) && defined(INET)
1654                 else
1655 #endif
1656 #ifdef INET
1657                         error = ip_ctloutput(so, sopt);
1658 #endif
1659                 /*
1660                  * When an IP-level socket option affects TCP, pass control
1661                  * down to stack tfb_tcp_ctloutput, otherwise return what
1662                  * IP level returned.
1663                  */
1664                 switch (sopt->sopt_level) {
1665 #ifdef INET6
1666                 case IPPROTO_IPV6:
1667                         if ((inp->inp_vflag & INP_IPV6PROTO) == 0)
1668                                 return (error);
1669                         switch (sopt->sopt_name) {
1670                         case IPV6_TCLASS:
1671                                 /* Notify tcp stacks that care (e.g. RACK). */
1672                                 break;
1673                         case IPV6_USE_MIN_MTU:
1674                                 /* Update t_maxseg accordingly. */
1675                                 break;
1676                         default:
1677                                 return (error);
1678                         }
1679                         break;
1680 #endif
1681 #ifdef INET
1682                 case IPPROTO_IP:
1683                         switch (sopt->sopt_name) {
1684                         case IP_TOS:
1685                                 inp->inp_ip_tos &= ~IPTOS_ECN_MASK;
1686                                 break;
1687                         case IP_TTL:
1688                                 /* Notify tcp stacks that care (e.g. RACK). */
1689                                 break;
1690                         default:
1691                                 return (error);
1692                         }
1693                         break;
1694 #endif
1695                 default:
1696                         return (error);
1697                 }
1698                 INP_WLOCK(inp);
1699                 if (inp->inp_flags & INP_DROPPED) {
1700                         INP_WUNLOCK(inp);
1701                         return (ECONNRESET);
1702                 }
1703         } else if (sopt->sopt_name == TCP_FUNCTION_BLK) {
1704                 /*
1705                  * Protect the TCP option TCP_FUNCTION_BLK so
1706                  * that a sub-function can *never* overwrite this.
1707                  */
1708                 struct tcp_function_set fsn;
1709                 struct tcp_function_block *blk;
1710                 void *ptr = NULL;
1711
1712                 INP_WUNLOCK(inp);
1713                 error = sooptcopyin(sopt, &fsn, sizeof fsn, sizeof fsn);
1714                 if (error)
1715                         return (error);
1716
1717                 INP_WLOCK(inp);
1718                 tp = intotcpcb(inp);
1719
1720                 blk = find_and_ref_tcp_functions(&fsn);
1721                 if (blk == NULL) {
1722                         INP_WUNLOCK(inp);
1723                         return (ENOENT);
1724                 }
1725                 if (tp->t_fb == blk) {
1726                         /* You already have this */
1727                         refcount_release(&blk->tfb_refcnt);
1728                         INP_WUNLOCK(inp);
1729                         return (0);
1730                 }
1731                 if (tp->t_state != TCPS_CLOSED) {
1732                         /*
1733                          * The user has advanced the state
1734                          * past the initial point, we may not
1735                          * be able to switch.
1736                          */
1737                         if (blk->tfb_tcp_handoff_ok != NULL) {
1738                                 /*
1739                                  * Does the stack provide a
1740                                  * query mechanism, if so it may
1741                                  * still be possible?
1742                                  */
1743                                 error = (*blk->tfb_tcp_handoff_ok)(tp);
1744                         } else
1745                                 error = EINVAL;
1746                         if (error) {
1747                                 refcount_release(&blk->tfb_refcnt);
1748                                 INP_WUNLOCK(inp);
1749                                 return(error);
1750                         }
1751                 }
1752                 if (blk->tfb_flags & TCP_FUNC_BEING_REMOVED) {
1753                         refcount_release(&blk->tfb_refcnt);
1754                         INP_WUNLOCK(inp);
1755                         return (ENOENT);
1756                 }
1757                 /*
1758                  * Ensure the new stack takes ownership with a
1759                  * clean slate on peak rate threshold.
1760                  */
1761 #ifdef TCPHPTS
1762                 /* Assure that we are not on any hpts */
1763                 tcp_hpts_remove(tp);
1764 #endif
1765                 if (blk->tfb_tcp_fb_init) {
1766                         error = (*blk->tfb_tcp_fb_init)(tp, &ptr);
1767                         if (error) {
1768                                 /*
1769                                  * Release the ref count the lookup
1770                                  * acquired.
1771                                  */
1772                                 refcount_release(&blk->tfb_refcnt);
1773                                 /*
1774                                  * Now there is a chance that the
1775                                  * init() function mucked with some
1776                                  * things before it failed, such as
1777                                  * hpts or inp_flags2 or timer granularity.
1778                                  * It should not of, but lets give the old
1779                                  * stack a chance to reset to a known good state.
1780                                  */
1781                                 if (tp->t_fb->tfb_switch_failed) {
1782                                         (*tp->t_fb->tfb_switch_failed)(tp);
1783                                 }
1784                                 goto err_out;
1785                         }
1786                 }
1787                 if (tp->t_fb->tfb_tcp_fb_fini) {
1788                         struct epoch_tracker et;
1789                         /*
1790                          * Tell the stack to cleanup with 0 i.e.
1791                          * the tcb is not going away.
1792                          */
1793                         NET_EPOCH_ENTER(et);
1794                         (*tp->t_fb->tfb_tcp_fb_fini)(tp, 0);
1795                         NET_EPOCH_EXIT(et);
1796                 }
1797                 /*
1798                  * Release the old refcnt, the
1799                  * lookup acquired a ref on the
1800                  * new one already.
1801                  */
1802                 refcount_release(&tp->t_fb->tfb_refcnt);
1803                 /*
1804                  * Set in the new stack.
1805                  */
1806                 tp->t_fb = blk;
1807                 tp->t_fb_ptr = ptr;
1808 #ifdef TCP_OFFLOAD
1809                 if (tp->t_flags & TF_TOE) {
1810                         tcp_offload_ctloutput(tp, sopt->sopt_dir,
1811                              sopt->sopt_name);
1812                 }
1813 #endif
1814 err_out:
1815                 INP_WUNLOCK(inp);
1816                 return (error);
1817
1818         }
1819
1820         /* Pass in the INP locked, callee must unlock it. */
1821         return (tp->t_fb->tfb_tcp_ctloutput(tp, sopt));
1822 }
1823
1824 static int
1825 tcp_ctloutput_get(struct inpcb *inp, struct sockopt *sopt)
1826 {
1827         struct socket *so = inp->inp_socket;
1828         struct tcpcb *tp = intotcpcb(inp);
1829         int error = 0;
1830
1831         MPASS(sopt->sopt_dir == SOPT_GET);
1832         INP_WLOCK_ASSERT(inp);
1833         KASSERT((inp->inp_flags & INP_DROPPED) == 0,
1834             ("inp_flags == %x", inp->inp_flags));
1835         KASSERT(so != NULL, ("inp_socket == NULL"));
1836
1837         if (sopt->sopt_level != IPPROTO_TCP) {
1838                 INP_WUNLOCK(inp);
1839 #ifdef INET6
1840                 if (inp->inp_vflag & INP_IPV6PROTO)
1841                         error = ip6_ctloutput(so, sopt);
1842 #endif /* INET6 */
1843 #if defined(INET6) && defined(INET)
1844                 else
1845 #endif
1846 #ifdef INET
1847                         error = ip_ctloutput(so, sopt);
1848 #endif
1849                 return (error);
1850         }
1851         if (((sopt->sopt_name == TCP_FUNCTION_BLK) ||
1852              (sopt->sopt_name == TCP_FUNCTION_ALIAS))) {
1853                 struct tcp_function_set fsn;
1854
1855                 if (sopt->sopt_name == TCP_FUNCTION_ALIAS) {
1856                         memset(&fsn, 0, sizeof(fsn));
1857                         find_tcp_function_alias(tp->t_fb, &fsn);
1858                 } else {
1859                         strncpy(fsn.function_set_name,
1860                             tp->t_fb->tfb_tcp_block_name,
1861                             TCP_FUNCTION_NAME_LEN_MAX);
1862                         fsn.function_set_name[TCP_FUNCTION_NAME_LEN_MAX - 1] = '\0';
1863                 }
1864                 fsn.pcbcnt = tp->t_fb->tfb_refcnt;
1865                 INP_WUNLOCK(inp);
1866                 error = sooptcopyout(sopt, &fsn, sizeof fsn);
1867                 return (error);
1868         }
1869
1870         /* Pass in the INP locked, callee must unlock it. */
1871         return (tp->t_fb->tfb_tcp_ctloutput(tp, sopt));
1872 }
1873
1874 int
1875 tcp_ctloutput(struct socket *so, struct sockopt *sopt)
1876 {
1877         struct  inpcb *inp;
1878
1879         inp = sotoinpcb(so);
1880         KASSERT(inp != NULL, ("tcp_ctloutput: inp == NULL"));
1881
1882         INP_WLOCK(inp);
1883         if (inp->inp_flags & INP_DROPPED) {
1884                 INP_WUNLOCK(inp);
1885                 return (ECONNRESET);
1886         }
1887         if (sopt->sopt_dir == SOPT_SET)
1888                 return (tcp_ctloutput_set(inp, sopt));
1889         else if (sopt->sopt_dir == SOPT_GET)
1890                 return (tcp_ctloutput_get(inp, sopt));
1891         else
1892                 panic("%s: sopt_dir $%d", __func__, sopt->sopt_dir);
1893 }
1894
1895 /*
1896  * If this assert becomes untrue, we need to change the size of the buf
1897  * variable in tcp_default_ctloutput().
1898  */
1899 #ifdef CTASSERT
1900 CTASSERT(TCP_CA_NAME_MAX <= TCP_LOG_ID_LEN);
1901 CTASSERT(TCP_LOG_REASON_LEN <= TCP_LOG_ID_LEN);
1902 #endif
1903
1904 #ifdef KERN_TLS
1905 static int
1906 copyin_tls_enable(struct sockopt *sopt, struct tls_enable *tls)
1907 {
1908         struct tls_enable_v0 tls_v0;
1909         int error;
1910
1911         if (sopt->sopt_valsize == sizeof(tls_v0)) {
1912                 error = sooptcopyin(sopt, &tls_v0, sizeof(tls_v0),
1913                     sizeof(tls_v0));
1914                 if (error)
1915                         return (error);
1916                 memset(tls, 0, sizeof(*tls));
1917                 tls->cipher_key = tls_v0.cipher_key;
1918                 tls->iv = tls_v0.iv;
1919                 tls->auth_key = tls_v0.auth_key;
1920                 tls->cipher_algorithm = tls_v0.cipher_algorithm;
1921                 tls->cipher_key_len = tls_v0.cipher_key_len;
1922                 tls->iv_len = tls_v0.iv_len;
1923                 tls->auth_algorithm = tls_v0.auth_algorithm;
1924                 tls->auth_key_len = tls_v0.auth_key_len;
1925                 tls->flags = tls_v0.flags;
1926                 tls->tls_vmajor = tls_v0.tls_vmajor;
1927                 tls->tls_vminor = tls_v0.tls_vminor;
1928                 return (0);
1929         }
1930
1931         return (sooptcopyin(sopt, tls, sizeof(*tls), sizeof(*tls)));
1932 }
1933 #endif
1934
1935 extern struct cc_algo newreno_cc_algo;
1936
1937 static int
1938 tcp_set_cc_mod(struct inpcb *inp, struct sockopt *sopt)
1939 {
1940         struct cc_algo *algo;
1941         void *ptr = NULL;
1942         struct tcpcb *tp;
1943         struct cc_var cc_mem;
1944         char    buf[TCP_CA_NAME_MAX];
1945         size_t mem_sz;
1946         int error;
1947
1948         INP_WUNLOCK(inp);
1949         error = sooptcopyin(sopt, buf, TCP_CA_NAME_MAX - 1, 1);
1950         if (error)
1951                 return(error);
1952         buf[sopt->sopt_valsize] = '\0';
1953         CC_LIST_RLOCK();
1954         STAILQ_FOREACH(algo, &cc_list, entries) {
1955                 if (strncmp(buf, algo->name,
1956                             TCP_CA_NAME_MAX) == 0) {
1957                         if (algo->flags & CC_MODULE_BEING_REMOVED) {
1958                                 /* We can't "see" modules being unloaded */
1959                                 continue;
1960                         }
1961                         break;
1962                 }
1963         }
1964         if (algo == NULL) {
1965                 CC_LIST_RUNLOCK();
1966                 return(ESRCH);
1967         }
1968         /*
1969          * With a reference the algorithm cannot be removed
1970          * so we hold a reference through the change process.
1971          */
1972         cc_refer(algo);
1973         CC_LIST_RUNLOCK();
1974         if (algo->cb_init != NULL) {
1975                 /* We can now pre-get the memory for the CC */
1976                 mem_sz = (*algo->cc_data_sz)();
1977                 if (mem_sz == 0) {
1978                         goto no_mem_needed;
1979                 }
1980                 ptr = malloc(mem_sz, M_CC_MEM, M_WAITOK);
1981         } else {
1982 no_mem_needed:
1983                 mem_sz = 0;
1984                 ptr = NULL;
1985         }
1986         /*
1987          * Make sure its all clean and zero and also get
1988          * back the inplock.
1989          */
1990         memset(&cc_mem, 0, sizeof(cc_mem));
1991         INP_WLOCK(inp);
1992         if (inp->inp_flags & INP_DROPPED) {
1993                 INP_WUNLOCK(inp);
1994                 if (ptr)
1995                         free(ptr, M_CC_MEM);
1996                 /* Release our temp reference */
1997                 CC_LIST_RLOCK();
1998                 cc_release(algo);
1999                 CC_LIST_RUNLOCK();
2000                 return (ECONNRESET);
2001         }
2002         tp = intotcpcb(inp);
2003         if (ptr != NULL)
2004                 memset(ptr, 0, mem_sz);
2005         cc_mem.ccvc.tcp = tp;
2006         /*
2007          * We once again hold a write lock over the tcb so it's
2008          * safe to do these things without ordering concerns.
2009          * Note here we init into stack memory.
2010          */
2011         if (algo->cb_init != NULL)
2012                 error = algo->cb_init(&cc_mem, ptr);
2013         else
2014                 error = 0;
2015         /*
2016          * The CC algorithms, when given their memory
2017          * should not fail we could in theory have a
2018          * KASSERT here.
2019          */
2020         if (error == 0) {
2021                 /*
2022                  * Touchdown, lets go ahead and move the
2023                  * connection to the new CC module by
2024                  * copying in the cc_mem after we call
2025                  * the old ones cleanup (if any).
2026                  */
2027                 if (CC_ALGO(tp)->cb_destroy != NULL)
2028                         CC_ALGO(tp)->cb_destroy(&tp->t_ccv);
2029                 /* Detach the old CC from the tcpcb  */
2030                 cc_detach(tp);
2031                 /* Copy in our temp memory that was inited */
2032                 memcpy(&tp->t_ccv, &cc_mem, sizeof(struct cc_var));
2033                 /* Now attach the new, which takes a reference */
2034                 cc_attach(tp, algo);
2035                 /* Ok now are we where we have gotten past any conn_init? */
2036                 if (TCPS_HAVEESTABLISHED(tp->t_state) && (CC_ALGO(tp)->conn_init != NULL)) {
2037                         /* Yep run the connection init for the new CC */
2038                         CC_ALGO(tp)->conn_init(&tp->t_ccv);
2039                 }
2040         } else if (ptr)
2041                 free(ptr, M_CC_MEM);
2042         INP_WUNLOCK(inp);
2043         /* Now lets release our temp reference */
2044         CC_LIST_RLOCK();
2045         cc_release(algo);
2046         CC_LIST_RUNLOCK();
2047         return (error);
2048 }
2049
2050 int
2051 tcp_default_ctloutput(struct tcpcb *tp, struct sockopt *sopt)
2052 {
2053         struct inpcb *inp = tptoinpcb(tp);
2054         int     error, opt, optval;
2055         u_int   ui;
2056         struct  tcp_info ti;
2057 #ifdef KERN_TLS
2058         struct tls_enable tls;
2059         struct socket *so = inp->inp_socket;
2060 #endif
2061         char    *pbuf, buf[TCP_LOG_ID_LEN];
2062 #ifdef STATS
2063         struct statsblob *sbp;
2064 #endif
2065         size_t  len;
2066
2067         INP_WLOCK_ASSERT(inp);
2068         KASSERT((inp->inp_flags & INP_DROPPED) == 0,
2069             ("inp_flags == %x", inp->inp_flags));
2070         KASSERT(inp->inp_socket != NULL, ("inp_socket == NULL"));
2071
2072         switch (sopt->sopt_level) {
2073 #ifdef INET6
2074         case IPPROTO_IPV6:
2075                 MPASS(inp->inp_vflag & INP_IPV6PROTO);
2076                 switch (sopt->sopt_name) {
2077                 case IPV6_USE_MIN_MTU:
2078                         tcp6_use_min_mtu(tp);
2079                         /* FALLTHROUGH */
2080                 }
2081                 INP_WUNLOCK(inp);
2082                 return (0);
2083 #endif
2084 #ifdef INET
2085         case IPPROTO_IP:
2086                 INP_WUNLOCK(inp);
2087                 return (0);
2088 #endif
2089         }
2090
2091         /*
2092          * For TCP_CCALGOOPT forward the control to CC module, for both
2093          * SOPT_SET and SOPT_GET.
2094          */
2095         switch (sopt->sopt_name) {
2096         case TCP_CCALGOOPT:
2097                 INP_WUNLOCK(inp);
2098                 if (sopt->sopt_valsize > CC_ALGOOPT_LIMIT)
2099                         return (EINVAL);
2100                 pbuf = malloc(sopt->sopt_valsize, M_TEMP, M_WAITOK | M_ZERO);
2101                 error = sooptcopyin(sopt, pbuf, sopt->sopt_valsize,
2102                     sopt->sopt_valsize);
2103                 if (error) {
2104                         free(pbuf, M_TEMP);
2105                         return (error);
2106                 }
2107                 INP_WLOCK_RECHECK_CLEANUP(inp, free(pbuf, M_TEMP));
2108                 if (CC_ALGO(tp)->ctl_output != NULL)
2109                         error = CC_ALGO(tp)->ctl_output(&tp->t_ccv, sopt, pbuf);
2110                 else
2111                         error = ENOENT;
2112                 INP_WUNLOCK(inp);
2113                 if (error == 0 && sopt->sopt_dir == SOPT_GET)
2114                         error = sooptcopyout(sopt, pbuf, sopt->sopt_valsize);
2115                 free(pbuf, M_TEMP);
2116                 return (error);
2117         }
2118
2119         switch (sopt->sopt_dir) {
2120         case SOPT_SET:
2121                 switch (sopt->sopt_name) {
2122 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
2123                 case TCP_MD5SIG:
2124                         INP_WUNLOCK(inp);
2125                         if (!TCPMD5_ENABLED())
2126                                 return (ENOPROTOOPT);
2127                         error = TCPMD5_PCBCTL(inp, sopt);
2128                         if (error)
2129                                 return (error);
2130                         INP_WLOCK_RECHECK(inp);
2131                         goto unlock_and_done;
2132 #endif /* IPSEC */
2133
2134                 case TCP_NODELAY:
2135                 case TCP_NOOPT:
2136                 case TCP_LRD:
2137                         INP_WUNLOCK(inp);
2138                         error = sooptcopyin(sopt, &optval, sizeof optval,
2139                             sizeof optval);
2140                         if (error)
2141                                 return (error);
2142
2143                         INP_WLOCK_RECHECK(inp);
2144                         switch (sopt->sopt_name) {
2145                         case TCP_NODELAY:
2146                                 opt = TF_NODELAY;
2147                                 break;
2148                         case TCP_NOOPT:
2149                                 opt = TF_NOOPT;
2150                                 break;
2151                         case TCP_LRD:
2152                                 opt = TF_LRD;
2153                                 break;
2154                         default:
2155                                 opt = 0; /* dead code to fool gcc */
2156                                 break;
2157                         }
2158
2159                         if (optval)
2160                                 tp->t_flags |= opt;
2161                         else
2162                                 tp->t_flags &= ~opt;
2163 unlock_and_done:
2164 #ifdef TCP_OFFLOAD
2165                         if (tp->t_flags & TF_TOE) {
2166                                 tcp_offload_ctloutput(tp, sopt->sopt_dir,
2167                                     sopt->sopt_name);
2168                         }
2169 #endif
2170                         INP_WUNLOCK(inp);
2171                         break;
2172
2173                 case TCP_NOPUSH:
2174                         INP_WUNLOCK(inp);
2175                         error = sooptcopyin(sopt, &optval, sizeof optval,
2176                             sizeof optval);
2177                         if (error)
2178                                 return (error);
2179
2180                         INP_WLOCK_RECHECK(inp);
2181                         if (optval)
2182                                 tp->t_flags |= TF_NOPUSH;
2183                         else if (tp->t_flags & TF_NOPUSH) {
2184                                 tp->t_flags &= ~TF_NOPUSH;
2185                                 if (TCPS_HAVEESTABLISHED(tp->t_state)) {
2186                                         struct epoch_tracker et;
2187
2188                                         NET_EPOCH_ENTER(et);
2189                                         error = tcp_output_nodrop(tp);
2190                                         NET_EPOCH_EXIT(et);
2191                                 }
2192                         }
2193                         goto unlock_and_done;
2194
2195                 case TCP_REMOTE_UDP_ENCAPS_PORT:
2196                         INP_WUNLOCK(inp);
2197                         error = sooptcopyin(sopt, &optval, sizeof optval,
2198                             sizeof optval);
2199                         if (error)
2200                                 return (error);
2201                         if ((optval < TCP_TUNNELING_PORT_MIN) ||
2202                             (optval > TCP_TUNNELING_PORT_MAX)) {
2203                                 /* Its got to be in range */
2204                                 return (EINVAL);
2205                         }
2206                         if ((V_tcp_udp_tunneling_port == 0) && (optval != 0)) {
2207                                 /* You have to have enabled a UDP tunneling port first */
2208                                 return (EINVAL);
2209                         }
2210                         INP_WLOCK_RECHECK(inp);
2211                         if (tp->t_state != TCPS_CLOSED) {
2212                                 /* You can't change after you are connected */
2213                                 error = EINVAL;
2214                         } else {
2215                                 /* Ok we are all good set the port */
2216                                 tp->t_port = htons(optval);
2217                         }
2218                         goto unlock_and_done;
2219
2220                 case TCP_MAXSEG:
2221                         INP_WUNLOCK(inp);
2222                         error = sooptcopyin(sopt, &optval, sizeof optval,
2223                             sizeof optval);
2224                         if (error)
2225                                 return (error);
2226
2227                         INP_WLOCK_RECHECK(inp);
2228                         if (optval > 0 && optval <= tp->t_maxseg &&
2229                             optval + 40 >= V_tcp_minmss)
2230                                 tp->t_maxseg = optval;
2231                         else
2232                                 error = EINVAL;
2233                         goto unlock_and_done;
2234
2235                 case TCP_INFO:
2236                         INP_WUNLOCK(inp);
2237                         error = EINVAL;
2238                         break;
2239
2240                 case TCP_STATS:
2241                         INP_WUNLOCK(inp);
2242 #ifdef STATS
2243                         error = sooptcopyin(sopt, &optval, sizeof optval,
2244                             sizeof optval);
2245                         if (error)
2246                                 return (error);
2247
2248                         if (optval > 0)
2249                                 sbp = stats_blob_alloc(
2250                                     V_tcp_perconn_stats_dflt_tpl, 0);
2251                         else
2252                                 sbp = NULL;
2253
2254                         INP_WLOCK_RECHECK(inp);
2255                         if ((tp->t_stats != NULL && sbp == NULL) ||
2256                             (tp->t_stats == NULL && sbp != NULL)) {
2257                                 struct statsblob *t = tp->t_stats;
2258                                 tp->t_stats = sbp;
2259                                 sbp = t;
2260                         }
2261                         INP_WUNLOCK(inp);
2262
2263                         stats_blob_destroy(sbp);
2264 #else
2265                         return (EOPNOTSUPP);
2266 #endif /* !STATS */
2267                         break;
2268
2269                 case TCP_CONGESTION:
2270                         error = tcp_set_cc_mod(inp, sopt);
2271                         break;
2272
2273                 case TCP_REUSPORT_LB_NUMA:
2274                         INP_WUNLOCK(inp);
2275                         error = sooptcopyin(sopt, &optval, sizeof(optval),
2276                             sizeof(optval));
2277                         INP_WLOCK_RECHECK(inp);
2278                         if (!error)
2279                                 error = in_pcblbgroup_numa(inp, optval);
2280                         INP_WUNLOCK(inp);
2281                         break;
2282
2283 #ifdef KERN_TLS
2284                 case TCP_TXTLS_ENABLE:
2285                         INP_WUNLOCK(inp);
2286                         error = copyin_tls_enable(sopt, &tls);
2287                         if (error)
2288                                 break;
2289                         error = ktls_enable_tx(so, &tls);
2290                         break;
2291                 case TCP_TXTLS_MODE:
2292                         INP_WUNLOCK(inp);
2293                         error = sooptcopyin(sopt, &ui, sizeof(ui), sizeof(ui));
2294                         if (error)
2295                                 return (error);
2296
2297                         INP_WLOCK_RECHECK(inp);
2298                         error = ktls_set_tx_mode(so, ui);
2299                         INP_WUNLOCK(inp);
2300                         break;
2301                 case TCP_RXTLS_ENABLE:
2302                         INP_WUNLOCK(inp);
2303                         error = sooptcopyin(sopt, &tls, sizeof(tls),
2304                             sizeof(tls));
2305                         if (error)
2306                                 break;
2307                         error = ktls_enable_rx(so, &tls);
2308                         break;
2309 #endif
2310                 case TCP_MAXUNACKTIME:
2311                 case TCP_KEEPIDLE:
2312                 case TCP_KEEPINTVL:
2313                 case TCP_KEEPINIT:
2314                         INP_WUNLOCK(inp);
2315                         error = sooptcopyin(sopt, &ui, sizeof(ui), sizeof(ui));
2316                         if (error)
2317                                 return (error);
2318
2319                         if (ui > (UINT_MAX / hz)) {
2320                                 error = EINVAL;
2321                                 break;
2322                         }
2323                         ui *= hz;
2324
2325                         INP_WLOCK_RECHECK(inp);
2326                         switch (sopt->sopt_name) {
2327                         case TCP_MAXUNACKTIME:
2328                                 tp->t_maxunacktime = ui;
2329                                 break;
2330
2331                         case TCP_KEEPIDLE:
2332                                 tp->t_keepidle = ui;
2333                                 /*
2334                                  * XXX: better check current remaining
2335                                  * timeout and "merge" it with new value.
2336                                  */
2337                                 if ((tp->t_state > TCPS_LISTEN) &&
2338                                     (tp->t_state <= TCPS_CLOSING))
2339                                         tcp_timer_activate(tp, TT_KEEP,
2340                                             TP_KEEPIDLE(tp));
2341                                 break;
2342                         case TCP_KEEPINTVL:
2343                                 tp->t_keepintvl = ui;
2344                                 if ((tp->t_state == TCPS_FIN_WAIT_2) &&
2345                                     (TP_MAXIDLE(tp) > 0))
2346                                         tcp_timer_activate(tp, TT_2MSL,
2347                                             TP_MAXIDLE(tp));
2348                                 break;
2349                         case TCP_KEEPINIT:
2350                                 tp->t_keepinit = ui;
2351                                 if (tp->t_state == TCPS_SYN_RECEIVED ||
2352                                     tp->t_state == TCPS_SYN_SENT)
2353                                         tcp_timer_activate(tp, TT_KEEP,
2354                                             TP_KEEPINIT(tp));
2355                                 break;
2356                         }
2357                         goto unlock_and_done;
2358
2359                 case TCP_KEEPCNT:
2360                         INP_WUNLOCK(inp);
2361                         error = sooptcopyin(sopt, &ui, sizeof(ui), sizeof(ui));
2362                         if (error)
2363                                 return (error);
2364
2365                         INP_WLOCK_RECHECK(inp);
2366                         tp->t_keepcnt = ui;
2367                         if ((tp->t_state == TCPS_FIN_WAIT_2) &&
2368                             (TP_MAXIDLE(tp) > 0))
2369                                 tcp_timer_activate(tp, TT_2MSL,
2370                                     TP_MAXIDLE(tp));
2371                         goto unlock_and_done;
2372
2373 #ifdef TCPPCAP
2374                 case TCP_PCAP_OUT:
2375                 case TCP_PCAP_IN:
2376                         INP_WUNLOCK(inp);
2377                         error = sooptcopyin(sopt, &optval, sizeof optval,
2378                             sizeof optval);
2379                         if (error)
2380                                 return (error);
2381
2382                         INP_WLOCK_RECHECK(inp);
2383                         if (optval >= 0)
2384                                 tcp_pcap_set_sock_max(
2385                                         (sopt->sopt_name == TCP_PCAP_OUT) ?
2386                                         &(tp->t_outpkts) : &(tp->t_inpkts),
2387                                         optval);
2388                         else
2389                                 error = EINVAL;
2390                         goto unlock_and_done;
2391 #endif
2392
2393                 case TCP_FASTOPEN: {
2394                         struct tcp_fastopen tfo_optval;
2395
2396                         INP_WUNLOCK(inp);
2397                         if (!V_tcp_fastopen_client_enable &&
2398                             !V_tcp_fastopen_server_enable)
2399                                 return (EPERM);
2400
2401                         error = sooptcopyin(sopt, &tfo_optval,
2402                                     sizeof(tfo_optval), sizeof(int));
2403                         if (error)
2404                                 return (error);
2405
2406                         INP_WLOCK_RECHECK(inp);
2407                         if ((tp->t_state != TCPS_CLOSED) &&
2408                             (tp->t_state != TCPS_LISTEN)) {
2409                                 error = EINVAL;
2410                                 goto unlock_and_done;
2411                         }
2412                         if (tfo_optval.enable) {
2413                                 if (tp->t_state == TCPS_LISTEN) {
2414                                         if (!V_tcp_fastopen_server_enable) {
2415                                                 error = EPERM;
2416                                                 goto unlock_and_done;
2417                                         }
2418
2419                                         if (tp->t_tfo_pending == NULL)
2420                                                 tp->t_tfo_pending =
2421                                                     tcp_fastopen_alloc_counter();
2422                                 } else {
2423                                         /*
2424                                          * If a pre-shared key was provided,
2425                                          * stash it in the client cookie
2426                                          * field of the tcpcb for use during
2427                                          * connect.
2428                                          */
2429                                         if (sopt->sopt_valsize ==
2430                                             sizeof(tfo_optval)) {
2431                                                 memcpy(tp->t_tfo_cookie.client,
2432                                                        tfo_optval.psk,
2433                                                        TCP_FASTOPEN_PSK_LEN);
2434                                                 tp->t_tfo_client_cookie_len =
2435                                                     TCP_FASTOPEN_PSK_LEN;
2436                                         }
2437                                 }
2438                                 tp->t_flags |= TF_FASTOPEN;
2439                         } else
2440                                 tp->t_flags &= ~TF_FASTOPEN;
2441                         goto unlock_and_done;
2442                 }
2443
2444 #ifdef TCP_BLACKBOX
2445                 case TCP_LOG:
2446                         INP_WUNLOCK(inp);
2447                         error = sooptcopyin(sopt, &optval, sizeof optval,
2448                             sizeof optval);
2449                         if (error)
2450                                 return (error);
2451
2452                         INP_WLOCK_RECHECK(inp);
2453                         error = tcp_log_state_change(tp, optval);
2454                         goto unlock_and_done;
2455
2456                 case TCP_LOGBUF:
2457                         INP_WUNLOCK(inp);
2458                         error = EINVAL;
2459                         break;
2460
2461                 case TCP_LOGID:
2462                         INP_WUNLOCK(inp);
2463                         error = sooptcopyin(sopt, buf, TCP_LOG_ID_LEN - 1, 0);
2464                         if (error)
2465                                 break;
2466                         buf[sopt->sopt_valsize] = '\0';
2467                         INP_WLOCK_RECHECK(inp);
2468                         error = tcp_log_set_id(tp, buf);
2469                         /* tcp_log_set_id() unlocks the INP. */
2470                         break;
2471
2472                 case TCP_LOGDUMP:
2473                 case TCP_LOGDUMPID:
2474                         INP_WUNLOCK(inp);
2475                         error =
2476                             sooptcopyin(sopt, buf, TCP_LOG_REASON_LEN - 1, 0);
2477                         if (error)
2478                                 break;
2479                         buf[sopt->sopt_valsize] = '\0';
2480                         INP_WLOCK_RECHECK(inp);
2481                         if (sopt->sopt_name == TCP_LOGDUMP) {
2482                                 error = tcp_log_dump_tp_logbuf(tp, buf,
2483                                     M_WAITOK, true);
2484                                 INP_WUNLOCK(inp);
2485                         } else {
2486                                 tcp_log_dump_tp_bucket_logbufs(tp, buf);
2487                                 /*
2488                                  * tcp_log_dump_tp_bucket_logbufs() drops the
2489                                  * INP lock.
2490                                  */
2491                         }
2492                         break;
2493 #endif
2494
2495                 default:
2496                         INP_WUNLOCK(inp);
2497                         error = ENOPROTOOPT;
2498                         break;
2499                 }
2500                 break;
2501
2502         case SOPT_GET:
2503                 tp = intotcpcb(inp);
2504                 switch (sopt->sopt_name) {
2505 #if defined(IPSEC_SUPPORT) || defined(TCP_SIGNATURE)
2506                 case TCP_MD5SIG:
2507                         INP_WUNLOCK(inp);
2508                         if (!TCPMD5_ENABLED())
2509                                 return (ENOPROTOOPT);
2510                         error = TCPMD5_PCBCTL(inp, sopt);
2511                         break;
2512 #endif
2513
2514                 case TCP_NODELAY:
2515                         optval = tp->t_flags & TF_NODELAY;
2516                         INP_WUNLOCK(inp);
2517                         error = sooptcopyout(sopt, &optval, sizeof optval);
2518                         break;
2519                 case TCP_MAXSEG:
2520                         optval = tp->t_maxseg;
2521                         INP_WUNLOCK(inp);
2522                         error = sooptcopyout(sopt, &optval, sizeof optval);
2523                         break;
2524                 case TCP_REMOTE_UDP_ENCAPS_PORT:
2525                         optval = ntohs(tp->t_port);
2526                         INP_WUNLOCK(inp);
2527                         error = sooptcopyout(sopt, &optval, sizeof optval);
2528                         break;
2529                 case TCP_NOOPT:
2530                         optval = tp->t_flags & TF_NOOPT;
2531                         INP_WUNLOCK(inp);
2532                         error = sooptcopyout(sopt, &optval, sizeof optval);
2533                         break;
2534                 case TCP_NOPUSH:
2535                         optval = tp->t_flags & TF_NOPUSH;
2536                         INP_WUNLOCK(inp);
2537                         error = sooptcopyout(sopt, &optval, sizeof optval);
2538                         break;
2539                 case TCP_INFO:
2540                         tcp_fill_info(tp, &ti);
2541                         INP_WUNLOCK(inp);
2542                         error = sooptcopyout(sopt, &ti, sizeof ti);
2543                         break;
2544                 case TCP_STATS:
2545                         {
2546 #ifdef STATS
2547                         int nheld;
2548                         TYPEOF_MEMBER(struct statsblob, flags) sbflags = 0;
2549
2550                         error = 0;
2551                         socklen_t outsbsz = sopt->sopt_valsize;
2552                         if (tp->t_stats == NULL)
2553                                 error = ENOENT;
2554                         else if (outsbsz >= tp->t_stats->cursz)
2555                                 outsbsz = tp->t_stats->cursz;
2556                         else if (outsbsz >= sizeof(struct statsblob))
2557                                 outsbsz = sizeof(struct statsblob);
2558                         else
2559                                 error = EINVAL;
2560                         INP_WUNLOCK(inp);
2561                         if (error)
2562                                 break;
2563
2564                         sbp = sopt->sopt_val;
2565                         nheld = atop(round_page(((vm_offset_t)sbp) +
2566                             (vm_size_t)outsbsz) - trunc_page((vm_offset_t)sbp));
2567                         vm_page_t ma[nheld];
2568                         if (vm_fault_quick_hold_pages(
2569                             &curproc->p_vmspace->vm_map, (vm_offset_t)sbp,
2570                             outsbsz, VM_PROT_READ | VM_PROT_WRITE, ma,
2571                             nheld) < 0) {
2572                                 error = EFAULT;
2573                                 break;
2574                         }
2575
2576                         if ((error = copyin_nofault(&(sbp->flags), &sbflags,
2577                             SIZEOF_MEMBER(struct statsblob, flags))))
2578                                 goto unhold;
2579
2580                         INP_WLOCK_RECHECK(inp);
2581                         error = stats_blob_snapshot(&sbp, outsbsz, tp->t_stats,
2582                             sbflags | SB_CLONE_USRDSTNOFAULT);
2583                         INP_WUNLOCK(inp);
2584                         sopt->sopt_valsize = outsbsz;
2585 unhold:
2586                         vm_page_unhold_pages(ma, nheld);
2587 #else
2588                         INP_WUNLOCK(inp);
2589                         error = EOPNOTSUPP;
2590 #endif /* !STATS */
2591                         break;
2592                         }
2593                 case TCP_CONGESTION:
2594                         len = strlcpy(buf, CC_ALGO(tp)->name, TCP_CA_NAME_MAX);
2595                         INP_WUNLOCK(inp);
2596                         error = sooptcopyout(sopt, buf, len + 1);
2597                         break;
2598                 case TCP_MAXUNACKTIME:
2599                 case TCP_KEEPIDLE:
2600                 case TCP_KEEPINTVL:
2601                 case TCP_KEEPINIT:
2602                 case TCP_KEEPCNT:
2603                         switch (sopt->sopt_name) {
2604                         case TCP_MAXUNACKTIME:
2605                                 ui = TP_MAXUNACKTIME(tp) / hz;
2606                                 break;
2607                         case TCP_KEEPIDLE:
2608                                 ui = TP_KEEPIDLE(tp) / hz;
2609                                 break;
2610                         case TCP_KEEPINTVL:
2611                                 ui = TP_KEEPINTVL(tp) / hz;
2612                                 break;
2613                         case TCP_KEEPINIT:
2614                                 ui = TP_KEEPINIT(tp) / hz;
2615                                 break;
2616                         case TCP_KEEPCNT:
2617                                 ui = TP_KEEPCNT(tp);
2618                                 break;
2619                         }
2620                         INP_WUNLOCK(inp);
2621                         error = sooptcopyout(sopt, &ui, sizeof(ui));
2622                         break;
2623 #ifdef TCPPCAP
2624                 case TCP_PCAP_OUT:
2625                 case TCP_PCAP_IN:
2626                         optval = tcp_pcap_get_sock_max(
2627                                         (sopt->sopt_name == TCP_PCAP_OUT) ?
2628                                         &(tp->t_outpkts) : &(tp->t_inpkts));
2629                         INP_WUNLOCK(inp);
2630                         error = sooptcopyout(sopt, &optval, sizeof optval);
2631                         break;
2632 #endif
2633                 case TCP_FASTOPEN:
2634                         optval = tp->t_flags & TF_FASTOPEN;
2635                         INP_WUNLOCK(inp);
2636                         error = sooptcopyout(sopt, &optval, sizeof optval);
2637                         break;
2638 #ifdef TCP_BLACKBOX
2639                 case TCP_LOG:
2640                         optval = tcp_get_bblog_state(tp);
2641                         INP_WUNLOCK(inp);
2642                         error = sooptcopyout(sopt, &optval, sizeof(optval));
2643                         break;
2644                 case TCP_LOGBUF:
2645                         /* tcp_log_getlogbuf() does INP_WUNLOCK(inp) */
2646                         error = tcp_log_getlogbuf(sopt, tp);
2647                         break;
2648                 case TCP_LOGID:
2649                         len = tcp_log_get_id(tp, buf);
2650                         INP_WUNLOCK(inp);
2651                         error = sooptcopyout(sopt, buf, len + 1);
2652                         break;
2653                 case TCP_LOGDUMP:
2654                 case TCP_LOGDUMPID:
2655                         INP_WUNLOCK(inp);
2656                         error = EINVAL;
2657                         break;
2658 #endif
2659 #ifdef KERN_TLS
2660                 case TCP_TXTLS_MODE:
2661                         error = ktls_get_tx_mode(so, &optval);
2662                         INP_WUNLOCK(inp);
2663                         if (error == 0)
2664                                 error = sooptcopyout(sopt, &optval,
2665                                     sizeof(optval));
2666                         break;
2667                 case TCP_RXTLS_MODE:
2668                         error = ktls_get_rx_mode(so, &optval);
2669                         INP_WUNLOCK(inp);
2670                         if (error == 0)
2671                                 error = sooptcopyout(sopt, &optval,
2672                                     sizeof(optval));
2673                         break;
2674 #endif
2675                 case TCP_LRD:
2676                         optval = tp->t_flags & TF_LRD;
2677                         INP_WUNLOCK(inp);
2678                         error = sooptcopyout(sopt, &optval, sizeof optval);
2679                         break;
2680                 default:
2681                         INP_WUNLOCK(inp);
2682                         error = ENOPROTOOPT;
2683                         break;
2684                 }
2685                 break;
2686         }
2687         return (error);
2688 }
2689 #undef INP_WLOCK_RECHECK
2690 #undef INP_WLOCK_RECHECK_CLEANUP
2691
2692 /*
2693  * Initiate (or continue) disconnect.
2694  * If embryonic state, just send reset (once).
2695  * If in ``let data drain'' option and linger null, just drop.
2696  * Otherwise (hard), mark socket disconnecting and drop
2697  * current input data; switch states based on user close, and
2698  * send segment to peer (with FIN).
2699  */
2700 static void
2701 tcp_disconnect(struct tcpcb *tp)
2702 {
2703         struct inpcb *inp = tptoinpcb(tp);
2704         struct socket *so = tptosocket(tp);
2705
2706         NET_EPOCH_ASSERT();
2707         INP_WLOCK_ASSERT(inp);
2708
2709         /*
2710          * Neither tcp_close() nor tcp_drop() should return NULL, as the
2711          * socket is still open.
2712          */
2713         if (tp->t_state < TCPS_ESTABLISHED &&
2714             !(tp->t_state > TCPS_LISTEN && IS_FASTOPEN(tp->t_flags))) {
2715                 tp = tcp_close(tp);
2716                 KASSERT(tp != NULL,
2717                     ("tcp_disconnect: tcp_close() returned NULL"));
2718         } else if ((so->so_options & SO_LINGER) && so->so_linger == 0) {
2719                 tp = tcp_drop(tp, 0);
2720                 KASSERT(tp != NULL,
2721                     ("tcp_disconnect: tcp_drop() returned NULL"));
2722         } else {
2723                 soisdisconnecting(so);
2724                 sbflush(&so->so_rcv);
2725                 tcp_usrclosed(tp);
2726                 if (!(inp->inp_flags & INP_DROPPED))
2727                         /* Ignore stack's drop request, we already at it. */
2728                         (void)tcp_output_nodrop(tp);
2729         }
2730 }
2731
2732 /*
2733  * User issued close, and wish to trail through shutdown states:
2734  * if never received SYN, just forget it.  If got a SYN from peer,
2735  * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
2736  * If already got a FIN from peer, then almost done; go to LAST_ACK
2737  * state.  In all other cases, have already sent FIN to peer (e.g.
2738  * after PRU_SHUTDOWN), and just have to play tedious game waiting
2739  * for peer to send FIN or not respond to keep-alives, etc.
2740  * We can let the user exit from the close as soon as the FIN is acked.
2741  */
2742 static void
2743 tcp_usrclosed(struct tcpcb *tp)
2744 {
2745
2746         NET_EPOCH_ASSERT();
2747         INP_WLOCK_ASSERT(tptoinpcb(tp));
2748
2749         switch (tp->t_state) {
2750         case TCPS_LISTEN:
2751 #ifdef TCP_OFFLOAD
2752                 tcp_offload_listen_stop(tp);
2753 #endif
2754                 tcp_state_change(tp, TCPS_CLOSED);
2755                 /* FALLTHROUGH */
2756         case TCPS_CLOSED:
2757                 tp = tcp_close(tp);
2758                 /*
2759                  * tcp_close() should never return NULL here as the socket is
2760                  * still open.
2761                  */
2762                 KASSERT(tp != NULL,
2763                     ("tcp_usrclosed: tcp_close() returned NULL"));
2764                 break;
2765
2766         case TCPS_SYN_SENT:
2767         case TCPS_SYN_RECEIVED:
2768                 tp->t_flags |= TF_NEEDFIN;
2769                 break;
2770
2771         case TCPS_ESTABLISHED:
2772                 tcp_state_change(tp, TCPS_FIN_WAIT_1);
2773                 break;
2774
2775         case TCPS_CLOSE_WAIT:
2776                 tcp_state_change(tp, TCPS_LAST_ACK);
2777                 break;
2778         }
2779         if (tp->t_acktime == 0)
2780                 tp->t_acktime = ticks;
2781         if (tp->t_state >= TCPS_FIN_WAIT_2) {
2782                 soisdisconnected(tptosocket(tp));
2783                 /* Prevent the connection hanging in FIN_WAIT_2 forever. */
2784                 if (tp->t_state == TCPS_FIN_WAIT_2) {
2785                         int timeout;
2786
2787                         timeout = (tcp_fast_finwait2_recycle) ?
2788                             tcp_finwait2_timeout : TP_MAXIDLE(tp);
2789                         tcp_timer_activate(tp, TT_2MSL, timeout);
2790                 }
2791         }
2792 }
2793
2794 #ifdef DDB
2795 static void
2796 db_print_indent(int indent)
2797 {
2798         int i;
2799
2800         for (i = 0; i < indent; i++)
2801                 db_printf(" ");
2802 }
2803
2804 static void
2805 db_print_tstate(int t_state)
2806 {
2807
2808         switch (t_state) {
2809         case TCPS_CLOSED:
2810                 db_printf("TCPS_CLOSED");
2811                 return;
2812
2813         case TCPS_LISTEN:
2814                 db_printf("TCPS_LISTEN");
2815                 return;
2816
2817         case TCPS_SYN_SENT:
2818                 db_printf("TCPS_SYN_SENT");
2819                 return;
2820
2821         case TCPS_SYN_RECEIVED:
2822                 db_printf("TCPS_SYN_RECEIVED");
2823                 return;
2824
2825         case TCPS_ESTABLISHED:
2826                 db_printf("TCPS_ESTABLISHED");
2827                 return;
2828
2829         case TCPS_CLOSE_WAIT:
2830                 db_printf("TCPS_CLOSE_WAIT");
2831                 return;
2832
2833         case TCPS_FIN_WAIT_1:
2834                 db_printf("TCPS_FIN_WAIT_1");
2835                 return;
2836
2837         case TCPS_CLOSING:
2838                 db_printf("TCPS_CLOSING");
2839                 return;
2840
2841         case TCPS_LAST_ACK:
2842                 db_printf("TCPS_LAST_ACK");
2843                 return;
2844
2845         case TCPS_FIN_WAIT_2:
2846                 db_printf("TCPS_FIN_WAIT_2");
2847                 return;
2848
2849         case TCPS_TIME_WAIT:
2850                 db_printf("TCPS_TIME_WAIT");
2851                 return;
2852
2853         default:
2854                 db_printf("unknown");
2855                 return;
2856         }
2857 }
2858
2859 static void
2860 db_print_tflags(u_int t_flags)
2861 {
2862         int comma;
2863
2864         comma = 0;
2865         if (t_flags & TF_ACKNOW) {
2866                 db_printf("%sTF_ACKNOW", comma ? ", " : "");
2867                 comma = 1;
2868         }
2869         if (t_flags & TF_DELACK) {
2870                 db_printf("%sTF_DELACK", comma ? ", " : "");
2871                 comma = 1;
2872         }
2873         if (t_flags & TF_NODELAY) {
2874                 db_printf("%sTF_NODELAY", comma ? ", " : "");
2875                 comma = 1;
2876         }
2877         if (t_flags & TF_NOOPT) {
2878                 db_printf("%sTF_NOOPT", comma ? ", " : "");
2879                 comma = 1;
2880         }
2881         if (t_flags & TF_SENTFIN) {
2882                 db_printf("%sTF_SENTFIN", comma ? ", " : "");
2883                 comma = 1;
2884         }
2885         if (t_flags & TF_REQ_SCALE) {
2886                 db_printf("%sTF_REQ_SCALE", comma ? ", " : "");
2887                 comma = 1;
2888         }
2889         if (t_flags & TF_RCVD_SCALE) {
2890                 db_printf("%sTF_RECVD_SCALE", comma ? ", " : "");
2891                 comma = 1;
2892         }
2893         if (t_flags & TF_REQ_TSTMP) {
2894                 db_printf("%sTF_REQ_TSTMP", comma ? ", " : "");
2895                 comma = 1;
2896         }
2897         if (t_flags & TF_RCVD_TSTMP) {
2898                 db_printf("%sTF_RCVD_TSTMP", comma ? ", " : "");
2899                 comma = 1;
2900         }
2901         if (t_flags & TF_SACK_PERMIT) {
2902                 db_printf("%sTF_SACK_PERMIT", comma ? ", " : "");
2903                 comma = 1;
2904         }
2905         if (t_flags & TF_NEEDSYN) {
2906                 db_printf("%sTF_NEEDSYN", comma ? ", " : "");
2907                 comma = 1;
2908         }
2909         if (t_flags & TF_NEEDFIN) {
2910                 db_printf("%sTF_NEEDFIN", comma ? ", " : "");
2911                 comma = 1;
2912         }
2913         if (t_flags & TF_NOPUSH) {
2914                 db_printf("%sTF_NOPUSH", comma ? ", " : "");
2915                 comma = 1;
2916         }
2917         if (t_flags & TF_PREVVALID) {
2918                 db_printf("%sTF_PREVVALID", comma ? ", " : "");
2919                 comma = 1;
2920         }
2921         if (t_flags & TF_MORETOCOME) {
2922                 db_printf("%sTF_MORETOCOME", comma ? ", " : "");
2923                 comma = 1;
2924         }
2925         if (t_flags & TF_SONOTCONN) {
2926                 db_printf("%sTF_SONOTCONN", comma ? ", " : "");
2927                 comma = 1;
2928         }
2929         if (t_flags & TF_LASTIDLE) {
2930                 db_printf("%sTF_LASTIDLE", comma ? ", " : "");
2931                 comma = 1;
2932         }
2933         if (t_flags & TF_RXWIN0SENT) {
2934                 db_printf("%sTF_RXWIN0SENT", comma ? ", " : "");
2935                 comma = 1;
2936         }
2937         if (t_flags & TF_FASTRECOVERY) {
2938                 db_printf("%sTF_FASTRECOVERY", comma ? ", " : "");
2939                 comma = 1;
2940         }
2941         if (t_flags & TF_CONGRECOVERY) {
2942                 db_printf("%sTF_CONGRECOVERY", comma ? ", " : "");
2943                 comma = 1;
2944         }
2945         if (t_flags & TF_WASFRECOVERY) {
2946                 db_printf("%sTF_WASFRECOVERY", comma ? ", " : "");
2947                 comma = 1;
2948         }
2949         if (t_flags & TF_WASCRECOVERY) {
2950                 db_printf("%sTF_WASCRECOVERY", comma ? ", " : "");
2951                 comma = 1;
2952         }
2953         if (t_flags & TF_SIGNATURE) {
2954                 db_printf("%sTF_SIGNATURE", comma ? ", " : "");
2955                 comma = 1;
2956         }
2957         if (t_flags & TF_FORCEDATA) {
2958                 db_printf("%sTF_FORCEDATA", comma ? ", " : "");
2959                 comma = 1;
2960         }
2961         if (t_flags & TF_TSO) {
2962                 db_printf("%sTF_TSO", comma ? ", " : "");
2963                 comma = 1;
2964         }
2965         if (t_flags & TF_FASTOPEN) {
2966                 db_printf("%sTF_FASTOPEN", comma ? ", " : "");
2967                 comma = 1;
2968         }
2969 }
2970
2971 static void
2972 db_print_tflags2(u_int t_flags2)
2973 {
2974         int comma;
2975
2976         comma = 0;
2977         if (t_flags2 & TF2_PLPMTU_BLACKHOLE) {
2978                 db_printf("%sTF2_PLPMTU_BLACKHOLE", comma ? ", " : "");
2979                 comma = 1;
2980         }
2981         if (t_flags2 & TF2_PLPMTU_PMTUD) {
2982                 db_printf("%sTF2_PLPMTU_PMTUD", comma ? ", " : "");
2983                 comma = 1;
2984         }
2985         if (t_flags2 & TF2_PLPMTU_MAXSEGSNT) {
2986                 db_printf("%sTF2_PLPMTU_MAXSEGSNT", comma ? ", " : "");
2987                 comma = 1;
2988         }
2989         if (t_flags2 & TF2_LOG_AUTO) {
2990                 db_printf("%sTF2_LOG_AUTO", comma ? ", " : "");
2991                 comma = 1;
2992         }
2993         if (t_flags2 & TF2_DROP_AF_DATA) {
2994                 db_printf("%sTF2_DROP_AF_DATA", comma ? ", " : "");
2995                 comma = 1;
2996         }
2997         if (t_flags2 & TF2_ECN_PERMIT) {
2998                 db_printf("%sTF2_ECN_PERMIT", comma ? ", " : "");
2999                 comma = 1;
3000         }
3001         if (t_flags2 & TF2_ECN_SND_CWR) {
3002                 db_printf("%sTF2_ECN_SND_CWR", comma ? ", " : "");
3003                 comma = 1;
3004         }
3005         if (t_flags2 & TF2_ECN_SND_ECE) {
3006                 db_printf("%sTF2_ECN_SND_ECE", comma ? ", " : "");
3007                 comma = 1;
3008         }
3009         if (t_flags2 & TF2_ACE_PERMIT) {
3010                 db_printf("%sTF2_ACE_PERMIT", comma ? ", " : "");
3011                 comma = 1;
3012         }
3013         if (t_flags2 & TF2_FBYTES_COMPLETE) {
3014                 db_printf("%sTF2_FBYTES_COMPLETE", comma ? ", " : "");
3015                 comma = 1;
3016         }
3017 }
3018
3019 static void
3020 db_print_toobflags(char t_oobflags)
3021 {
3022         int comma;
3023
3024         comma = 0;
3025         if (t_oobflags & TCPOOB_HAVEDATA) {
3026                 db_printf("%sTCPOOB_HAVEDATA", comma ? ", " : "");
3027                 comma = 1;
3028         }
3029         if (t_oobflags & TCPOOB_HADDATA) {
3030                 db_printf("%sTCPOOB_HADDATA", comma ? ", " : "");
3031                 comma = 1;
3032         }
3033 }
3034
3035 static void
3036 db_print_tcpcb(struct tcpcb *tp, const char *name, int indent)
3037 {
3038
3039         db_print_indent(indent);
3040         db_printf("%s at %p\n", name, tp);
3041
3042         indent += 2;
3043
3044         db_print_indent(indent);
3045         db_printf("t_segq first: %p   t_segqlen: %d   t_dupacks: %d\n",
3046            TAILQ_FIRST(&tp->t_segq), tp->t_segqlen, tp->t_dupacks);
3047
3048         db_print_indent(indent);
3049         db_printf("t_callout: %p   t_timers: %p\n",
3050             &tp->t_callout, &tp->t_timers);
3051
3052         db_print_indent(indent);
3053         db_printf("t_state: %d (", tp->t_state);
3054         db_print_tstate(tp->t_state);
3055         db_printf(")\n");
3056
3057         db_print_indent(indent);
3058         db_printf("t_flags: 0x%x (", tp->t_flags);
3059         db_print_tflags(tp->t_flags);
3060         db_printf(")\n");
3061
3062         db_print_indent(indent);
3063         db_printf("t_flags2: 0x%x (", tp->t_flags2);
3064         db_print_tflags2(tp->t_flags2);
3065         db_printf(")\n");
3066
3067         db_print_indent(indent);
3068         db_printf("snd_una: 0x%08x   snd_max: 0x%08x   snd_nxt: 0x%08x\n",
3069             tp->snd_una, tp->snd_max, tp->snd_nxt);
3070
3071         db_print_indent(indent);
3072         db_printf("snd_up: 0x%08x   snd_wl1: 0x%08x   snd_wl2: 0x%08x\n",
3073            tp->snd_up, tp->snd_wl1, tp->snd_wl2);
3074
3075         db_print_indent(indent);
3076         db_printf("iss: 0x%08x   irs: 0x%08x   rcv_nxt: 0x%08x\n",
3077             tp->iss, tp->irs, tp->rcv_nxt);
3078
3079         db_print_indent(indent);
3080         db_printf("rcv_adv: 0x%08x   rcv_wnd: %u   rcv_up: 0x%08x\n",
3081             tp->rcv_adv, tp->rcv_wnd, tp->rcv_up);
3082
3083         db_print_indent(indent);
3084         db_printf("snd_wnd: %u   snd_cwnd: %u\n",
3085            tp->snd_wnd, tp->snd_cwnd);
3086
3087         db_print_indent(indent);
3088         db_printf("snd_ssthresh: %u   snd_recover: "
3089             "0x%08x\n", tp->snd_ssthresh, tp->snd_recover);
3090
3091         db_print_indent(indent);
3092         db_printf("t_rcvtime: %u   t_startime: %u\n",
3093             tp->t_rcvtime, tp->t_starttime);
3094
3095         db_print_indent(indent);
3096         db_printf("t_rttime: %u   t_rtsq: 0x%08x\n",
3097             tp->t_rtttime, tp->t_rtseq);
3098
3099         db_print_indent(indent);
3100         db_printf("t_rxtcur: %d   t_maxseg: %u   t_srtt: %d\n",
3101             tp->t_rxtcur, tp->t_maxseg, tp->t_srtt);
3102
3103         db_print_indent(indent);
3104         db_printf("t_rttvar: %d   t_rxtshift: %d   t_rttmin: %u\n",
3105             tp->t_rttvar, tp->t_rxtshift, tp->t_rttmin);
3106
3107         db_print_indent(indent);
3108         db_printf("t_rttupdated: %u   max_sndwnd: %u   t_softerror: %d\n",
3109             tp->t_rttupdated, tp->max_sndwnd, tp->t_softerror);
3110
3111         db_print_indent(indent);
3112         db_printf("t_oobflags: 0x%x (", tp->t_oobflags);
3113         db_print_toobflags(tp->t_oobflags);
3114         db_printf(")   t_iobc: 0x%02x\n", tp->t_iobc);
3115
3116         db_print_indent(indent);
3117         db_printf("snd_scale: %u   rcv_scale: %u   request_r_scale: %u\n",
3118             tp->snd_scale, tp->rcv_scale, tp->request_r_scale);
3119
3120         db_print_indent(indent);
3121         db_printf("ts_recent: %u   ts_recent_age: %u\n",
3122             tp->ts_recent, tp->ts_recent_age);
3123
3124         db_print_indent(indent);
3125         db_printf("ts_offset: %u   last_ack_sent: 0x%08x   snd_cwnd_prev: "
3126             "%u\n", tp->ts_offset, tp->last_ack_sent, tp->snd_cwnd_prev);
3127
3128         db_print_indent(indent);
3129         db_printf("snd_ssthresh_prev: %u   snd_recover_prev: 0x%08x   "
3130             "t_badrxtwin: %u\n", tp->snd_ssthresh_prev,
3131             tp->snd_recover_prev, tp->t_badrxtwin);
3132
3133         db_print_indent(indent);
3134         db_printf("snd_numholes: %d  snd_holes first: %p\n",
3135             tp->snd_numholes, TAILQ_FIRST(&tp->snd_holes));
3136
3137         db_print_indent(indent);
3138         db_printf("snd_fack: 0x%08x   rcv_numsacks: %d\n",
3139             tp->snd_fack, tp->rcv_numsacks);
3140
3141         /* Skip sackblks, sackhint. */
3142
3143         db_print_indent(indent);
3144         db_printf("t_rttlow: %d   rfbuf_ts: %u   rfbuf_cnt: %d\n",
3145             tp->t_rttlow, tp->rfbuf_ts, tp->rfbuf_cnt);
3146 }
3147
3148 DB_SHOW_COMMAND(tcpcb, db_show_tcpcb)
3149 {
3150         struct tcpcb *tp;
3151
3152         if (!have_addr) {
3153                 db_printf("usage: show tcpcb <addr>\n");
3154                 return;
3155         }
3156         tp = (struct tcpcb *)addr;
3157
3158         db_print_tcpcb(tp, "tcpcb", 0);
3159 }
3160 #endif