sys/kern/uipc_socket.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1982, 1986, 1988, 1990, 1993
   5  *      The Regents of the University of California.
   6  * Copyright (c) 2004 The FreeBSD Foundation
   7  * Copyright (c) 2004-2008 Robert N. M. Watson
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  *      @(#)uipc_socket.c       8.3 (Berkeley) 4/15/94
  35  */
  36
  37 /*
  38  * Comments on the socket life cycle:
  39  *
  40  * soalloc() sets of socket layer state for a socket, called only by
  41  * socreate() and sonewconn().  Socket layer private.
  42  *
  43  * sodealloc() tears down socket layer state for a socket, called only by
  44  * sofree() and sonewconn().  Socket layer private.
  45  *
  46  * pru_attach() associates protocol layer state with an allocated socket;
  47  * called only once, may fail, aborting socket allocation.  This is called
  48  * from socreate() and sonewconn().  Socket layer private.
  49  *
  50  * pru_detach() disassociates protocol layer state from an attached socket,
  51  * and will be called exactly once for sockets in which pru_attach() has
  52  * been successfully called.  If pru_attach() returned an error,
  53  * pru_detach() will not be called.  Socket layer private.
  54  *
  55  * pru_abort() and pru_close() notify the protocol layer that the last
  56  * consumer of a socket is starting to tear down the socket, and that the
  57  * protocol should terminate the connection.  Historically, pru_abort() also
  58  * detached protocol state from the socket state, but this is no longer the
  59  * case.
  60  *
  61  * socreate() creates a socket and attaches protocol state.  This is a public
  62  * interface that may be used by socket layer consumers to create new
  63  * sockets.
  64  *
  65  * sonewconn() creates a socket and attaches protocol state.  This is a
  66  * public interface  that may be used by protocols to create new sockets when
  67  * a new connection is received and will be available for accept() on a
  68  * listen socket.
  69  *
  70  * soclose() destroys a socket after possibly waiting for it to disconnect.
  71  * This is a public interface that socket consumers should use to close and
  72  * release a socket when done with it.
  73  *
  74  * soabort() destroys a socket without waiting for it to disconnect (used
  75  * only for incoming connections that are already partially or fully
  76  * connected).  This is used internally by the socket layer when clearing
  77  * listen socket queues (due to overflow or close on the listen socket), but
  78  * is also a public interface protocols may use to abort connections in
  79  * their incomplete listen queues should they no longer be required.  Sockets
  80  * placed in completed connection listen queues should not be aborted for
  81  * reasons described in the comment above the soclose() implementation.  This
  82  * is not a general purpose close routine, and except in the specific
  83  * circumstances described here, should not be used.
  84  *
  85  * sofree() will free a socket and its protocol state if all references on
  86  * the socket have been released, and is the public interface to attempt to
  87  * free a socket when a reference is removed.  This is a socket layer private
  88  * interface.
  89  *
  90  * NOTE: In addition to socreate() and soclose(), which provide a single
  91  * socket reference to the consumer to be managed as required, there are two
  92  * calls to explicitly manage socket references, soref(), and sorele().
  93  * Currently, these are generally required only when transitioning a socket
  94  * from a listen queue to a file descriptor, in order to prevent garbage
  95  * collection of the socket at an untimely moment.  For a number of reasons,
  96  * these interfaces are not preferred, and should be avoided.
  97  *
  98  * NOTE: With regard to VNETs the general rule is that callers do not set
  99  * curvnet. Exceptions to this rule include soabort(), sodisconnect(),
 100  * sofree() (and with that sorele(), sotryfree()), as well as sonewconn()
 101  * and sorflush(), which are usually called from a pre-set VNET context.
 102  * sopoll() currently does not need a VNET context to be set.
 103  */
 104
 105 #include <sys/cdefs.h>
 106 __FBSDID("$FreeBSD$");
 107
 108 #include "opt_inet.h"
 109 #include "opt_inet6.h"
 110 #include "opt_kern_tls.h"
 111 #include "opt_sctp.h"
 112
 113 #include <sys/param.h>
 114 #include <sys/systm.h>
 115 #include <sys/capsicum.h>
 116 #include <sys/fcntl.h>
 117 #include <sys/limits.h>
 118 #include <sys/lock.h>
 119 #include <sys/mac.h>
 120 #include <sys/malloc.h>
 121 #include <sys/mbuf.h>
 122 #include <sys/mutex.h>
 123 #include <sys/domain.h>
 124 #include <sys/file.h>                   /* for struct knote */
 125 #include <sys/hhook.h>
 126 #include <sys/kernel.h>
 127 #include <sys/khelp.h>
 128 #include <sys/ktls.h>
 129 #include <sys/event.h>
 130 #include <sys/eventhandler.h>
 131 #include <sys/poll.h>
 132 #include <sys/proc.h>
 133 #include <sys/protosw.h>
 134 #include <sys/sbuf.h>
 135 #include <sys/socket.h>
 136 #include <sys/socketvar.h>
 137 #include <sys/resourcevar.h>
 138 #include <net/route.h>
 139 #include <sys/signalvar.h>
 140 #include <sys/stat.h>
 141 #include <sys/sx.h>
 142 #include <sys/sysctl.h>
 143 #include <sys/taskqueue.h>
 144 #include <sys/uio.h>
 145 #include <sys/un.h>
 146 #include <sys/unpcb.h>
 147 #include <sys/jail.h>
 148 #include <sys/syslog.h>
 149 #include <netinet/in.h>
 150 #include <netinet/in_pcb.h>
 151 #include <netinet/tcp.h>
 152
 153 #include <net/vnet.h>
 154
 155 #include <security/mac/mac_framework.h>
 156
 157 #include <vm/uma.h>
 158
 159 #ifdef COMPAT_FREEBSD32
 160 #include <sys/mount.h>
 161 #include <sys/sysent.h>
 162 #include <compat/freebsd32/freebsd32.h>
 163 #endif
 164
 165 static int      soreceive_rcvoob(struct socket *so, struct uio *uio,
 166                     int flags);
 167 static void     so_rdknl_lock(void *);
 168 static void     so_rdknl_unlock(void *);
 169 static void     so_rdknl_assert_lock(void *, int);
 170 static void     so_wrknl_lock(void *);
 171 static void     so_wrknl_unlock(void *);
 172 static void     so_wrknl_assert_lock(void *, int);
 173
 174 static void     filt_sordetach(struct knote *kn);
 175 static int      filt_soread(struct knote *kn, long hint);
 176 static void     filt_sowdetach(struct knote *kn);
 177 static int      filt_sowrite(struct knote *kn, long hint);
 178 static int      filt_soempty(struct knote *kn, long hint);
 179 static int inline hhook_run_socket(struct socket *so, void *hctx, int32_t h_id);
 180 fo_kqfilter_t   soo_kqfilter;
 181
 182 static struct filterops soread_filtops = {
 183         .f_isfd = 1,
 184         .f_detach = filt_sordetach,
 185         .f_event = filt_soread,
 186 };
 187 static struct filterops sowrite_filtops = {
 188         .f_isfd = 1,
 189         .f_detach = filt_sowdetach,
 190         .f_event = filt_sowrite,
 191 };
 192 static struct filterops soempty_filtops = {
 193         .f_isfd = 1,
 194         .f_detach = filt_sowdetach,
 195         .f_event = filt_soempty,
 196 };
 197
 198 so_gen_t        so_gencnt;      /* generation count for sockets */
 199
 200 MALLOC_DEFINE(M_SONAME, "soname", "socket name");
 201 MALLOC_DEFINE(M_PCB, "pcb", "protocol control block");
 202
 203 #define VNET_SO_ASSERT(so)                                              \
 204         VNET_ASSERT(curvnet != NULL,                                    \
 205             ("%s:%d curvnet is NULL, so=%p", __func__, __LINE__, (so)));
 206
 207 VNET_DEFINE(struct hhook_head *, socket_hhh[HHOOK_SOCKET_LAST + 1]);
 208 #define V_socket_hhh            VNET(socket_hhh)
 209
 210 /*
 211  * Limit on the number of connections in the listen queue waiting
 212  * for accept(2).
 213  * NB: The original sysctl somaxconn is still available but hidden
 214  * to prevent confusion about the actual purpose of this number.
 215  */
 216 static u_int somaxconn = SOMAXCONN;
 217
 218 static int
 219 sysctl_somaxconn(SYSCTL_HANDLER_ARGS)
 220 {
 221         int error;
 222         int val;
 223
 224         val = somaxconn;
 225         error = sysctl_handle_int(oidp, &val, 0, req);
 226         if (error || !req->newptr )
 227                 return (error);
 228
 229         /*
 230          * The purpose of the UINT_MAX / 3 limit, is so that the formula
 231          *   3 * so_qlimit / 2
 232          * below, will not overflow.
 233          */
 234
 235         if (val < 1 || val > UINT_MAX / 3)
 236                 return (EINVAL);
 237
 238         somaxconn = val;
 239         return (0);
 240 }
 241 SYSCTL_PROC(_kern_ipc, OID_AUTO, soacceptqueue,
 242     CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_MPSAFE, 0, sizeof(int),
 243     sysctl_somaxconn, "I",
 244     "Maximum listen socket pending connection accept queue size");
 245 SYSCTL_PROC(_kern_ipc, KIPC_SOMAXCONN, somaxconn,
 246     CTLTYPE_UINT | CTLFLAG_RW | CTLFLAG_SKIP | CTLFLAG_MPSAFE, 0,
 247     sizeof(int), sysctl_somaxconn, "I",
 248     "Maximum listen socket pending connection accept queue size (compat)");
 249
 250 static int numopensockets;
 251 SYSCTL_INT(_kern_ipc, OID_AUTO, numopensockets, CTLFLAG_RD,
 252     &numopensockets, 0, "Number of open sockets");
 253
 254 /*
 255  * so_global_mtx protects so_gencnt, numopensockets, and the per-socket
 256  * so_gencnt field.
 257  */
 258 static struct mtx so_global_mtx;
 259 MTX_SYSINIT(so_global_mtx, &so_global_mtx, "so_glabel", MTX_DEF);
 260
 261 /*
 262  * General IPC sysctl name space, used by sockets and a variety of other IPC
 263  * types.
 264  */
 265 SYSCTL_NODE(_kern, KERN_IPC, ipc, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
 266     "IPC");
 267
 268 /*
 269  * Initialize the socket subsystem and set up the socket
 270  * memory allocator.
 271  */
 272 static uma_zone_t socket_zone;
 273 int     maxsockets;
 274
 275 static void
 276 socket_zone_change(void *tag)
 277 {
 278
 279         maxsockets = uma_zone_set_max(socket_zone, maxsockets);
 280 }
 281
 282 static void
 283 socket_hhook_register(int subtype)
 284 {
 285
 286         if (hhook_head_register(HHOOK_TYPE_SOCKET, subtype,
 287             &V_socket_hhh[subtype],
 288             HHOOK_NOWAIT|HHOOK_HEADISINVNET) != 0)
 289                 printf("%s: WARNING: unable to register hook\n", __func__);
 290 }
 291
 292 static void
 293 socket_hhook_deregister(int subtype)
 294 {
 295
 296         if (hhook_head_deregister(V_socket_hhh[subtype]) != 0)
 297                 printf("%s: WARNING: unable to deregister hook\n", __func__);
 298 }
 299
 300 static void
 301 socket_init(void *tag)
 302 {
 303
 304         socket_zone = uma_zcreate("socket", sizeof(struct socket), NULL, NULL,
 305             NULL, NULL, UMA_ALIGN_PTR, 0);
 306         maxsockets = uma_zone_set_max(socket_zone, maxsockets);
 307         uma_zone_set_warning(socket_zone, "kern.ipc.maxsockets limit reached");
 308         EVENTHANDLER_REGISTER(maxsockets_change, socket_zone_change, NULL,
 309             EVENTHANDLER_PRI_FIRST);
 310 }
 311 SYSINIT(socket, SI_SUB_PROTO_DOMAININIT, SI_ORDER_ANY, socket_init, NULL);
 312
 313 static void
 314 socket_vnet_init(const void *unused __unused)
 315 {
 316         int i;
 317
 318         /* We expect a contiguous range */
 319         for (i = 0; i <= HHOOK_SOCKET_LAST; i++)
 320                 socket_hhook_register(i);
 321 }
 322 VNET_SYSINIT(socket_vnet_init, SI_SUB_PROTO_DOMAININIT, SI_ORDER_ANY,
 323     socket_vnet_init, NULL);
 324
 325 static void
 326 socket_vnet_uninit(const void *unused __unused)
 327 {
 328         int i;
 329
 330         for (i = 0; i <= HHOOK_SOCKET_LAST; i++)
 331                 socket_hhook_deregister(i);
 332 }
 333 VNET_SYSUNINIT(socket_vnet_uninit, SI_SUB_PROTO_DOMAININIT, SI_ORDER_ANY,
 334     socket_vnet_uninit, NULL);
 335
 336 /*
 337  * Initialise maxsockets.  This SYSINIT must be run after
 338  * tunable_mbinit().
 339  */
 340 static void
 341 init_maxsockets(void *ignored)
 342 {
 343
 344         TUNABLE_INT_FETCH("kern.ipc.maxsockets", &maxsockets);
 345         maxsockets = imax(maxsockets, maxfiles);
 346 }
 347 SYSINIT(param, SI_SUB_TUNABLES, SI_ORDER_ANY, init_maxsockets, NULL);
 348
 349 /*
 350  * Sysctl to get and set the maximum global sockets limit.  Notify protocols
 351  * of the change so that they can update their dependent limits as required.
 352  */
 353 static int
 354 sysctl_maxsockets(SYSCTL_HANDLER_ARGS)
 355 {
 356         int error, newmaxsockets;
 357
 358         newmaxsockets = maxsockets;
 359         error = sysctl_handle_int(oidp, &newmaxsockets, 0, req);
 360         if (error == 0 && req->newptr && newmaxsockets != maxsockets) {
 361                 if (newmaxsockets > maxsockets &&
 362                     newmaxsockets <= maxfiles) {
 363                         maxsockets = newmaxsockets;
 364                         EVENTHANDLER_INVOKE(maxsockets_change);
 365                 } else
 366                         error = EINVAL;
 367         }
 368         return (error);
 369 }
 370 SYSCTL_PROC(_kern_ipc, OID_AUTO, maxsockets,
 371     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, &maxsockets, 0,
 372     sysctl_maxsockets, "IU",
 373     "Maximum number of sockets available");
 374
 375 /*
 376  * Socket operation routines.  These routines are called by the routines in
 377  * sys_socket.c or from a system process, and implement the semantics of
 378  * socket operations by switching out to the protocol specific routines.
 379  */
 380
 381 /*
 382  * Get a socket structure from our zone, and initialize it.  Note that it
 383  * would probably be better to allocate socket and PCB at the same time, but
 384  * I'm not convinced that all the protocols can be easily modified to do
 385  * this.
 386  *
 387  * soalloc() returns a socket with a ref count of 0.
 388  */
 389 static struct socket *
 390 soalloc(struct vnet *vnet)
 391 {
 392         struct socket *so;
 393
 394         so = uma_zalloc(socket_zone, M_NOWAIT | M_ZERO);
 395         if (so == NULL)
 396                 return (NULL);
 397 #ifdef MAC
 398         if (mac_socket_init(so, M_NOWAIT) != 0) {
 399                 uma_zfree(socket_zone, so);
 400                 return (NULL);
 401         }
 402 #endif
 403         if (khelp_init_osd(HELPER_CLASS_SOCKET, &so->osd)) {
 404                 uma_zfree(socket_zone, so);
 405                 return (NULL);
 406         }
 407
 408         /*
 409          * The socket locking protocol allows to lock 2 sockets at a time,
 410          * however, the first one must be a listening socket.  WITNESS lacks
 411          * a feature to change class of an existing lock, so we use DUPOK.
 412          */
 413         mtx_init(&so->so_lock, "socket", NULL, MTX_DEF | MTX_DUPOK);
 414         mtx_init(&so->so_snd_mtx, "so_snd", NULL, MTX_DEF);
 415         mtx_init(&so->so_rcv_mtx, "so_rcv", NULL, MTX_DEF);
 416         so->so_rcv.sb_sel = &so->so_rdsel;
 417         so->so_snd.sb_sel = &so->so_wrsel;
 418         sx_init(&so->so_snd_sx, "so_snd_sx");
 419         sx_init(&so->so_rcv_sx, "so_rcv_sx");
 420         TAILQ_INIT(&so->so_snd.sb_aiojobq);
 421         TAILQ_INIT(&so->so_rcv.sb_aiojobq);
 422         TASK_INIT(&so->so_snd.sb_aiotask, 0, soaio_snd, so);
 423         TASK_INIT(&so->so_rcv.sb_aiotask, 0, soaio_rcv, so);
 424 #ifdef VIMAGE
 425         VNET_ASSERT(vnet != NULL, ("%s:%d vnet is NULL, so=%p",
 426             __func__, __LINE__, so));
 427         so->so_vnet = vnet;
 428 #endif
 429         /* We shouldn't need the so_global_mtx */
 430         if (hhook_run_socket(so, NULL, HHOOK_SOCKET_CREATE)) {
 431                 /* Do we need more comprehensive error returns? */
 432                 uma_zfree(socket_zone, so);
 433                 return (NULL);
 434         }
 435         mtx_lock(&so_global_mtx);
 436         so->so_gencnt = ++so_gencnt;
 437         ++numopensockets;
 438 #ifdef VIMAGE
 439         vnet->vnet_sockcnt++;
 440 #endif
 441         mtx_unlock(&so_global_mtx);
 442
 443         return (so);
 444 }
 445
 446 /*
 447  * Free the storage associated with a socket at the socket layer, tear down
 448  * locks, labels, etc.  All protocol state is assumed already to have been
 449  * torn down (and possibly never set up) by the caller.
 450  */
 451 void
 452 sodealloc(struct socket *so)
 453 {
 454
 455         KASSERT(so->so_count == 0, ("sodealloc(): so_count %d", so->so_count));
 456         KASSERT(so->so_pcb == NULL, ("sodealloc(): so_pcb != NULL"));
 457
 458         mtx_lock(&so_global_mtx);
 459         so->so_gencnt = ++so_gencnt;
 460         --numopensockets;       /* Could be below, but faster here. */
 461 #ifdef VIMAGE
 462         VNET_ASSERT(so->so_vnet != NULL, ("%s:%d so_vnet is NULL, so=%p",
 463             __func__, __LINE__, so));
 464         so->so_vnet->vnet_sockcnt--;
 465 #endif
 466         mtx_unlock(&so_global_mtx);
 467 #ifdef MAC
 468         mac_socket_destroy(so);
 469 #endif
 470         hhook_run_socket(so, NULL, HHOOK_SOCKET_CLOSE);
 471
 472         khelp_destroy_osd(&so->osd);
 473         if (SOLISTENING(so)) {
 474                 if (so->sol_accept_filter != NULL)
 475                         accept_filt_setopt(so, NULL);
 476         } else {
 477                 if (so->so_rcv.sb_hiwat)
 478                         (void)chgsbsize(so->so_cred->cr_uidinfo,
 479                             &so->so_rcv.sb_hiwat, 0, RLIM_INFINITY);
 480                 if (so->so_snd.sb_hiwat)
 481                         (void)chgsbsize(so->so_cred->cr_uidinfo,
 482                             &so->so_snd.sb_hiwat, 0, RLIM_INFINITY);
 483                 sx_destroy(&so->so_snd_sx);
 484                 sx_destroy(&so->so_rcv_sx);
 485                 mtx_destroy(&so->so_snd_mtx);
 486                 mtx_destroy(&so->so_rcv_mtx);
 487         }
 488         crfree(so->so_cred);
 489         mtx_destroy(&so->so_lock);
 490         uma_zfree(socket_zone, so);
 491 }
 492
 493 /*
 494  * socreate returns a socket with a ref count of 1 and a file descriptor
 495  * reference.  The socket should be closed with soclose().
 496  */
 497 int
 498 socreate(int dom, struct socket **aso, int type, int proto,
 499     struct ucred *cred, struct thread *td)
 500 {
 501         struct protosw *prp;
 502         struct socket *so;
 503         int error;
 504
 505         /*
 506          * XXX: divert(4) historically abused PF_INET.  Keep this compatibility
 507          * shim until all applications have been updated.
 508          */
 509         if (__predict_false(dom == PF_INET && type == SOCK_RAW &&
 510             proto == IPPROTO_DIVERT)) {
 511                 dom = PF_DIVERT;
 512                 printf("%s uses obsolete way to create divert(4) socket\n",
 513                     td->td_proc->p_comm);
 514         }
 515
 516         prp = pffindproto(dom, type, proto);
 517         if (prp == NULL) {
 518                 /* No support for domain. */
 519                 if (pffinddomain(dom) == NULL)
 520                         return (EAFNOSUPPORT);
 521                 /* No support for socket type. */
 522                 if (proto == 0 && type != 0)
 523                         return (EPROTOTYPE);
 524                 return (EPROTONOSUPPORT);
 525         }
 526
 527         MPASS(prp->pr_attach);
 528
 529         if (IN_CAPABILITY_MODE(td) && (prp->pr_flags & PR_CAPATTACH) == 0)
 530                 return (ECAPMODE);
 531
 532         if (prison_check_af(cred, prp->pr_domain->dom_family) != 0)
 533                 return (EPROTONOSUPPORT);
 534
 535         so = soalloc(CRED_TO_VNET(cred));
 536         if (so == NULL)
 537                 return (ENOBUFS);
 538
 539         so->so_type = type;
 540         so->so_cred = crhold(cred);
 541         if ((prp->pr_domain->dom_family == PF_INET) ||
 542             (prp->pr_domain->dom_family == PF_INET6) ||
 543             (prp->pr_domain->dom_family == PF_ROUTE))
 544                 so->so_fibnum = td->td_proc->p_fibnum;
 545         else
 546                 so->so_fibnum = 0;
 547         so->so_proto = prp;
 548 #ifdef MAC
 549         mac_socket_create(cred, so);
 550 #endif
 551         knlist_init(&so->so_rdsel.si_note, so, so_rdknl_lock, so_rdknl_unlock,
 552             so_rdknl_assert_lock);
 553         knlist_init(&so->so_wrsel.si_note, so, so_wrknl_lock, so_wrknl_unlock,
 554             so_wrknl_assert_lock);
 555         if ((prp->pr_flags & PR_SOCKBUF) == 0) {
 556                 so->so_snd.sb_mtx = &so->so_snd_mtx;
 557                 so->so_rcv.sb_mtx = &so->so_rcv_mtx;
 558         }
 559         /*
 560          * Auto-sizing of socket buffers is managed by the protocols and
 561          * the appropriate flags must be set in the pru_attach function.
 562          */
 563         CURVNET_SET(so->so_vnet);
 564         error = prp->pr_attach(so, proto, td);
 565         CURVNET_RESTORE();
 566         if (error) {
 567                 sodealloc(so);
 568                 return (error);
 569         }
 570         soref(so);
 571         *aso = so;
 572         return (0);
 573 }
 574
 575 #ifdef REGRESSION
 576 static int regression_sonewconn_earlytest = 1;
 577 SYSCTL_INT(_regression, OID_AUTO, sonewconn_earlytest, CTLFLAG_RW,
 578     &regression_sonewconn_earlytest, 0, "Perform early sonewconn limit test");
 579 #endif
 580
 581 static struct timeval overinterval = { 60, 0 };
 582 SYSCTL_TIMEVAL_SEC(_kern_ipc, OID_AUTO, sooverinterval, CTLFLAG_RW,
 583     &overinterval,
 584     "Delay in seconds between warnings for listen socket overflows");
 585
 586 /*
 587  * When an attempt at a new connection is noted on a socket which supports
 588  * accept(2), the protocol has two options:
 589  * 1) Call legacy sonewconn() function, which would call protocol attach
 590  *    method, same as used for socket(2).
 591  * 2) Call solisten_clone(), do attach that is specific to a cloned connection,
 592  *    and then call solisten_enqueue().
 593  *
 594  * Note: the ref count on the socket is 0 on return.
 595  */
 596 struct socket *
 597 solisten_clone(struct socket *head)
 598 {
 599         struct sbuf descrsb;
 600         struct socket *so;
 601         int len, overcount;
 602         u_int qlen;
 603         const char localprefix[] = "local:";
 604         char descrbuf[SUNPATHLEN + sizeof(localprefix)];
 605 #if defined(INET6)
 606         char addrbuf[INET6_ADDRSTRLEN];
 607 #elif defined(INET)
 608         char addrbuf[INET_ADDRSTRLEN];
 609 #endif
 610         bool dolog, over;
 611
 612         SOLISTEN_LOCK(head);
 613         over = (head->sol_qlen > 3 * head->sol_qlimit / 2);
 614 #ifdef REGRESSION
 615         if (regression_sonewconn_earlytest && over) {
 616 #else
 617         if (over) {
 618 #endif
 619                 head->sol_overcount++;
 620                 dolog = !!ratecheck(&head->sol_lastover, &overinterval);
 621
 622                 /*
 623                  * If we're going to log, copy the overflow count and queue
 624                  * length from the listen socket before dropping the lock.
 625                  * Also, reset the overflow count.
 626                  */
 627                 if (dolog) {
 628                         overcount = head->sol_overcount;
 629                         head->sol_overcount = 0;
 630                         qlen = head->sol_qlen;
 631                 }
 632                 SOLISTEN_UNLOCK(head);
 633
 634                 if (dolog) {
 635                         /*
 636                          * Try to print something descriptive about the
 637                          * socket for the error message.
 638                          */
 639                         sbuf_new(&descrsb, descrbuf, sizeof(descrbuf),
 640                             SBUF_FIXEDLEN);
 641                         switch (head->so_proto->pr_domain->dom_family) {
 642 #if defined(INET) || defined(INET6)
 643 #ifdef INET
 644                         case AF_INET:
 645 #endif
 646 #ifdef INET6
 647                         case AF_INET6:
 648                                 if (head->so_proto->pr_domain->dom_family ==
 649                                     AF_INET6 ||
 650                                     (sotoinpcb(head)->inp_inc.inc_flags &
 651                                     INC_ISIPV6)) {
 652                                         ip6_sprintf(addrbuf,
 653                                             &sotoinpcb(head)->inp_inc.inc6_laddr);
 654                                         sbuf_printf(&descrsb, "[%s]", addrbuf);
 655                                 } else
 656 #endif
 657                                 {
 658 #ifdef INET
 659                                         inet_ntoa_r(
 660                                             sotoinpcb(head)->inp_inc.inc_laddr,
 661                                             addrbuf);
 662                                         sbuf_cat(&descrsb, addrbuf);
 663 #endif
 664                                 }
 665                                 sbuf_printf(&descrsb, ":%hu (proto %u)",
 666                                     ntohs(sotoinpcb(head)->inp_inc.inc_lport),
 667                                     head->so_proto->pr_protocol);
 668                                 break;
 669 #endif /* INET || INET6 */
 670                         case AF_UNIX:
 671                                 sbuf_cat(&descrsb, localprefix);
 672                                 if (sotounpcb(head)->unp_addr != NULL)
 673                                         len =
 674                                             sotounpcb(head)->unp_addr->sun_len -
 675                                             offsetof(struct sockaddr_un,
 676                                             sun_path);
 677                                 else
 678                                         len = 0;
 679                                 if (len > 0)
 680                                         sbuf_bcat(&descrsb,
 681                                             sotounpcb(head)->unp_addr->sun_path,
 682                                             len);
 683                                 else
 684                                         sbuf_cat(&descrsb, "(unknown)");
 685                                 break;
 686                         }
 687
 688                         /*
 689                          * If we can't print something more specific, at least
 690                          * print the domain name.
 691                          */
 692                         if (sbuf_finish(&descrsb) != 0 ||
 693                             sbuf_len(&descrsb) <= 0) {
 694                                 sbuf_clear(&descrsb);
 695                                 sbuf_cat(&descrsb,
 696                                     head->so_proto->pr_domain->dom_name ?:
 697                                     "unknown");
 698                                 sbuf_finish(&descrsb);
 699                         }
 700                         KASSERT(sbuf_len(&descrsb) > 0,
 701                             ("%s: sbuf creation failed", __func__));
 702                         /*
 703                          * Preserve the historic listen queue overflow log
 704                          * message, that starts with "sonewconn:".  It has
 705                          * been known to sysadmins for years and also test
 706                          * sys/kern/sonewconn_overflow checks for it.
 707                          */
 708                         if (head->so_cred == 0) {
 709                                 log(LOG_DEBUG, "sonewconn: pcb %p (%s): "
 710                                     "Listen queue overflow: %i already in "
 711                                     "queue awaiting acceptance (%d "
 712                                     "occurrences)\n", head->so_pcb,
 713                                     sbuf_data(&descrsb),
 714                                 qlen, overcount);
 715                         } else {
 716                                 log(LOG_DEBUG, "sonewconn: pcb %p (%s): "
 717                                     "Listen queue overflow: "
 718                                     "%i already in queue awaiting acceptance "
 719                                     "(%d occurrences), euid %d, rgid %d, jail %s\n",
 720                                     head->so_pcb, sbuf_data(&descrsb), qlen,
 721                                     overcount, head->so_cred->cr_uid,
 722                                     head->so_cred->cr_rgid,
 723                                     head->so_cred->cr_prison ?
 724                                         head->so_cred->cr_prison->pr_name :
 725                                         "not_jailed");
 726                         }
 727                         sbuf_delete(&descrsb);
 728
 729                         overcount = 0;
 730                 }
 731
 732                 return (NULL);
 733         }
 734         SOLISTEN_UNLOCK(head);
 735         VNET_ASSERT(head->so_vnet != NULL, ("%s: so %p vnet is NULL",
 736             __func__, head));
 737         so = soalloc(head->so_vnet);
 738         if (so == NULL) {
 739                 log(LOG_DEBUG, "%s: pcb %p: New socket allocation failure: "
 740                     "limit reached or out of memory\n",
 741                     __func__, head->so_pcb);
 742                 return (NULL);
 743         }
 744         so->so_listen = head;
 745         so->so_type = head->so_type;
 746         so->so_options = head->so_options & ~SO_ACCEPTCONN;
 747         so->so_linger = head->so_linger;
 748         so->so_state = head->so_state;
 749         so->so_fibnum = head->so_fibnum;
 750         so->so_proto = head->so_proto;
 751         so->so_cred = crhold(head->so_cred);
 752 #ifdef MAC
 753         mac_socket_newconn(head, so);
 754 #endif
 755         knlist_init(&so->so_rdsel.si_note, so, so_rdknl_lock, so_rdknl_unlock,
 756             so_rdknl_assert_lock);
 757         knlist_init(&so->so_wrsel.si_note, so, so_wrknl_lock, so_wrknl_unlock,
 758             so_wrknl_assert_lock);
 759         VNET_SO_ASSERT(head);
 760         if (soreserve(so, head->sol_sbsnd_hiwat, head->sol_sbrcv_hiwat)) {
 761                 sodealloc(so);
 762                 log(LOG_DEBUG, "%s: pcb %p: soreserve() failed\n",
 763                     __func__, head->so_pcb);
 764                 return (NULL);
 765         }
 766         so->so_rcv.sb_lowat = head->sol_sbrcv_lowat;
 767         so->so_snd.sb_lowat = head->sol_sbsnd_lowat;
 768         so->so_rcv.sb_timeo = head->sol_sbrcv_timeo;
 769         so->so_snd.sb_timeo = head->sol_sbsnd_timeo;
 770         so->so_rcv.sb_flags = head->sol_sbrcv_flags & SB_AUTOSIZE;
 771         so->so_snd.sb_flags = head->sol_sbsnd_flags & SB_AUTOSIZE;
 772         if ((so->so_proto->pr_flags & PR_SOCKBUF) == 0) {
 773                 so->so_snd.sb_mtx = &so->so_snd_mtx;
 774                 so->so_rcv.sb_mtx = &so->so_rcv_mtx;
 775         }
 776
 777         return (so);
 778 }
 779
 780 /* Connstatus may be 0, or SS_ISCONFIRMING, or SS_ISCONNECTED. */
 781 struct socket *
 782 sonewconn(struct socket *head, int connstatus)
 783 {
 784         struct socket *so;
 785
 786         if ((so = solisten_clone(head)) == NULL)
 787                 return (NULL);
 788
 789         if (so->so_proto->pr_attach(so, 0, NULL) != 0) {
 790                 sodealloc(so);
 791                 log(LOG_DEBUG, "%s: pcb %p: pr_attach() failed\n",
 792                     __func__, head->so_pcb);
 793                 return (NULL);
 794         }
 795
 796         (void)solisten_enqueue(so, connstatus);
 797
 798         return (so);
 799 }
 800
 801 /*
 802  * Enqueue socket cloned by solisten_clone() to the listen queue of the
 803  * listener it has been cloned from.
 804  *
 805  * Return 'true' if socket landed on complete queue, otherwise 'false'.
 806  */
 807 bool
 808 solisten_enqueue(struct socket *so, int connstatus)
 809 {
 810         struct socket *head = so->so_listen;
 811
 812         MPASS(refcount_load(&so->so_count) == 0);
 813         refcount_init(&so->so_count, 1);
 814
 815         SOLISTEN_LOCK(head);
 816         if (head->sol_accept_filter != NULL)
 817                 connstatus = 0;
 818         so->so_state |= connstatus;
 819         soref(head); /* A socket on (in)complete queue refs head. */
 820         if (connstatus) {
 821                 TAILQ_INSERT_TAIL(&head->sol_comp, so, so_list);
 822                 so->so_qstate = SQ_COMP;
 823                 head->sol_qlen++;
 824                 solisten_wakeup(head);  /* unlocks */
 825                 return (true);
 826         } else {
 827                 /*
 828                  * Keep removing sockets from the head until there's room for
 829                  * us to insert on the tail.  In pre-locking revisions, this
 830                  * was a simple if(), but as we could be racing with other
 831                  * threads and soabort() requires dropping locks, we must
 832                  * loop waiting for the condition to be true.
 833                  */
 834                 while (head->sol_incqlen > head->sol_qlimit) {
 835                         struct socket *sp;
 836
 837                         sp = TAILQ_FIRST(&head->sol_incomp);
 838                         TAILQ_REMOVE(&head->sol_incomp, sp, so_list);
 839                         head->sol_incqlen--;
 840                         SOCK_LOCK(sp);
 841                         sp->so_qstate = SQ_NONE;
 842                         sp->so_listen = NULL;
 843                         SOCK_UNLOCK(sp);
 844                         sorele_locked(head);    /* does SOLISTEN_UNLOCK, head stays */
 845                         soabort(sp);
 846                         SOLISTEN_LOCK(head);
 847                 }
 848                 TAILQ_INSERT_TAIL(&head->sol_incomp, so, so_list);
 849                 so->so_qstate = SQ_INCOMP;
 850                 head->sol_incqlen++;
 851                 SOLISTEN_UNLOCK(head);
 852                 return (false);
 853         }
 854 }
 855
 856 #if defined(SCTP) || defined(SCTP_SUPPORT)
 857 /*
 858  * Socket part of sctp_peeloff().  Detach a new socket from an
 859  * association.  The new socket is returned with a reference.
 860  *
 861  * XXXGL: reduce copy-paste with solisten_clone().
 862  */
 863 struct socket *
 864 sopeeloff(struct socket *head)
 865 {
 866         struct socket *so;
 867
 868         VNET_ASSERT(head->so_vnet != NULL, ("%s:%d so_vnet is NULL, head=%p",
 869             __func__, __LINE__, head));
 870         so = soalloc(head->so_vnet);
 871         if (so == NULL) {
 872                 log(LOG_DEBUG, "%s: pcb %p: New socket allocation failure: "
 873                     "limit reached or out of memory\n",
 874                     __func__, head->so_pcb);
 875                 return (NULL);
 876         }
 877         so->so_type = head->so_type;
 878         so->so_options = head->so_options;
 879         so->so_linger = head->so_linger;
 880         so->so_state = (head->so_state & SS_NBIO) | SS_ISCONNECTED;
 881         so->so_fibnum = head->so_fibnum;
 882         so->so_proto = head->so_proto;
 883         so->so_cred = crhold(head->so_cred);
 884 #ifdef MAC
 885         mac_socket_newconn(head, so);
 886 #endif
 887         knlist_init(&so->so_rdsel.si_note, so, so_rdknl_lock, so_rdknl_unlock,
 888             so_rdknl_assert_lock);
 889         knlist_init(&so->so_wrsel.si_note, so, so_wrknl_lock, so_wrknl_unlock,
 890             so_wrknl_assert_lock);
 891         VNET_SO_ASSERT(head);
 892         if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat)) {
 893                 sodealloc(so);
 894                 log(LOG_DEBUG, "%s: pcb %p: soreserve() failed\n",
 895                     __func__, head->so_pcb);
 896                 return (NULL);
 897         }
 898         if ((*so->so_proto->pr_attach)(so, 0, NULL)) {
 899                 sodealloc(so);
 900                 log(LOG_DEBUG, "%s: pcb %p: pru_attach() failed\n",
 901                     __func__, head->so_pcb);
 902                 return (NULL);
 903         }
 904         so->so_rcv.sb_lowat = head->so_rcv.sb_lowat;
 905         so->so_snd.sb_lowat = head->so_snd.sb_lowat;
 906         so->so_rcv.sb_timeo = head->so_rcv.sb_timeo;
 907         so->so_snd.sb_timeo = head->so_snd.sb_timeo;
 908         so->so_rcv.sb_flags |= head->so_rcv.sb_flags & SB_AUTOSIZE;
 909         so->so_snd.sb_flags |= head->so_snd.sb_flags & SB_AUTOSIZE;
 910
 911         soref(so);
 912
 913         return (so);
 914 }
 915 #endif  /* SCTP */
 916
 917 int
 918 sobind(struct socket *so, struct sockaddr *nam, struct thread *td)
 919 {
 920         int error;
 921
 922         CURVNET_SET(so->so_vnet);
 923         error = so->so_proto->pr_bind(so, nam, td);
 924         CURVNET_RESTORE();
 925         return (error);
 926 }
 927
 928 int
 929 sobindat(int fd, struct socket *so, struct sockaddr *nam, struct thread *td)
 930 {
 931         int error;
 932
 933         CURVNET_SET(so->so_vnet);
 934         error = so->so_proto->pr_bindat(fd, so, nam, td);
 935         CURVNET_RESTORE();
 936         return (error);
 937 }
 938
 939 /*
 940  * solisten() transitions a socket from a non-listening state to a listening
 941  * state, but can also be used to update the listen queue depth on an
 942  * existing listen socket.  The protocol will call back into the sockets
 943  * layer using solisten_proto_check() and solisten_proto() to check and set
 944  * socket-layer listen state.  Call backs are used so that the protocol can
 945  * acquire both protocol and socket layer locks in whatever order is required
 946  * by the protocol.
 947  *
 948  * Protocol implementors are advised to hold the socket lock across the
 949  * socket-layer test and set to avoid races at the socket layer.
 950  */
 951 int
 952 solisten(struct socket *so, int backlog, struct thread *td)
 953 {
 954         int error;
 955
 956         CURVNET_SET(so->so_vnet);
 957         error = so->so_proto->pr_listen(so, backlog, td);
 958         CURVNET_RESTORE();
 959         return (error);
 960 }
 961
 962 /*
 963  * Prepare for a call to solisten_proto().  Acquire all socket buffer locks in
 964  * order to interlock with socket I/O.
 965  */
 966 int
 967 solisten_proto_check(struct socket *so)
 968 {
 969         SOCK_LOCK_ASSERT(so);
 970
 971         if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
 972             SS_ISDISCONNECTING)) != 0)
 973                 return (EINVAL);
 974
 975         /*
 976          * Sleeping is not permitted here, so simply fail if userspace is
 977          * attempting to transmit or receive on the socket.  This kind of
 978          * transient failure is not ideal, but it should occur only if userspace
 979          * is misusing the socket interfaces.
 980          */
 981         if (!sx_try_xlock(&so->so_snd_sx))
 982                 return (EAGAIN);
 983         if (!sx_try_xlock(&so->so_rcv_sx)) {
 984                 sx_xunlock(&so->so_snd_sx);
 985                 return (EAGAIN);
 986         }
 987         mtx_lock(&so->so_snd_mtx);
 988         mtx_lock(&so->so_rcv_mtx);
 989
 990         /* Interlock with soo_aio_queue(). */
 991         if (!SOLISTENING(so) &&
 992            ((so->so_snd.sb_flags & (SB_AIO | SB_AIO_RUNNING)) != 0 ||
 993            (so->so_rcv.sb_flags & (SB_AIO | SB_AIO_RUNNING)) != 0)) {
 994                 solisten_proto_abort(so);
 995                 return (EINVAL);
 996         }
 997         return (0);
 998 }
 999
1000 /*
1001  * Undo the setup done by solisten_proto_check().
1002  */
1003 void
1004 solisten_proto_abort(struct socket *so)
1005 {
1006         mtx_unlock(&so->so_snd_mtx);
1007         mtx_unlock(&so->so_rcv_mtx);
1008         sx_xunlock(&so->so_snd_sx);
1009         sx_xunlock(&so->so_rcv_sx);
1010 }
1011
1012 void
1013 solisten_proto(struct socket *so, int backlog)
1014 {
1015         int sbrcv_lowat, sbsnd_lowat;
1016         u_int sbrcv_hiwat, sbsnd_hiwat;
1017         short sbrcv_flags, sbsnd_flags;
1018         sbintime_t sbrcv_timeo, sbsnd_timeo;
1019
1020         SOCK_LOCK_ASSERT(so);
1021         KASSERT((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
1022             SS_ISDISCONNECTING)) == 0,
1023             ("%s: bad socket state %p", __func__, so));
1024
1025         if (SOLISTENING(so))
1026                 goto listening;
1027
1028         /*
1029          * Change this socket to listening state.
1030          */
1031         sbrcv_lowat = so->so_rcv.sb_lowat;
1032         sbsnd_lowat = so->so_snd.sb_lowat;
1033         sbrcv_hiwat = so->so_rcv.sb_hiwat;
1034         sbsnd_hiwat = so->so_snd.sb_hiwat;
1035         sbrcv_flags = so->so_rcv.sb_flags;
1036         sbsnd_flags = so->so_snd.sb_flags;
1037         sbrcv_timeo = so->so_rcv.sb_timeo;
1038         sbsnd_timeo = so->so_snd.sb_timeo;
1039
1040         sbdestroy(so, SO_SND);
1041         sbdestroy(so, SO_RCV);
1042
1043 #ifdef INVARIANTS
1044         bzero(&so->so_rcv,
1045             sizeof(struct socket) - offsetof(struct socket, so_rcv));
1046 #endif
1047
1048         so->sol_sbrcv_lowat = sbrcv_lowat;
1049         so->sol_sbsnd_lowat = sbsnd_lowat;
1050         so->sol_sbrcv_hiwat = sbrcv_hiwat;
1051         so->sol_sbsnd_hiwat = sbsnd_hiwat;
1052         so->sol_sbrcv_flags = sbrcv_flags;
1053         so->sol_sbsnd_flags = sbsnd_flags;
1054         so->sol_sbrcv_timeo = sbrcv_timeo;
1055         so->sol_sbsnd_timeo = sbsnd_timeo;
1056
1057         so->sol_qlen = so->sol_incqlen = 0;
1058         TAILQ_INIT(&so->sol_incomp);
1059         TAILQ_INIT(&so->sol_comp);
1060
1061         so->sol_accept_filter = NULL;
1062         so->sol_accept_filter_arg = NULL;
1063         so->sol_accept_filter_str = NULL;
1064
1065         so->sol_upcall = NULL;
1066         so->sol_upcallarg = NULL;
1067
1068         so->so_options |= SO_ACCEPTCONN;
1069
1070 listening:
1071         if (backlog < 0 || backlog > somaxconn)
1072                 backlog = somaxconn;
1073         so->sol_qlimit = backlog;
1074
1075         mtx_unlock(&so->so_snd_mtx);
1076         mtx_unlock(&so->so_rcv_mtx);
1077         sx_xunlock(&so->so_snd_sx);
1078         sx_xunlock(&so->so_rcv_sx);
1079 }
1080
1081 /*
1082  * Wakeup listeners/subsystems once we have a complete connection.
1083  * Enters with lock, returns unlocked.
1084  */
1085 void
1086 solisten_wakeup(struct socket *sol)
1087 {
1088
1089         if (sol->sol_upcall != NULL)
1090                 (void )sol->sol_upcall(sol, sol->sol_upcallarg, M_NOWAIT);
1091         else {
1092                 selwakeuppri(&sol->so_rdsel, PSOCK);
1093                 KNOTE_LOCKED(&sol->so_rdsel.si_note, 0);
1094         }
1095         SOLISTEN_UNLOCK(sol);
1096         wakeup_one(&sol->sol_comp);
1097         if ((sol->so_state & SS_ASYNC) && sol->so_sigio != NULL)
1098                 pgsigio(&sol->so_sigio, SIGIO, 0);
1099 }
1100
1101 /*
1102  * Return single connection off a listening socket queue.  Main consumer of
1103  * the function is kern_accept4().  Some modules, that do their own accept
1104  * management also use the function.  The socket reference held by the
1105  * listen queue is handed to the caller.
1106  *
1107  * Listening socket must be locked on entry and is returned unlocked on
1108  * return.
1109  * The flags argument is set of accept4(2) flags and ACCEPT4_INHERIT.
1110  */
1111 int
1112 solisten_dequeue(struct socket *head, struct socket **ret, int flags)
1113 {
1114         struct socket *so;
1115         int error;
1116
1117         SOLISTEN_LOCK_ASSERT(head);
1118
1119         while (!(head->so_state & SS_NBIO) && TAILQ_EMPTY(&head->sol_comp) &&
1120             head->so_error == 0) {
1121                 error = msleep(&head->sol_comp, SOCK_MTX(head), PSOCK | PCATCH,
1122                     "accept", 0);
1123                 if (error != 0) {
1124                         SOLISTEN_UNLOCK(head);
1125                         return (error);
1126                 }
1127         }
1128         if (head->so_error) {
1129                 error = head->so_error;
1130                 head->so_error = 0;
1131         } else if ((head->so_state & SS_NBIO) && TAILQ_EMPTY(&head->sol_comp))
1132                 error = EWOULDBLOCK;
1133         else
1134                 error = 0;
1135         if (error) {
1136                 SOLISTEN_UNLOCK(head);
1137                 return (error);
1138         }
1139         so = TAILQ_FIRST(&head->sol_comp);
1140         SOCK_LOCK(so);
1141         KASSERT(so->so_qstate == SQ_COMP,
1142             ("%s: so %p not SQ_COMP", __func__, so));
1143         head->sol_qlen--;
1144         so->so_qstate = SQ_NONE;
1145         so->so_listen = NULL;
1146         TAILQ_REMOVE(&head->sol_comp, so, so_list);
1147         if (flags & ACCEPT4_INHERIT)
1148                 so->so_state |= (head->so_state & SS_NBIO);
1149         else
1150                 so->so_state |= (flags & SOCK_NONBLOCK) ? SS_NBIO : 0;
1151         SOCK_UNLOCK(so);
1152         sorele_locked(head);
1153
1154         *ret = so;
1155         return (0);
1156 }
1157
1158 /*
1159  * Free socket upon release of the very last reference.
1160  */
1161 static void
1162 sofree(struct socket *so)
1163 {
1164         struct protosw *pr = so->so_proto;
1165
1166         SOCK_LOCK_ASSERT(so);
1167         KASSERT(refcount_load(&so->so_count) == 0,
1168             ("%s: so %p has references", __func__, so));
1169         KASSERT(SOLISTENING(so) || so->so_qstate == SQ_NONE,
1170             ("%s: so %p is on listen queue", __func__, so));
1171
1172         SOCK_UNLOCK(so);
1173
1174         if (so->so_dtor != NULL)
1175                 so->so_dtor(so);
1176
1177         VNET_SO_ASSERT(so);
1178         if ((pr->pr_flags & PR_RIGHTS) && !SOLISTENING(so)) {
1179                 MPASS(pr->pr_domain->dom_dispose != NULL);
1180                 (*pr->pr_domain->dom_dispose)(so);
1181         }
1182         if (pr->pr_detach != NULL)
1183                 pr->pr_detach(so);
1184
1185         /*
1186          * From this point on, we assume that no other references to this
1187          * socket exist anywhere else in the stack.  Therefore, no locks need
1188          * to be acquired or held.
1189          */
1190         if (!(pr->pr_flags & PR_SOCKBUF) && !SOLISTENING(so)) {
1191                 sbdestroy(so, SO_SND);
1192                 sbdestroy(so, SO_RCV);
1193         }
1194         seldrain(&so->so_rdsel);
1195         seldrain(&so->so_wrsel);
1196         knlist_destroy(&so->so_rdsel.si_note);
1197         knlist_destroy(&so->so_wrsel.si_note);
1198         sodealloc(so);
1199 }
1200
1201 /*
1202  * Release a reference on a socket while holding the socket lock.
1203  * Unlocks the socket lock before returning.
1204  */
1205 void
1206 sorele_locked(struct socket *so)
1207 {
1208         SOCK_LOCK_ASSERT(so);
1209         if (refcount_release(&so->so_count))
1210                 sofree(so);
1211         else
1212                 SOCK_UNLOCK(so);
1213 }
1214
1215 /*
1216  * Close a socket on last file table reference removal.  Initiate disconnect
1217  * if connected.  Free socket when disconnect complete.
1218  *
1219  * This function will sorele() the socket.  Note that soclose() may be called
1220  * prior to the ref count reaching zero.  The actual socket structure will
1221  * not be freed until the ref count reaches zero.
1222  */
1223 int
1224 soclose(struct socket *so)
1225 {
1226         struct accept_queue lqueue;
1227         int error = 0;
1228         bool listening, last __diagused;
1229
1230         CURVNET_SET(so->so_vnet);
1231         funsetown(&so->so_sigio);
1232         if (so->so_state & SS_ISCONNECTED) {
1233                 if ((so->so_state & SS_ISDISCONNECTING) == 0) {
1234                         error = sodisconnect(so);
1235                         if (error) {
1236                                 if (error == ENOTCONN)
1237                                         error = 0;
1238                                 goto drop;
1239                         }
1240                 }
1241
1242                 if ((so->so_options & SO_LINGER) != 0 && so->so_linger != 0) {
1243                         if ((so->so_state & SS_ISDISCONNECTING) &&
1244                             (so->so_state & SS_NBIO))
1245                                 goto drop;
1246                         while (so->so_state & SS_ISCONNECTED) {
1247                                 error = tsleep(&so->so_timeo,
1248                                     PSOCK | PCATCH, "soclos",
1249                                     so->so_linger * hz);
1250                                 if (error)
1251                                         break;
1252                         }
1253                 }
1254         }
1255
1256 drop:
1257         if (so->so_proto->pr_close != NULL)
1258                 so->so_proto->pr_close(so);
1259
1260         SOCK_LOCK(so);
1261         if ((listening = SOLISTENING(so))) {
1262                 struct socket *sp;
1263
1264                 TAILQ_INIT(&lqueue);
1265                 TAILQ_SWAP(&lqueue, &so->sol_incomp, socket, so_list);
1266                 TAILQ_CONCAT(&lqueue, &so->sol_comp, so_list);
1267
1268                 so->sol_qlen = so->sol_incqlen = 0;
1269
1270                 TAILQ_FOREACH(sp, &lqueue, so_list) {
1271                         SOCK_LOCK(sp);
1272                         sp->so_qstate = SQ_NONE;
1273                         sp->so_listen = NULL;
1274                         SOCK_UNLOCK(sp);
1275                         last = refcount_release(&so->so_count);
1276                         KASSERT(!last, ("%s: released last reference for %p",
1277                             __func__, so));
1278                 }
1279         }
1280         sorele_locked(so);
1281         if (listening) {
1282                 struct socket *sp, *tsp;
1283
1284                 TAILQ_FOREACH_SAFE(sp, &lqueue, so_list, tsp)
1285                         soabort(sp);
1286         }
1287         CURVNET_RESTORE();
1288         return (error);
1289 }
1290
1291 /*
1292  * soabort() is used to abruptly tear down a connection, such as when a
1293  * resource limit is reached (listen queue depth exceeded), or if a listen
1294  * socket is closed while there are sockets waiting to be accepted.
1295  *
1296  * This interface is tricky, because it is called on an unreferenced socket,
1297  * and must be called only by a thread that has actually removed the socket
1298  * from the listen queue it was on.  Likely this thread holds the last
1299  * reference on the socket and soabort() will proceed with sofree().  But
1300  * it might be not the last, as the sockets on the listen queues are seen
1301  * from the protocol side.
1302  *
1303  * This interface will call into the protocol code, so must not be called
1304  * with any socket locks held.  Protocols do call it while holding their own
1305  * recursible protocol mutexes, but this is something that should be subject
1306  * to review in the future.
1307  *
1308  * Usually socket should have a single reference left, but this is not a
1309  * requirement.  In the past, when we have had named references for file
1310  * descriptor and protocol, we asserted that none of them are being held.
1311  */
1312 void
1313 soabort(struct socket *so)
1314 {
1315
1316         VNET_SO_ASSERT(so);
1317
1318         if (so->so_proto->pr_abort != NULL)
1319                 so->so_proto->pr_abort(so);
1320         SOCK_LOCK(so);
1321         sorele_locked(so);
1322 }
1323
1324 int
1325 soaccept(struct socket *so, struct sockaddr **nam)
1326 {
1327         int error;
1328
1329         CURVNET_SET(so->so_vnet);
1330         error = so->so_proto->pr_accept(so, nam);
1331         CURVNET_RESTORE();
1332         return (error);
1333 }
1334
1335 int
1336 soconnect(struct socket *so, struct sockaddr *nam, struct thread *td)
1337 {
1338
1339         return (soconnectat(AT_FDCWD, so, nam, td));
1340 }
1341
1342 int
1343 soconnectat(int fd, struct socket *so, struct sockaddr *nam, struct thread *td)
1344 {
1345         int error;
1346
1347         CURVNET_SET(so->so_vnet);
1348         /*
1349          * If protocol is connection-based, can only connect once.
1350          * Otherwise, if connected, try to disconnect first.  This allows
1351          * user to disconnect by connecting to, e.g., a null address.
1352          */
1353         if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
1354             ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
1355             (error = sodisconnect(so)))) {
1356                 error = EISCONN;
1357         } else {
1358                 /*
1359                  * Prevent accumulated error from previous connection from
1360                  * biting us.
1361                  */
1362                 so->so_error = 0;
1363                 if (fd == AT_FDCWD) {
1364                         error = so->so_proto->pr_connect(so, nam, td);
1365                 } else {
1366                         error = so->so_proto->pr_connectat(fd, so, nam, td);
1367                 }
1368         }
1369         CURVNET_RESTORE();
1370
1371         return (error);
1372 }
1373
1374 int
1375 soconnect2(struct socket *so1, struct socket *so2)
1376 {
1377         int error;
1378
1379         CURVNET_SET(so1->so_vnet);
1380         error = so1->so_proto->pr_connect2(so1, so2);
1381         CURVNET_RESTORE();
1382         return (error);
1383 }
1384
1385 int
1386 sodisconnect(struct socket *so)
1387 {
1388         int error;
1389
1390         if ((so->so_state & SS_ISCONNECTED) == 0)
1391                 return (ENOTCONN);
1392         if (so->so_state & SS_ISDISCONNECTING)
1393                 return (EALREADY);
1394         VNET_SO_ASSERT(so);
1395         error = so->so_proto->pr_disconnect(so);
1396         return (error);
1397 }
1398
1399 int
1400 sosend_dgram(struct socket *so, struct sockaddr *addr, struct uio *uio,
1401     struct mbuf *top, struct mbuf *control, int flags, struct thread *td)
1402 {
1403         long space;
1404         ssize_t resid;
1405         int clen = 0, error, dontroute;
1406
1407         KASSERT(so->so_type == SOCK_DGRAM, ("sosend_dgram: !SOCK_DGRAM"));
1408         KASSERT(so->so_proto->pr_flags & PR_ATOMIC,
1409             ("sosend_dgram: !PR_ATOMIC"));
1410
1411         if (uio != NULL)
1412                 resid = uio->uio_resid;
1413         else
1414                 resid = top->m_pkthdr.len;
1415         /*
1416          * In theory resid should be unsigned.  However, space must be
1417          * signed, as it might be less than 0 if we over-committed, and we
1418          * must use a signed comparison of space and resid.  On the other
1419          * hand, a negative resid causes us to loop sending 0-length
1420          * segments to the protocol.
1421          */
1422         if (resid < 0) {
1423                 error = EINVAL;
1424                 goto out;
1425         }
1426
1427         dontroute =
1428             (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0;
1429         if (td != NULL)
1430                 td->td_ru.ru_msgsnd++;
1431         if (control != NULL)
1432                 clen = control->m_len;
1433
1434         SOCKBUF_LOCK(&so->so_snd);
1435         if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
1436                 SOCKBUF_UNLOCK(&so->so_snd);
1437                 error = EPIPE;
1438                 goto out;
1439         }
1440         if (so->so_error) {
1441                 error = so->so_error;
1442                 so->so_error = 0;
1443                 SOCKBUF_UNLOCK(&so->so_snd);
1444                 goto out;
1445         }
1446         if ((so->so_state & SS_ISCONNECTED) == 0) {
1447                 /*
1448                  * `sendto' and `sendmsg' is allowed on a connection-based
1449                  * socket if it supports implied connect.  Return ENOTCONN if
1450                  * not connected and no address is supplied.
1451                  */
1452                 if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
1453                     (so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
1454                         if ((so->so_state & SS_ISCONFIRMING) == 0 &&
1455                             !(resid == 0 && clen != 0)) {
1456                                 SOCKBUF_UNLOCK(&so->so_snd);
1457                                 error = ENOTCONN;
1458                                 goto out;
1459                         }
1460                 } else if (addr == NULL) {
1461                         if (so->so_proto->pr_flags & PR_CONNREQUIRED)
1462                                 error = ENOTCONN;
1463                         else
1464                                 error = EDESTADDRREQ;
1465                         SOCKBUF_UNLOCK(&so->so_snd);
1466                         goto out;
1467                 }
1468         }
1469
1470         /*
1471          * Do we need MSG_OOB support in SOCK_DGRAM?  Signs here may be a
1472          * problem and need fixing.
1473          */
1474         space = sbspace(&so->so_snd);
1475         if (flags & MSG_OOB)
1476                 space += 1024;
1477         space -= clen;
1478         SOCKBUF_UNLOCK(&so->so_snd);
1479         if (resid > space) {
1480                 error = EMSGSIZE;
1481                 goto out;
1482         }
1483         if (uio == NULL) {
1484                 resid = 0;
1485                 if (flags & MSG_EOR)
1486                         top->m_flags |= M_EOR;
1487         } else {
1488                 /*
1489                  * Copy the data from userland into a mbuf chain.
1490                  * If no data is to be copied in, a single empty mbuf
1491                  * is returned.
1492                  */
1493                 top = m_uiotombuf(uio, M_WAITOK, space, max_hdr,
1494                     (M_PKTHDR | ((flags & MSG_EOR) ? M_EOR : 0)));
1495                 if (top == NULL) {
1496                         error = EFAULT; /* only possible error */
1497                         goto out;
1498                 }
1499                 space -= resid - uio->uio_resid;
1500                 resid = uio->uio_resid;
1501         }
1502         KASSERT(resid == 0, ("sosend_dgram: resid != 0"));
1503         /*
1504          * XXXRW: Frobbing SO_DONTROUTE here is even worse without sblock
1505          * than with.
1506          */
1507         if (dontroute) {
1508                 SOCK_LOCK(so);
1509                 so->so_options |= SO_DONTROUTE;
1510                 SOCK_UNLOCK(so);
1511         }
1512         /*
1513          * XXX all the SBS_CANTSENDMORE checks previously done could be out
1514          * of date.  We could have received a reset packet in an interrupt or
1515          * maybe we slept while doing page faults in uiomove() etc.  We could
1516          * probably recheck again inside the locking protection here, but
1517          * there are probably other places that this also happens.  We must
1518          * rethink this.
1519          */
1520         VNET_SO_ASSERT(so);
1521         error = so->so_proto->pr_send(so, (flags & MSG_OOB) ? PRUS_OOB :
1522         /*
1523          * If the user set MSG_EOF, the protocol understands this flag and
1524          * nothing left to send then use PRU_SEND_EOF instead of PRU_SEND.
1525          */
1526             ((flags & MSG_EOF) &&
1527              (so->so_proto->pr_flags & PR_IMPLOPCL) &&
1528              (resid <= 0)) ?
1529                 PRUS_EOF :
1530                 /* If there is more to send set PRUS_MORETOCOME */
1531                 (flags & MSG_MORETOCOME) ||
1532                 (resid > 0 && space > 0) ? PRUS_MORETOCOME : 0,
1533                 top, addr, control, td);
1534         if (dontroute) {
1535                 SOCK_LOCK(so);
1536                 so->so_options &= ~SO_DONTROUTE;
1537                 SOCK_UNLOCK(so);
1538         }
1539         clen = 0;
1540         control = NULL;
1541         top = NULL;
1542 out:
1543         if (top != NULL)
1544                 m_freem(top);
1545         if (control != NULL)
1546                 m_freem(control);
1547         return (error);
1548 }
1549
1550 /*
1551  * Send on a socket.  If send must go all at once and message is larger than
1552  * send buffering, then hard error.  Lock against other senders.  If must go
1553  * all at once and not enough room now, then inform user that this would
1554  * block and do nothing.  Otherwise, if nonblocking, send as much as
1555  * possible.  The data to be sent is described by "uio" if nonzero, otherwise
1556  * by the mbuf chain "top" (which must be null if uio is not).  Data provided
1557  * in mbuf chain must be small enough to send all at once.
1558  *
1559  * Returns nonzero on error, timeout or signal; callers must check for short
1560  * counts if EINTR/ERESTART are returned.  Data and control buffers are freed
1561  * on return.
1562  */
1563 int
1564 sosend_generic(struct socket *so, struct sockaddr *addr, struct uio *uio,
1565     struct mbuf *top, struct mbuf *control, int flags, struct thread *td)
1566 {
1567         long space;
1568         ssize_t resid;
1569         int clen = 0, error, dontroute;
1570         int atomic = sosendallatonce(so) || top;
1571         int pr_send_flag;
1572 #ifdef KERN_TLS
1573         struct ktls_session *tls;
1574         int tls_enq_cnt, tls_send_flag;
1575         uint8_t tls_rtype;
1576
1577         tls = NULL;
1578         tls_rtype = TLS_RLTYPE_APP;
1579 #endif
1580         if (uio != NULL)
1581                 resid = uio->uio_resid;
1582         else if ((top->m_flags & M_PKTHDR) != 0)
1583                 resid = top->m_pkthdr.len;
1584         else
1585                 resid = m_length(top, NULL);
1586         /*
1587          * In theory resid should be unsigned.  However, space must be
1588          * signed, as it might be less than 0 if we over-committed, and we
1589          * must use a signed comparison of space and resid.  On the other
1590          * hand, a negative resid causes us to loop sending 0-length
1591          * segments to the protocol.
1592          *
1593          * Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
1594          * type sockets since that's an error.
1595          */
1596         if (resid < 0 || (so->so_type == SOCK_STREAM && (flags & MSG_EOR))) {
1597                 error = EINVAL;
1598                 goto out;
1599         }
1600
1601         dontroute =
1602             (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
1603             (so->so_proto->pr_flags & PR_ATOMIC);
1604         if (td != NULL)
1605                 td->td_ru.ru_msgsnd++;
1606         if (control != NULL)
1607                 clen = control->m_len;
1608
1609         error = SOCK_IO_SEND_LOCK(so, SBLOCKWAIT(flags));
1610         if (error)
1611                 goto out;
1612
1613 #ifdef KERN_TLS
1614         tls_send_flag = 0;
1615         tls = ktls_hold(so->so_snd.sb_tls_info);
1616         if (tls != NULL) {
1617                 if (tls->mode == TCP_TLS_MODE_SW)
1618                         tls_send_flag = PRUS_NOTREADY;
1619
1620                 if (control != NULL) {
1621                         struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1622
1623                         if (clen >= sizeof(*cm) &&
1624                             cm->cmsg_type == TLS_SET_RECORD_TYPE) {
1625                                 tls_rtype = *((uint8_t *)CMSG_DATA(cm));
1626                                 clen = 0;
1627                                 m_freem(control);
1628                                 control = NULL;
1629                                 atomic = 1;
1630                         }
1631                 }
1632
1633                 if (resid == 0 && !ktls_permit_empty_frames(tls)) {
1634                         error = EINVAL;
1635                         goto release;
1636                 }
1637         }
1638 #endif
1639
1640 restart:
1641         do {
1642                 SOCKBUF_LOCK(&so->so_snd);
1643                 if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
1644                         SOCKBUF_UNLOCK(&so->so_snd);
1645                         error = EPIPE;
1646                         goto release;
1647                 }
1648                 if (so->so_error) {
1649                         error = so->so_error;
1650                         so->so_error = 0;
1651                         SOCKBUF_UNLOCK(&so->so_snd);
1652                         goto release;
1653                 }
1654                 if ((so->so_state & SS_ISCONNECTED) == 0) {
1655                         /*
1656                          * `sendto' and `sendmsg' is allowed on a connection-
1657                          * based socket if it supports implied connect.
1658                          * Return ENOTCONN if not connected and no address is
1659                          * supplied.
1660                          */
1661                         if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
1662                             (so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
1663                                 if ((so->so_state & SS_ISCONFIRMING) == 0 &&
1664                                     !(resid == 0 && clen != 0)) {
1665                                         SOCKBUF_UNLOCK(&so->so_snd);
1666                                         error = ENOTCONN;
1667                                         goto release;
1668                                 }
1669                         } else if (addr == NULL) {
1670                                 SOCKBUF_UNLOCK(&so->so_snd);
1671                                 if (so->so_proto->pr_flags & PR_CONNREQUIRED)
1672                                         error = ENOTCONN;
1673                                 else
1674                                         error = EDESTADDRREQ;
1675                                 goto release;
1676                         }
1677                 }
1678                 space = sbspace(&so->so_snd);
1679                 if (flags & MSG_OOB)
1680                         space += 1024;
1681                 if ((atomic && resid > so->so_snd.sb_hiwat) ||
1682                     clen > so->so_snd.sb_hiwat) {
1683                         SOCKBUF_UNLOCK(&so->so_snd);
1684                         error = EMSGSIZE;
1685                         goto release;
1686                 }
1687                 if (space < resid + clen &&
1688                     (atomic || space < so->so_snd.sb_lowat || space < clen)) {
1689                         if ((so->so_state & SS_NBIO) ||
1690                             (flags & (MSG_NBIO | MSG_DONTWAIT)) != 0) {
1691                                 SOCKBUF_UNLOCK(&so->so_snd);
1692                                 error = EWOULDBLOCK;
1693                                 goto release;
1694                         }
1695                         error = sbwait(so, SO_SND);
1696                         SOCKBUF_UNLOCK(&so->so_snd);
1697                         if (error)
1698                                 goto release;
1699                         goto restart;
1700                 }
1701                 SOCKBUF_UNLOCK(&so->so_snd);
1702                 space -= clen;
1703                 do {
1704                         if (uio == NULL) {
1705                                 resid = 0;
1706                                 if (flags & MSG_EOR)
1707                                         top->m_flags |= M_EOR;
1708 #ifdef KERN_TLS
1709                                 if (tls != NULL) {
1710                                         ktls_frame(top, tls, &tls_enq_cnt,
1711                                             tls_rtype);
1712                                         tls_rtype = TLS_RLTYPE_APP;
1713                                 }
1714 #endif
1715                         } else {
1716                                 /*
1717                                  * Copy the data from userland into a mbuf
1718                                  * chain.  If resid is 0, which can happen
1719                                  * only if we have control to send, then
1720                                  * a single empty mbuf is returned.  This
1721                                  * is a workaround to prevent protocol send
1722                                  * methods to panic.
1723                                  */
1724 #ifdef KERN_TLS
1725                                 if (tls != NULL) {
1726                                         top = m_uiotombuf(uio, M_WAITOK, space,
1727                                             tls->params.max_frame_len,
1728                                             M_EXTPG |
1729                                             ((flags & MSG_EOR) ? M_EOR : 0));
1730                                         if (top != NULL) {
1731                                                 ktls_frame(top, tls,
1732                                                     &tls_enq_cnt, tls_rtype);
1733                                         }
1734                                         tls_rtype = TLS_RLTYPE_APP;
1735                                 } else
1736 #endif
1737                                         top = m_uiotombuf(uio, M_WAITOK, space,
1738                                             (atomic ? max_hdr : 0),
1739                                             (atomic ? M_PKTHDR : 0) |
1740                                             ((flags & MSG_EOR) ? M_EOR : 0));
1741                                 if (top == NULL) {
1742                                         error = EFAULT; /* only possible error */
1743                                         goto release;
1744                                 }
1745                                 space -= resid - uio->uio_resid;
1746                                 resid = uio->uio_resid;
1747                         }
1748                         if (dontroute) {
1749                                 SOCK_LOCK(so);
1750                                 so->so_options |= SO_DONTROUTE;
1751                                 SOCK_UNLOCK(so);
1752                         }
1753                         /*
1754                          * XXX all the SBS_CANTSENDMORE checks previously
1755                          * done could be out of date.  We could have received
1756                          * a reset packet in an interrupt or maybe we slept
1757                          * while doing page faults in uiomove() etc.  We
1758                          * could probably recheck again inside the locking
1759                          * protection here, but there are probably other
1760                          * places that this also happens.  We must rethink
1761                          * this.
1762                          */
1763                         VNET_SO_ASSERT(so);
1764
1765                         pr_send_flag = (flags & MSG_OOB) ? PRUS_OOB :
1766                         /*
1767                          * If the user set MSG_EOF, the protocol understands
1768                          * this flag and nothing left to send then use
1769                          * PRU_SEND_EOF instead of PRU_SEND.
1770                          */
1771                             ((flags & MSG_EOF) &&
1772                              (so->so_proto->pr_flags & PR_IMPLOPCL) &&
1773                              (resid <= 0)) ?
1774                                 PRUS_EOF :
1775                         /* If there is more to send set PRUS_MORETOCOME. */
1776                             (flags & MSG_MORETOCOME) ||
1777                             (resid > 0 && space > 0) ? PRUS_MORETOCOME : 0;
1778
1779 #ifdef KERN_TLS
1780                         pr_send_flag |= tls_send_flag;
1781 #endif
1782
1783                         error = so->so_proto->pr_send(so, pr_send_flag, top,
1784                             addr, control, td);
1785
1786                         if (dontroute) {
1787                                 SOCK_LOCK(so);
1788                                 so->so_options &= ~SO_DONTROUTE;
1789                                 SOCK_UNLOCK(so);
1790                         }
1791
1792 #ifdef KERN_TLS
1793                         if (tls != NULL && tls->mode == TCP_TLS_MODE_SW) {
1794                                 if (error != 0) {
1795                                         m_freem(top);
1796                                         top = NULL;
1797                                 } else {
1798                                         soref(so);
1799                                         ktls_enqueue(top, so, tls_enq_cnt);
1800                                 }
1801                         }
1802 #endif
1803                         clen = 0;
1804                         control = NULL;
1805                         top = NULL;
1806                         if (error)
1807                                 goto release;
1808                 } while (resid && space > 0);
1809         } while (resid);
1810
1811 release:
1812         SOCK_IO_SEND_UNLOCK(so);
1813 out:
1814 #ifdef KERN_TLS
1815         if (tls != NULL)
1816                 ktls_free(tls);
1817 #endif
1818         if (top != NULL)
1819                 m_freem(top);
1820         if (control != NULL)
1821                 m_freem(control);
1822         return (error);
1823 }
1824
1825 int
1826 sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
1827     struct mbuf *top, struct mbuf *control, int flags, struct thread *td)
1828 {
1829         int error;
1830
1831         CURVNET_SET(so->so_vnet);
1832         error = so->so_proto->pr_sosend(so, addr, uio,
1833             top, control, flags, td);
1834         CURVNET_RESTORE();
1835         return (error);
1836 }
1837
1838 /*
1839  * The part of soreceive() that implements reading non-inline out-of-band
1840  * data from a socket.  For more complete comments, see soreceive(), from
1841  * which this code originated.
1842  *
1843  * Note that soreceive_rcvoob(), unlike the remainder of soreceive(), is
1844  * unable to return an mbuf chain to the caller.
1845  */
1846 static int
1847 soreceive_rcvoob(struct socket *so, struct uio *uio, int flags)
1848 {
1849         struct protosw *pr = so->so_proto;
1850         struct mbuf *m;
1851         int error;
1852
1853         KASSERT(flags & MSG_OOB, ("soreceive_rcvoob: (flags & MSG_OOB) == 0"));
1854         VNET_SO_ASSERT(so);
1855
1856         m = m_get(M_WAITOK, MT_DATA);
1857         error = pr->pr_rcvoob(so, m, flags & MSG_PEEK);
1858         if (error)
1859                 goto bad;
1860         do {
1861                 error = uiomove(mtod(m, void *),
1862                     (int) min(uio->uio_resid, m->m_len), uio);
1863                 m = m_free(m);
1864         } while (uio->uio_resid && error == 0 && m);
1865 bad:
1866         if (m != NULL)
1867                 m_freem(m);
1868         return (error);
1869 }
1870
1871 /*
1872  * Following replacement or removal of the first mbuf on the first mbuf chain
1873  * of a socket buffer, push necessary state changes back into the socket
1874  * buffer so that other consumers see the values consistently.  'nextrecord'
1875  * is the callers locally stored value of the original value of
1876  * sb->sb_mb->m_nextpkt which must be restored when the lead mbuf changes.
1877  * NOTE: 'nextrecord' may be NULL.
1878  */
1879 static __inline void
1880 sockbuf_pushsync(struct sockbuf *sb, struct mbuf *nextrecord)
1881 {
1882
1883         SOCKBUF_LOCK_ASSERT(sb);
1884         /*
1885          * First, update for the new value of nextrecord.  If necessary, make
1886          * it the first record.
1887          */
1888         if (sb->sb_mb != NULL)
1889                 sb->sb_mb->m_nextpkt = nextrecord;
1890         else
1891                 sb->sb_mb = nextrecord;
1892
1893         /*
1894          * Now update any dependent socket buffer fields to reflect the new
1895          * state.  This is an expanded inline of SB_EMPTY_FIXUP(), with the
1896          * addition of a second clause that takes care of the case where
1897          * sb_mb has been updated, but remains the last record.
1898          */
1899         if (sb->sb_mb == NULL) {
1900                 sb->sb_mbtail = NULL;
1901                 sb->sb_lastrecord = NULL;
1902         } else if (sb->sb_mb->m_nextpkt == NULL)
1903                 sb->sb_lastrecord = sb->sb_mb;
1904 }
1905
1906 /*
1907  * Implement receive operations on a socket.  We depend on the way that
1908  * records are added to the sockbuf by sbappend.  In particular, each record
1909  * (mbufs linked through m_next) must begin with an address if the protocol
1910  * so specifies, followed by an optional mbuf or mbufs containing ancillary
1911  * data, and then zero or more mbufs of data.  In order to allow parallelism
1912  * between network receive and copying to user space, as well as avoid
1913  * sleeping with a mutex held, we release the socket buffer mutex during the
1914  * user space copy.  Although the sockbuf is locked, new data may still be
1915  * appended, and thus we must maintain consistency of the sockbuf during that
1916  * time.
1917  *
1918  * The caller may receive the data as a single mbuf chain by supplying an
1919  * mbuf **mp0 for use in returning the chain.  The uio is then used only for
1920  * the count in uio_resid.
1921  */
1922 int
1923 soreceive_generic(struct socket *so, struct sockaddr **psa, struct uio *uio,
1924     struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
1925 {
1926         struct mbuf *m, **mp;
1927         int flags, error, offset;
1928         ssize_t len;
1929         struct protosw *pr = so->so_proto;
1930         struct mbuf *nextrecord;
1931         int moff, type = 0;
1932         ssize_t orig_resid = uio->uio_resid;
1933         bool report_real_len = false;
1934
1935         mp = mp0;
1936         if (psa != NULL)
1937                 *psa = NULL;
1938         if (controlp != NULL)
1939                 *controlp = NULL;
1940         if (flagsp != NULL) {
1941                 report_real_len = *flagsp & MSG_TRUNC;
1942                 *flagsp &= ~MSG_TRUNC;
1943                 flags = *flagsp &~ MSG_EOR;
1944         } else
1945                 flags = 0;
1946         if (flags & MSG_OOB)
1947                 return (soreceive_rcvoob(so, uio, flags));
1948         if (mp != NULL)
1949                 *mp = NULL;
1950         if ((pr->pr_flags & PR_WANTRCVD) && (so->so_state & SS_ISCONFIRMING)
1951             && uio->uio_resid) {
1952                 VNET_SO_ASSERT(so);
1953                 pr->pr_rcvd(so, 0);
1954         }
1955
1956         error = SOCK_IO_RECV_LOCK(so, SBLOCKWAIT(flags));
1957         if (error)
1958                 return (error);
1959
1960 restart:
1961         SOCKBUF_LOCK(&so->so_rcv);
1962         m = so->so_rcv.sb_mb;
1963         /*
1964          * If we have less data than requested, block awaiting more (subject
1965          * to any timeout) if:
1966          *   1. the current count is less than the low water mark, or
1967          *   2. MSG_DONTWAIT is not set
1968          */
1969         if (m == NULL || (((flags & MSG_DONTWAIT) == 0 &&
1970             sbavail(&so->so_rcv) < uio->uio_resid) &&
1971             sbavail(&so->so_rcv) < so->so_rcv.sb_lowat &&
1972             m->m_nextpkt == NULL && (pr->pr_flags & PR_ATOMIC) == 0)) {
1973                 KASSERT(m != NULL || !sbavail(&so->so_rcv),
1974                     ("receive: m == %p sbavail == %u",
1975                     m, sbavail(&so->so_rcv)));
1976                 if (so->so_error || so->so_rerror) {
1977                         if (m != NULL)
1978                                 goto dontblock;
1979                         if (so->so_error)
1980                                 error = so->so_error;
1981                         else
1982                                 error = so->so_rerror;
1983                         if ((flags & MSG_PEEK) == 0) {
1984                                 if (so->so_error)
1985                                         so->so_error = 0;
1986                                 else
1987                                         so->so_rerror = 0;
1988                         }
1989                         SOCKBUF_UNLOCK(&so->so_rcv);
1990                         goto release;
1991                 }
1992                 SOCKBUF_LOCK_ASSERT(&so->so_rcv);
1993                 if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
1994                         if (m != NULL)
1995                                 goto dontblock;
1996 #ifdef KERN_TLS
1997                         else if (so->so_rcv.sb_tlsdcc == 0 &&
1998                             so->so_rcv.sb_tlscc == 0) {
1999 #else
2000                         else {
2001 #endif
2002                                 SOCKBUF_UNLOCK(&so->so_rcv);
2003                                 goto release;
2004                         }
2005                 }
2006                 for (; m != NULL; m = m->m_next)
2007                         if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
2008                                 m = so->so_rcv.sb_mb;
2009                                 goto dontblock;
2010                         }
2011                 if ((so->so_state & (SS_ISCONNECTING | SS_ISCONNECTED |
2012                     SS_ISDISCONNECTING | SS_ISDISCONNECTED)) == 0 &&
2013                     (so->so_proto->pr_flags & PR_CONNREQUIRED) != 0) {
2014                         SOCKBUF_UNLOCK(&so->so_rcv);
2015                         error = ENOTCONN;
2016                         goto release;
2017                 }
2018                 if (uio->uio_resid == 0 && !report_real_len) {
2019                         SOCKBUF_UNLOCK(&so->so_rcv);
2020                         goto release;
2021                 }
2022                 if ((so->so_state & SS_NBIO) ||
2023                     (flags & (MSG_DONTWAIT|MSG_NBIO))) {
2024                         SOCKBUF_UNLOCK(&so->so_rcv);
2025                         error = EWOULDBLOCK;
2026                         goto release;
2027                 }
2028                 SBLASTRECORDCHK(&so->so_rcv);
2029                 SBLASTMBUFCHK(&so->so_rcv);
2030                 error = sbwait(so, SO_RCV);
2031                 SOCKBUF_UNLOCK(&so->so_rcv);
2032                 if (error)
2033                         goto release;
2034                 goto restart;
2035         }
2036 dontblock:
2037         /*
2038          * From this point onward, we maintain 'nextrecord' as a cache of the
2039          * pointer to the next record in the socket buffer.  We must keep the
2040          * various socket buffer pointers and local stack versions of the
2041          * pointers in sync, pushing out modifications before dropping the
2042          * socket buffer mutex, and re-reading them when picking it up.
2043          *
2044          * Otherwise, we will race with the network stack appending new data
2045          * or records onto the socket buffer by using inconsistent/stale
2046          * versions of the field, possibly resulting in socket buffer
2047          * corruption.
2048          *
2049          * By holding the high-level sblock(), we prevent simultaneous
2050          * readers from pulling off the front of the socket buffer.
2051          */
2052         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2053         if (uio->uio_td)
2054                 uio->uio_td->td_ru.ru_msgrcv++;
2055         KASSERT(m == so->so_rcv.sb_mb, ("soreceive: m != so->so_rcv.sb_mb"));
2056         SBLASTRECORDCHK(&so->so_rcv);
2057         SBLASTMBUFCHK(&so->so_rcv);
2058         nextrecord = m->m_nextpkt;
2059         if (pr->pr_flags & PR_ADDR) {
2060                 KASSERT(m->m_type == MT_SONAME,
2061                     ("m->m_type == %d", m->m_type));
2062                 orig_resid = 0;
2063                 if (psa != NULL)
2064                         *psa = sodupsockaddr(mtod(m, struct sockaddr *),
2065                             M_NOWAIT);
2066                 if (flags & MSG_PEEK) {
2067                         m = m->m_next;
2068                 } else {
2069                         sbfree(&so->so_rcv, m);
2070                         so->so_rcv.sb_mb = m_free(m);
2071                         m = so->so_rcv.sb_mb;
2072                         sockbuf_pushsync(&so->so_rcv, nextrecord);
2073                 }
2074         }
2075
2076         /*
2077          * Process one or more MT_CONTROL mbufs present before any data mbufs
2078          * in the first mbuf chain on the socket buffer.  If MSG_PEEK, we
2079          * just copy the data; if !MSG_PEEK, we call into the protocol to
2080          * perform externalization (or freeing if controlp == NULL).
2081          */
2082         if (m != NULL && m->m_type == MT_CONTROL) {
2083                 struct mbuf *cm = NULL, *cmn;
2084                 struct mbuf **cme = &cm;
2085 #ifdef KERN_TLS
2086                 struct cmsghdr *cmsg;
2087                 struct tls_get_record tgr;
2088
2089                 /*
2090                  * For MSG_TLSAPPDATA, check for an alert record.
2091                  * If found, return ENXIO without removing
2092                  * it from the receive queue.  This allows a subsequent
2093                  * call without MSG_TLSAPPDATA to receive it.
2094                  * Note that, for TLS, there should only be a single
2095                  * control mbuf with the TLS_GET_RECORD message in it.
2096                  */
2097                 if (flags & MSG_TLSAPPDATA) {
2098                         cmsg = mtod(m, struct cmsghdr *);
2099                         if (cmsg->cmsg_type == TLS_GET_RECORD &&
2100                             cmsg->cmsg_len == CMSG_LEN(sizeof(tgr))) {
2101                                 memcpy(&tgr, CMSG_DATA(cmsg), sizeof(tgr));
2102                                 if (__predict_false(tgr.tls_type ==
2103                                     TLS_RLTYPE_ALERT)) {
2104                                         SOCKBUF_UNLOCK(&so->so_rcv);
2105                                         error = ENXIO;
2106                                         goto release;
2107                                 }
2108                         }
2109                 }
2110 #endif
2111
2112                 do {
2113                         if (flags & MSG_PEEK) {
2114                                 if (controlp != NULL) {
2115                                         *controlp = m_copym(m, 0, m->m_len,
2116                                             M_NOWAIT);
2117                                         controlp = &(*controlp)->m_next;
2118                                 }
2119                                 m = m->m_next;
2120                         } else {
2121                                 sbfree(&so->so_rcv, m);
2122                                 so->so_rcv.sb_mb = m->m_next;
2123                                 m->m_next = NULL;
2124                                 *cme = m;
2125                                 cme = &(*cme)->m_next;
2126                                 m = so->so_rcv.sb_mb;
2127                         }
2128                 } while (m != NULL && m->m_type == MT_CONTROL);
2129                 if ((flags & MSG_PEEK) == 0)
2130                         sockbuf_pushsync(&so->so_rcv, nextrecord);
2131                 while (cm != NULL) {
2132                         cmn = cm->m_next;
2133                         cm->m_next = NULL;
2134                         if (pr->pr_domain->dom_externalize != NULL) {
2135                                 SOCKBUF_UNLOCK(&so->so_rcv);
2136                                 VNET_SO_ASSERT(so);
2137                                 error = (*pr->pr_domain->dom_externalize)
2138                                     (cm, controlp, flags);
2139                                 SOCKBUF_LOCK(&so->so_rcv);
2140                         } else if (controlp != NULL)
2141                                 *controlp = cm;
2142                         else
2143                                 m_freem(cm);
2144                         if (controlp != NULL) {
2145                                 while (*controlp != NULL)
2146                                         controlp = &(*controlp)->m_next;
2147                         }
2148                         cm = cmn;
2149                 }
2150                 if (m != NULL)
2151                         nextrecord = so->so_rcv.sb_mb->m_nextpkt;
2152                 else
2153                         nextrecord = so->so_rcv.sb_mb;
2154                 orig_resid = 0;
2155         }
2156         if (m != NULL) {
2157                 if ((flags & MSG_PEEK) == 0) {
2158                         KASSERT(m->m_nextpkt == nextrecord,
2159                             ("soreceive: post-control, nextrecord !sync"));
2160                         if (nextrecord == NULL) {
2161                                 KASSERT(so->so_rcv.sb_mb == m,
2162                                     ("soreceive: post-control, sb_mb!=m"));
2163                                 KASSERT(so->so_rcv.sb_lastrecord == m,
2164                                     ("soreceive: post-control, lastrecord!=m"));
2165                         }
2166                 }
2167                 type = m->m_type;
2168                 if (type == MT_OOBDATA)
2169                         flags |= MSG_OOB;
2170         } else {
2171                 if ((flags & MSG_PEEK) == 0) {
2172                         KASSERT(so->so_rcv.sb_mb == nextrecord,
2173                             ("soreceive: sb_mb != nextrecord"));
2174                         if (so->so_rcv.sb_mb == NULL) {
2175                                 KASSERT(so->so_rcv.sb_lastrecord == NULL,
2176                                     ("soreceive: sb_lastercord != NULL"));
2177                         }
2178                 }
2179         }
2180         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2181         SBLASTRECORDCHK(&so->so_rcv);
2182         SBLASTMBUFCHK(&so->so_rcv);
2183
2184         /*
2185          * Now continue to read any data mbufs off of the head of the socket
2186          * buffer until the read request is satisfied.  Note that 'type' is
2187          * used to store the type of any mbuf reads that have happened so far
2188          * such that soreceive() can stop reading if the type changes, which
2189          * causes soreceive() to return only one of regular data and inline
2190          * out-of-band data in a single socket receive operation.
2191          */
2192         moff = 0;
2193         offset = 0;
2194         while (m != NULL && !(m->m_flags & M_NOTAVAIL) && uio->uio_resid > 0
2195             && error == 0) {
2196                 /*
2197                  * If the type of mbuf has changed since the last mbuf
2198                  * examined ('type'), end the receive operation.
2199                  */
2200                 SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2201                 if (m->m_type == MT_OOBDATA || m->m_type == MT_CONTROL) {
2202                         if (type != m->m_type)
2203                                 break;
2204                 } else if (type == MT_OOBDATA)
2205                         break;
2206                 else
2207                     KASSERT(m->m_type == MT_DATA,
2208                         ("m->m_type == %d", m->m_type));
2209                 so->so_rcv.sb_state &= ~SBS_RCVATMARK;
2210                 len = uio->uio_resid;
2211                 if (so->so_oobmark && len > so->so_oobmark - offset)
2212                         len = so->so_oobmark - offset;
2213                 if (len > m->m_len - moff)
2214                         len = m->m_len - moff;
2215                 /*
2216                  * If mp is set, just pass back the mbufs.  Otherwise copy
2217                  * them out via the uio, then free.  Sockbuf must be
2218                  * consistent here (points to current mbuf, it points to next
2219                  * record) when we drop priority; we must note any additions
2220                  * to the sockbuf when we block interrupts again.
2221                  */
2222                 if (mp == NULL) {
2223                         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2224                         SBLASTRECORDCHK(&so->so_rcv);
2225                         SBLASTMBUFCHK(&so->so_rcv);
2226                         SOCKBUF_UNLOCK(&so->so_rcv);
2227                         if ((m->m_flags & M_EXTPG) != 0)
2228                                 error = m_unmapped_uiomove(m, moff, uio,
2229                                     (int)len);
2230                         else
2231                                 error = uiomove(mtod(m, char *) + moff,
2232                                     (int)len, uio);
2233                         SOCKBUF_LOCK(&so->so_rcv);
2234                         if (error) {
2235                                 /*
2236                                  * The MT_SONAME mbuf has already been removed
2237                                  * from the record, so it is necessary to
2238                                  * remove the data mbufs, if any, to preserve
2239                                  * the invariant in the case of PR_ADDR that
2240                                  * requires MT_SONAME mbufs at the head of
2241                                  * each record.
2242                                  */
2243                                 if (pr->pr_flags & PR_ATOMIC &&
2244                                     ((flags & MSG_PEEK) == 0))
2245                                         (void)sbdroprecord_locked(&so->so_rcv);
2246                                 SOCKBUF_UNLOCK(&so->so_rcv);
2247                                 goto release;
2248                         }
2249                 } else
2250                         uio->uio_resid -= len;
2251                 SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2252                 if (len == m->m_len - moff) {
2253                         if (m->m_flags & M_EOR)
2254                                 flags |= MSG_EOR;
2255                         if (flags & MSG_PEEK) {
2256                                 m = m->m_next;
2257                                 moff = 0;
2258                         } else {
2259                                 nextrecord = m->m_nextpkt;
2260                                 sbfree(&so->so_rcv, m);
2261                                 if (mp != NULL) {
2262                                         m->m_nextpkt = NULL;
2263                                         *mp = m;
2264                                         mp = &m->m_next;
2265                                         so->so_rcv.sb_mb = m = m->m_next;
2266                                         *mp = NULL;
2267                                 } else {
2268                                         so->so_rcv.sb_mb = m_free(m);
2269                                         m = so->so_rcv.sb_mb;
2270                                 }
2271                                 sockbuf_pushsync(&so->so_rcv, nextrecord);
2272                                 SBLASTRECORDCHK(&so->so_rcv);
2273                                 SBLASTMBUFCHK(&so->so_rcv);
2274                         }
2275                 } else {
2276                         if (flags & MSG_PEEK)
2277                                 moff += len;
2278                         else {
2279                                 if (mp != NULL) {
2280                                         if (flags & MSG_DONTWAIT) {
2281                                                 *mp = m_copym(m, 0, len,
2282                                                     M_NOWAIT);
2283                                                 if (*mp == NULL) {
2284                                                         /*
2285                                                          * m_copym() couldn't
2286                                                          * allocate an mbuf.
2287                                                          * Adjust uio_resid back
2288                                                          * (it was adjusted
2289                                                          * down by len bytes,
2290                                                          * which we didn't end
2291                                                          * up "copying" over).
2292                                                          */
2293                                                         uio->uio_resid += len;
2294                                                         break;
2295                                                 }
2296                                         } else {
2297                                                 SOCKBUF_UNLOCK(&so->so_rcv);
2298                                                 *mp = m_copym(m, 0, len,
2299                                                     M_WAITOK);
2300                                                 SOCKBUF_LOCK(&so->so_rcv);
2301                                         }
2302                                 }
2303                                 sbcut_locked(&so->so_rcv, len);
2304                         }
2305                 }
2306                 SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2307                 if (so->so_oobmark) {
2308                         if ((flags & MSG_PEEK) == 0) {
2309                                 so->so_oobmark -= len;
2310                                 if (so->so_oobmark == 0) {
2311                                         so->so_rcv.sb_state |= SBS_RCVATMARK;
2312                                         break;
2313                                 }
2314                         } else {
2315                                 offset += len;
2316                                 if (offset == so->so_oobmark)
2317                                         break;
2318                         }
2319                 }
2320                 if (flags & MSG_EOR)
2321                         break;
2322                 /*
2323                  * If the MSG_WAITALL flag is set (for non-atomic socket), we
2324                  * must not quit until "uio->uio_resid == 0" or an error
2325                  * termination.  If a signal/timeout occurs, return with a
2326                  * short count but without error.  Keep sockbuf locked
2327                  * against other readers.
2328                  */
2329                 while (flags & MSG_WAITALL && m == NULL && uio->uio_resid > 0 &&
2330                     !sosendallatonce(so) && nextrecord == NULL) {
2331                         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2332                         if (so->so_error || so->so_rerror ||
2333                             so->so_rcv.sb_state & SBS_CANTRCVMORE)
2334                                 break;
2335                         /*
2336                          * Notify the protocol that some data has been
2337                          * drained before blocking.
2338                          */
2339                         if (pr->pr_flags & PR_WANTRCVD) {
2340                                 SOCKBUF_UNLOCK(&so->so_rcv);
2341                                 VNET_SO_ASSERT(so);
2342                                 pr->pr_rcvd(so, flags);
2343                                 SOCKBUF_LOCK(&so->so_rcv);
2344                         }
2345                         SBLASTRECORDCHK(&so->so_rcv);
2346                         SBLASTMBUFCHK(&so->so_rcv);
2347                         /*
2348                          * We could receive some data while was notifying
2349                          * the protocol. Skip blocking in this case.
2350                          */
2351                         if (so->so_rcv.sb_mb == NULL) {
2352                                 error = sbwait(so, SO_RCV);
2353                                 if (error) {
2354                                         SOCKBUF_UNLOCK(&so->so_rcv);
2355                                         goto release;
2356                                 }
2357                         }
2358                         m = so->so_rcv.sb_mb;
2359                         if (m != NULL)
2360                                 nextrecord = m->m_nextpkt;
2361                 }
2362         }
2363
2364         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2365         if (m != NULL && pr->pr_flags & PR_ATOMIC) {
2366                 if (report_real_len)
2367                         uio->uio_resid -= m_length(m, NULL) - moff;
2368                 flags |= MSG_TRUNC;
2369                 if ((flags & MSG_PEEK) == 0)
2370                         (void) sbdroprecord_locked(&so->so_rcv);
2371         }
2372         if ((flags & MSG_PEEK) == 0) {
2373                 if (m == NULL) {
2374                         /*
2375                          * First part is an inline SB_EMPTY_FIXUP().  Second
2376                          * part makes sure sb_lastrecord is up-to-date if
2377                          * there is still data in the socket buffer.
2378                          */
2379                         so->so_rcv.sb_mb = nextrecord;
2380                         if (so->so_rcv.sb_mb == NULL) {
2381                                 so->so_rcv.sb_mbtail = NULL;
2382                                 so->so_rcv.sb_lastrecord = NULL;
2383                         } else if (nextrecord->m_nextpkt == NULL)
2384                                 so->so_rcv.sb_lastrecord = nextrecord;
2385                 }
2386                 SBLASTRECORDCHK(&so->so_rcv);
2387                 SBLASTMBUFCHK(&so->so_rcv);
2388                 /*
2389                  * If soreceive() is being done from the socket callback,
2390                  * then don't need to generate ACK to peer to update window,
2391                  * since ACK will be generated on return to TCP.
2392                  */
2393                 if (!(flags & MSG_SOCALLBCK) &&
2394                     (pr->pr_flags & PR_WANTRCVD)) {
2395                         SOCKBUF_UNLOCK(&so->so_rcv);
2396                         VNET_SO_ASSERT(so);
2397                         pr->pr_rcvd(so, flags);
2398                         SOCKBUF_LOCK(&so->so_rcv);
2399                 }
2400         }
2401         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2402         if (orig_resid == uio->uio_resid && orig_resid &&
2403             (flags & MSG_EOR) == 0 && (so->so_rcv.sb_state & SBS_CANTRCVMORE) == 0) {
2404                 SOCKBUF_UNLOCK(&so->so_rcv);
2405                 goto restart;
2406         }
2407         SOCKBUF_UNLOCK(&so->so_rcv);
2408
2409         if (flagsp != NULL)
2410                 *flagsp |= flags;
2411 release:
2412         SOCK_IO_RECV_UNLOCK(so);
2413         return (error);
2414 }
2415
2416 /*
2417  * Optimized version of soreceive() for stream (TCP) sockets.
2418  */
2419 int
2420 soreceive_stream(struct socket *so, struct sockaddr **psa, struct uio *uio,
2421     struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
2422 {
2423         int len = 0, error = 0, flags, oresid;
2424         struct sockbuf *sb;
2425         struct mbuf *m, *n = NULL;
2426
2427         /* We only do stream sockets. */
2428         if (so->so_type != SOCK_STREAM)
2429                 return (EINVAL);
2430         if (psa != NULL)
2431                 *psa = NULL;
2432         if (flagsp != NULL)
2433                 flags = *flagsp &~ MSG_EOR;
2434         else
2435                 flags = 0;
2436         if (controlp != NULL)
2437                 *controlp = NULL;
2438         if (flags & MSG_OOB)
2439                 return (soreceive_rcvoob(so, uio, flags));
2440         if (mp0 != NULL)
2441                 *mp0 = NULL;
2442
2443         sb = &so->so_rcv;
2444
2445 #ifdef KERN_TLS
2446         /*
2447          * KTLS store TLS records as records with a control message to
2448          * describe the framing.
2449          *
2450          * We check once here before acquiring locks to optimize the
2451          * common case.
2452          */
2453         if (sb->sb_tls_info != NULL)
2454                 return (soreceive_generic(so, psa, uio, mp0, controlp,
2455                     flagsp));
2456 #endif
2457
2458         /* Prevent other readers from entering the socket. */
2459         error = SOCK_IO_RECV_LOCK(so, SBLOCKWAIT(flags));
2460         if (error)
2461                 return (error);
2462         SOCKBUF_LOCK(sb);
2463
2464 #ifdef KERN_TLS
2465         if (sb->sb_tls_info != NULL) {
2466                 SOCKBUF_UNLOCK(sb);
2467                 SOCK_IO_RECV_UNLOCK(so);
2468                 return (soreceive_generic(so, psa, uio, mp0, controlp,
2469                     flagsp));
2470         }
2471 #endif
2472
2473         /* Easy one, no space to copyout anything. */
2474         if (uio->uio_resid == 0) {
2475                 error = EINVAL;
2476                 goto out;
2477         }
2478         oresid = uio->uio_resid;
2479
2480         /* We will never ever get anything unless we are or were connected. */
2481         if (!(so->so_state & (SS_ISCONNECTED|SS_ISDISCONNECTED))) {
2482                 error = ENOTCONN;
2483                 goto out;
2484         }
2485
2486 restart:
2487         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2488
2489         /* Abort if socket has reported problems. */
2490         if (so->so_error) {
2491                 if (sbavail(sb) > 0)
2492                         goto deliver;
2493                 if (oresid > uio->uio_resid)
2494                         goto out;
2495                 error = so->so_error;
2496                 if (!(flags & MSG_PEEK))
2497                         so->so_error = 0;
2498                 goto out;
2499         }
2500
2501         /* Door is closed.  Deliver what is left, if any. */
2502         if (sb->sb_state & SBS_CANTRCVMORE) {
2503                 if (sbavail(sb) > 0)
2504                         goto deliver;
2505                 else
2506                         goto out;
2507         }
2508
2509         /* Socket buffer is empty and we shall not block. */
2510         if (sbavail(sb) == 0 &&
2511             ((so->so_state & SS_NBIO) || (flags & (MSG_DONTWAIT|MSG_NBIO)))) {
2512                 error = EAGAIN;
2513                 goto out;
2514         }
2515
2516         /* Socket buffer got some data that we shall deliver now. */
2517         if (sbavail(sb) > 0 && !(flags & MSG_WAITALL) &&
2518             ((so->so_state & SS_NBIO) ||
2519              (flags & (MSG_DONTWAIT|MSG_NBIO)) ||
2520              sbavail(sb) >= sb->sb_lowat ||
2521              sbavail(sb) >= uio->uio_resid ||
2522              sbavail(sb) >= sb->sb_hiwat) ) {
2523                 goto deliver;
2524         }
2525
2526         /* On MSG_WAITALL we must wait until all data or error arrives. */
2527         if ((flags & MSG_WAITALL) &&
2528             (sbavail(sb) >= uio->uio_resid || sbavail(sb) >= sb->sb_hiwat))
2529                 goto deliver;
2530
2531         /*
2532          * Wait and block until (more) data comes in.
2533          * NB: Drops the sockbuf lock during wait.
2534          */
2535         error = sbwait(so, SO_RCV);
2536         if (error)
2537                 goto out;
2538         goto restart;
2539
2540 deliver:
2541         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2542         KASSERT(sbavail(sb) > 0, ("%s: sockbuf empty", __func__));
2543         KASSERT(sb->sb_mb != NULL, ("%s: sb_mb == NULL", __func__));
2544
2545         /* Statistics. */
2546         if (uio->uio_td)
2547                 uio->uio_td->td_ru.ru_msgrcv++;
2548
2549         /* Fill uio until full or current end of socket buffer is reached. */
2550         len = min(uio->uio_resid, sbavail(sb));
2551         if (mp0 != NULL) {
2552                 /* Dequeue as many mbufs as possible. */
2553                 if (!(flags & MSG_PEEK) && len >= sb->sb_mb->m_len) {
2554                         if (*mp0 == NULL)
2555                                 *mp0 = sb->sb_mb;
2556                         else
2557                                 m_cat(*mp0, sb->sb_mb);
2558                         for (m = sb->sb_mb;
2559                              m != NULL && m->m_len <= len;
2560                              m = m->m_next) {
2561                                 KASSERT(!(m->m_flags & M_NOTAVAIL),
2562                                     ("%s: m %p not available", __func__, m));
2563                                 len -= m->m_len;
2564                                 uio->uio_resid -= m->m_len;
2565                                 sbfree(sb, m);
2566                                 n = m;
2567                         }
2568                         n->m_next = NULL;
2569                         sb->sb_mb = m;
2570                         sb->sb_lastrecord = sb->sb_mb;
2571                         if (sb->sb_mb == NULL)
2572                                 SB_EMPTY_FIXUP(sb);
2573                 }
2574                 /* Copy the remainder. */
2575                 if (len > 0) {
2576                         KASSERT(sb->sb_mb != NULL,
2577                             ("%s: len > 0 && sb->sb_mb empty", __func__));
2578
2579                         m = m_copym(sb->sb_mb, 0, len, M_NOWAIT);
2580                         if (m == NULL)
2581                                 len = 0;        /* Don't flush data from sockbuf. */
2582                         else
2583                                 uio->uio_resid -= len;
2584                         if (*mp0 != NULL)
2585                                 m_cat(*mp0, m);
2586                         else
2587                                 *mp0 = m;
2588                         if (*mp0 == NULL) {
2589                                 error = ENOBUFS;
2590                                 goto out;
2591                         }
2592                 }
2593         } else {
2594                 /* NB: Must unlock socket buffer as uiomove may sleep. */
2595                 SOCKBUF_UNLOCK(sb);
2596                 error = m_mbuftouio(uio, sb->sb_mb, len);
2597                 SOCKBUF_LOCK(sb);
2598                 if (error)
2599                         goto out;
2600         }
2601         SBLASTRECORDCHK(sb);
2602         SBLASTMBUFCHK(sb);
2603
2604         /*
2605          * Remove the delivered data from the socket buffer unless we
2606          * were only peeking.
2607          */
2608         if (!(flags & MSG_PEEK)) {
2609                 if (len > 0)
2610                         sbdrop_locked(sb, len);
2611
2612                 /* Notify protocol that we drained some data. */
2613                 if ((so->so_proto->pr_flags & PR_WANTRCVD) &&
2614                     (((flags & MSG_WAITALL) && uio->uio_resid > 0) ||
2615                      !(flags & MSG_SOCALLBCK))) {
2616                         SOCKBUF_UNLOCK(sb);
2617                         VNET_SO_ASSERT(so);
2618                         so->so_proto->pr_rcvd(so, flags);
2619                         SOCKBUF_LOCK(sb);
2620                 }
2621         }
2622
2623         /*
2624          * For MSG_WAITALL we may have to loop again and wait for
2625          * more data to come in.
2626          */
2627         if ((flags & MSG_WAITALL) && uio->uio_resid > 0)
2628                 goto restart;
2629 out:
2630         SBLASTRECORDCHK(sb);
2631         SBLASTMBUFCHK(sb);
2632         SOCKBUF_UNLOCK(sb);
2633         SOCK_IO_RECV_UNLOCK(so);
2634         return (error);
2635 }
2636
2637 /*
2638  * Optimized version of soreceive() for simple datagram cases from userspace.
2639  * Unlike in the stream case, we're able to drop a datagram if copyout()
2640  * fails, and because we handle datagrams atomically, we don't need to use a
2641  * sleep lock to prevent I/O interlacing.
2642  */
2643 int
2644 soreceive_dgram(struct socket *so, struct sockaddr **psa, struct uio *uio,
2645     struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
2646 {
2647         struct mbuf *m, *m2;
2648         int flags, error;
2649         ssize_t len;
2650         struct protosw *pr = so->so_proto;
2651         struct mbuf *nextrecord;
2652
2653         if (psa != NULL)
2654                 *psa = NULL;
2655         if (controlp != NULL)
2656                 *controlp = NULL;
2657         if (flagsp != NULL)
2658                 flags = *flagsp &~ MSG_EOR;
2659         else
2660                 flags = 0;
2661
2662         /*
2663          * For any complicated cases, fall back to the full
2664          * soreceive_generic().
2665          */
2666         if (mp0 != NULL || (flags & (MSG_PEEK | MSG_OOB | MSG_TRUNC)))
2667                 return (soreceive_generic(so, psa, uio, mp0, controlp,
2668                     flagsp));
2669
2670         /*
2671          * Enforce restrictions on use.
2672          */
2673         KASSERT((pr->pr_flags & PR_WANTRCVD) == 0,
2674             ("soreceive_dgram: wantrcvd"));
2675         KASSERT(pr->pr_flags & PR_ATOMIC, ("soreceive_dgram: !atomic"));
2676         KASSERT((so->so_rcv.sb_state & SBS_RCVATMARK) == 0,
2677             ("soreceive_dgram: SBS_RCVATMARK"));
2678         KASSERT((so->so_proto->pr_flags & PR_CONNREQUIRED) == 0,
2679             ("soreceive_dgram: P_CONNREQUIRED"));
2680
2681         /*
2682          * Loop blocking while waiting for a datagram.
2683          */
2684         SOCKBUF_LOCK(&so->so_rcv);
2685         while ((m = so->so_rcv.sb_mb) == NULL) {
2686                 KASSERT(sbavail(&so->so_rcv) == 0,
2687                     ("soreceive_dgram: sb_mb NULL but sbavail %u",
2688                     sbavail(&so->so_rcv)));
2689                 if (so->so_error) {
2690                         error = so->so_error;
2691                         so->so_error = 0;
2692                         SOCKBUF_UNLOCK(&so->so_rcv);
2693                         return (error);
2694                 }
2695                 if (so->so_rcv.sb_state & SBS_CANTRCVMORE ||
2696                     uio->uio_resid == 0) {
2697                         SOCKBUF_UNLOCK(&so->so_rcv);
2698                         return (0);
2699                 }
2700                 if ((so->so_state & SS_NBIO) ||
2701                     (flags & (MSG_DONTWAIT|MSG_NBIO))) {
2702                         SOCKBUF_UNLOCK(&so->so_rcv);
2703                         return (EWOULDBLOCK);
2704                 }
2705                 SBLASTRECORDCHK(&so->so_rcv);
2706                 SBLASTMBUFCHK(&so->so_rcv);
2707                 error = sbwait(so, SO_RCV);
2708                 if (error) {
2709                         SOCKBUF_UNLOCK(&so->so_rcv);
2710                         return (error);
2711                 }
2712         }
2713         SOCKBUF_LOCK_ASSERT(&so->so_rcv);
2714
2715         if (uio->uio_td)
2716                 uio->uio_td->td_ru.ru_msgrcv++;
2717         SBLASTRECORDCHK(&so->so_rcv);
2718         SBLASTMBUFCHK(&so->so_rcv);
2719         nextrecord = m->m_nextpkt;
2720         if (nextrecord == NULL) {
2721                 KASSERT(so->so_rcv.sb_lastrecord == m,
2722                     ("soreceive_dgram: lastrecord != m"));
2723         }
2724
2725         KASSERT(so->so_rcv.sb_mb->m_nextpkt == nextrecord,
2726             ("soreceive_dgram: m_nextpkt != nextrecord"));
2727
2728         /*
2729          * Pull 'm' and its chain off the front of the packet queue.
2730          */
2731         so->so_rcv.sb_mb = NULL;
2732         sockbuf_pushsync(&so->so_rcv, nextrecord);
2733
2734         /*
2735          * Walk 'm's chain and free that many bytes from the socket buffer.
2736          */
2737         for (m2 = m; m2 != NULL; m2 = m2->m_next)
2738                 sbfree(&so->so_rcv, m2);
2739
2740         /*
2741          * Do a few last checks before we let go of the lock.
2742          */
2743         SBLASTRECORDCHK(&so->so_rcv);
2744         SBLASTMBUFCHK(&so->so_rcv);
2745         SOCKBUF_UNLOCK(&so->so_rcv);
2746
2747         if (pr->pr_flags & PR_ADDR) {
2748                 KASSERT(m->m_type == MT_SONAME,
2749                     ("m->m_type == %d", m->m_type));
2750                 if (psa != NULL)
2751                         *psa = sodupsockaddr(mtod(m, struct sockaddr *),
2752                             M_NOWAIT);
2753                 m = m_free(m);
2754         }
2755         if (m == NULL) {
2756                 /* XXXRW: Can this happen? */
2757                 return (0);
2758         }
2759
2760         /*
2761          * Packet to copyout() is now in 'm' and it is disconnected from the
2762          * queue.
2763          *
2764          * Process one or more MT_CONTROL mbufs present before any data mbufs
2765          * in the first mbuf chain on the socket buffer.  We call into the
2766          * protocol to perform externalization (or freeing if controlp ==
2767          * NULL). In some cases there can be only MT_CONTROL mbufs without
2768          * MT_DATA mbufs.
2769          */
2770         if (m->m_type == MT_CONTROL) {
2771                 struct mbuf *cm = NULL, *cmn;
2772                 struct mbuf **cme = &cm;
2773
2774                 do {
2775                         m2 = m->m_next;
2776                         m->m_next = NULL;
2777                         *cme = m;
2778                         cme = &(*cme)->m_next;
2779                         m = m2;
2780                 } while (m != NULL && m->m_type == MT_CONTROL);
2781                 while (cm != NULL) {
2782                         cmn = cm->m_next;
2783                         cm->m_next = NULL;
2784                         if (pr->pr_domain->dom_externalize != NULL) {
2785                                 error = (*pr->pr_domain->dom_externalize)
2786                                     (cm, controlp, flags);
2787                         } else if (controlp != NULL)
2788                                 *controlp = cm;
2789                         else
2790                                 m_freem(cm);
2791                         if (controlp != NULL) {
2792                                 while (*controlp != NULL)
2793                                         controlp = &(*controlp)->m_next;
2794                         }
2795                         cm = cmn;
2796                 }
2797         }
2798         KASSERT(m == NULL || m->m_type == MT_DATA,
2799             ("soreceive_dgram: !data"));
2800         while (m != NULL && uio->uio_resid > 0) {
2801                 len = uio->uio_resid;
2802                 if (len > m->m_len)
2803                         len = m->m_len;
2804                 error = uiomove(mtod(m, char *), (int)len, uio);
2805                 if (error) {
2806                         m_freem(m);
2807                         return (error);
2808                 }
2809                 if (len == m->m_len)
2810                         m = m_free(m);
2811                 else {
2812                         m->m_data += len;
2813                         m->m_len -= len;
2814                 }
2815         }
2816         if (m != NULL) {
2817                 flags |= MSG_TRUNC;
2818                 m_freem(m);
2819         }
2820         if (flagsp != NULL)
2821                 *flagsp |= flags;
2822         return (0);
2823 }
2824
2825 int
2826 soreceive(struct socket *so, struct sockaddr **psa, struct uio *uio,
2827     struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
2828 {
2829         int error;
2830
2831         CURVNET_SET(so->so_vnet);
2832         error = so->so_proto->pr_soreceive(so, psa, uio, mp0, controlp, flagsp);
2833         CURVNET_RESTORE();
2834         return (error);
2835 }
2836
2837 int
2838 soshutdown(struct socket *so, int how)
2839 {
2840         struct protosw *pr;
2841         int error, soerror_enotconn;
2842
2843         if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
2844                 return (EINVAL);
2845
2846         soerror_enotconn = 0;
2847         SOCK_LOCK(so);
2848         if ((so->so_state &
2849             (SS_ISCONNECTED | SS_ISCONNECTING | SS_ISDISCONNECTING)) == 0) {
2850                 /*
2851                  * POSIX mandates us to return ENOTCONN when shutdown(2) is
2852                  * invoked on a datagram sockets, however historically we would
2853                  * actually tear socket down. This is known to be leveraged by
2854                  * some applications to unblock process waiting in recvXXX(2)
2855                  * by other process that it shares that socket with. Try to meet
2856                  * both backward-compatibility and POSIX requirements by forcing
2857                  * ENOTCONN but still asking protocol to perform pru_shutdown().
2858                  */
2859                 if (so->so_type != SOCK_DGRAM && !SOLISTENING(so)) {
2860                         SOCK_UNLOCK(so);
2861                         return (ENOTCONN);
2862                 }
2863                 soerror_enotconn = 1;
2864         }
2865
2866         if (SOLISTENING(so)) {
2867                 if (how != SHUT_WR) {
2868                         so->so_error = ECONNABORTED;
2869                         solisten_wakeup(so);    /* unlocks so */
2870                 } else {
2871                         SOCK_UNLOCK(so);
2872                 }
2873                 goto done;
2874         }
2875         SOCK_UNLOCK(so);
2876
2877         CURVNET_SET(so->so_vnet);
2878         pr = so->so_proto;
2879         if (pr->pr_flush != NULL)
2880                 pr->pr_flush(so, how);
2881         if (how != SHUT_WR)
2882                 sorflush(so);
2883         if (how != SHUT_RD) {
2884                 error = pr->pr_shutdown(so);
2885                 wakeup(&so->so_timeo);
2886                 CURVNET_RESTORE();
2887                 return ((error == 0 && soerror_enotconn) ? ENOTCONN : error);
2888         }
2889         wakeup(&so->so_timeo);
2890         CURVNET_RESTORE();
2891
2892 done:
2893         return (soerror_enotconn ? ENOTCONN : 0);
2894 }
2895
2896 void
2897 sorflush(struct socket *so)
2898 {
2899         struct protosw *pr;
2900         int error;
2901
2902         VNET_SO_ASSERT(so);
2903
2904         /*
2905          * Dislodge threads currently blocked in receive and wait to acquire
2906          * a lock against other simultaneous readers before clearing the
2907          * socket buffer.  Don't let our acquire be interrupted by a signal
2908          * despite any existing socket disposition on interruptable waiting.
2909          */
2910         socantrcvmore(so);
2911
2912         error = SOCK_IO_RECV_LOCK(so, SBL_WAIT | SBL_NOINTR);
2913         if (error != 0) {
2914                 KASSERT(SOLISTENING(so),
2915                     ("%s: soiolock(%p) failed", __func__, so));
2916                 return;
2917         }
2918
2919         pr = so->so_proto;
2920         if (pr->pr_flags & PR_RIGHTS) {
2921                 MPASS(pr->pr_domain->dom_dispose != NULL);
2922                 (*pr->pr_domain->dom_dispose)(so);
2923         } else {
2924                 sbrelease(so, SO_RCV);
2925                 SOCK_IO_RECV_UNLOCK(so);
2926         }
2927
2928 }
2929
2930 /*
2931  * Wrapper for Socket established helper hook.
2932  * Parameters: socket, context of the hook point, hook id.
2933  */
2934 static int inline
2935 hhook_run_socket(struct socket *so, void *hctx, int32_t h_id)
2936 {
2937         struct socket_hhook_data hhook_data = {
2938                 .so = so,
2939                 .hctx = hctx,
2940                 .m = NULL,
2941                 .status = 0
2942         };
2943
2944         CURVNET_SET(so->so_vnet);
2945         HHOOKS_RUN_IF(V_socket_hhh[h_id], &hhook_data, &so->osd);
2946         CURVNET_RESTORE();
2947
2948         /* Ugly but needed, since hhooks return void for now */
2949         return (hhook_data.status);
2950 }
2951
2952 /*
2953  * Perhaps this routine, and sooptcopyout(), below, ought to come in an
2954  * additional variant to handle the case where the option value needs to be
2955  * some kind of integer, but not a specific size.  In addition to their use
2956  * here, these functions are also called by the protocol-level pr_ctloutput()
2957  * routines.
2958  */
2959 int
2960 sooptcopyin(struct sockopt *sopt, void *buf, size_t len, size_t minlen)
2961 {
2962         size_t  valsize;
2963
2964         /*
2965          * If the user gives us more than we wanted, we ignore it, but if we
2966          * don't get the minimum length the caller wants, we return EINVAL.
2967          * On success, sopt->sopt_valsize is set to however much we actually
2968          * retrieved.
2969          */
2970         if ((valsize = sopt->sopt_valsize) < minlen)
2971                 return EINVAL;
2972         if (valsize > len)
2973                 sopt->sopt_valsize = valsize = len;
2974
2975         if (sopt->sopt_td != NULL)
2976                 return (copyin(sopt->sopt_val, buf, valsize));
2977
2978         bcopy(sopt->sopt_val, buf, valsize);
2979         return (0);
2980 }
2981
2982 /*
2983  * Kernel version of setsockopt(2).
2984  *
2985  * XXX: optlen is size_t, not socklen_t
2986  */
2987 int
2988 so_setsockopt(struct socket *so, int level, int optname, void *optval,
2989     size_t optlen)
2990 {
2991         struct sockopt sopt;
2992
2993         sopt.sopt_level = level;
2994         sopt.sopt_name = optname;
2995         sopt.sopt_dir = SOPT_SET;
2996         sopt.sopt_val = optval;
2997         sopt.sopt_valsize = optlen;
2998         sopt.sopt_td = NULL;
2999         return (sosetopt(so, &sopt));
3000 }
3001
3002 int
3003 sosetopt(struct socket *so, struct sockopt *sopt)
3004 {
3005         int     error, optval;
3006         struct  linger l;
3007         struct  timeval tv;
3008         sbintime_t val, *valp;
3009         uint32_t val32;
3010 #ifdef MAC
3011         struct mac extmac;
3012 #endif
3013
3014         CURVNET_SET(so->so_vnet);
3015         error = 0;
3016         if (sopt->sopt_level != SOL_SOCKET) {
3017                 if (so->so_proto->pr_ctloutput != NULL)
3018                         error = (*so->so_proto->pr_ctloutput)(so, sopt);
3019                 else
3020                         error = ENOPROTOOPT;
3021         } else {
3022                 switch (sopt->sopt_name) {
3023                 case SO_ACCEPTFILTER:
3024                         error = accept_filt_setopt(so, sopt);
3025                         if (error)
3026                                 goto bad;
3027                         break;
3028
3029                 case SO_LINGER:
3030                         error = sooptcopyin(sopt, &l, sizeof l, sizeof l);
3031                         if (error)
3032                                 goto bad;
3033                         if (l.l_linger < 0 ||
3034                             l.l_linger > USHRT_MAX ||
3035                             l.l_linger > (INT_MAX / hz)) {
3036                                 error = EDOM;
3037                                 goto bad;
3038                         }
3039                         SOCK_LOCK(so);
3040                         so->so_linger = l.l_linger;
3041                         if (l.l_onoff)
3042                                 so->so_options |= SO_LINGER;
3043                         else
3044                                 so->so_options &= ~SO_LINGER;
3045                         SOCK_UNLOCK(so);
3046                         break;
3047
3048                 case SO_DEBUG:
3049                 case SO_KEEPALIVE:
3050                 case SO_DONTROUTE:
3051                 case SO_USELOOPBACK:
3052                 case SO_BROADCAST:
3053                 case SO_REUSEADDR:
3054                 case SO_REUSEPORT:
3055                 case SO_REUSEPORT_LB:
3056                 case SO_OOBINLINE:
3057                 case SO_TIMESTAMP:
3058                 case SO_BINTIME:
3059                 case SO_NOSIGPIPE:
3060                 case SO_NO_DDP:
3061                 case SO_NO_OFFLOAD:
3062                 case SO_RERROR:
3063                         error = sooptcopyin(sopt, &optval, sizeof optval,
3064                             sizeof optval);
3065                         if (error)
3066                                 goto bad;
3067                         SOCK_LOCK(so);
3068                         if (optval)
3069                                 so->so_options |= sopt->sopt_name;
3070                         else
3071                                 so->so_options &= ~sopt->sopt_name;
3072                         SOCK_UNLOCK(so);
3073                         break;
3074
3075                 case SO_SETFIB:
3076                         error = sooptcopyin(sopt, &optval, sizeof optval,
3077                             sizeof optval);
3078                         if (error)
3079                                 goto bad;
3080
3081                         if (optval < 0 || optval >= rt_numfibs) {
3082                                 error = EINVAL;
3083                                 goto bad;
3084                         }
3085                         if (((so->so_proto->pr_domain->dom_family == PF_INET) ||
3086                            (so->so_proto->pr_domain->dom_family == PF_INET6) ||
3087                            (so->so_proto->pr_domain->dom_family == PF_ROUTE)))
3088                                 so->so_fibnum = optval;
3089                         else
3090                                 so->so_fibnum = 0;
3091                         break;
3092
3093                 case SO_USER_COOKIE:
3094                         error = sooptcopyin(sopt, &val32, sizeof val32,
3095                             sizeof val32);
3096                         if (error)
3097                                 goto bad;
3098                         so->so_user_cookie = val32;
3099                         break;
3100
3101                 case SO_SNDBUF:
3102                 case SO_RCVBUF:
3103                 case SO_SNDLOWAT:
3104                 case SO_RCVLOWAT:
3105                         error = so->so_proto->pr_setsbopt(so, sopt);
3106                         if (error)
3107                                 goto bad;
3108                         break;
3109
3110                 case SO_SNDTIMEO:
3111                 case SO_RCVTIMEO:
3112 #ifdef COMPAT_FREEBSD32
3113                         if (SV_CURPROC_FLAG(SV_ILP32)) {
3114                                 struct timeval32 tv32;
3115
3116                                 error = sooptcopyin(sopt, &tv32, sizeof tv32,
3117                                     sizeof tv32);
3118                                 CP(tv32, tv, tv_sec);
3119                                 CP(tv32, tv, tv_usec);
3120                         } else
3121 #endif
3122                                 error = sooptcopyin(sopt, &tv, sizeof tv,
3123                                     sizeof tv);
3124                         if (error)
3125                                 goto bad;
3126                         if (tv.tv_sec < 0 || tv.tv_usec < 0 ||
3127                             tv.tv_usec >= 1000000) {
3128                                 error = EDOM;
3129                                 goto bad;
3130                         }
3131                         if (tv.tv_sec > INT32_MAX)
3132                                 val = SBT_MAX;
3133                         else
3134                                 val = tvtosbt(tv);
3135                         SOCK_LOCK(so);
3136                         valp = sopt->sopt_name == SO_SNDTIMEO ?
3137                             (SOLISTENING(so) ? &so->sol_sbsnd_timeo :
3138                             &so->so_snd.sb_timeo) :
3139                             (SOLISTENING(so) ? &so->sol_sbrcv_timeo :
3140                             &so->so_rcv.sb_timeo);
3141                         *valp = val;
3142                         SOCK_UNLOCK(so);
3143                         break;
3144
3145                 case SO_LABEL:
3146 #ifdef MAC
3147                         error = sooptcopyin(sopt, &extmac, sizeof extmac,
3148                             sizeof extmac);
3149                         if (error)
3150                                 goto bad;
3151                         error = mac_setsockopt_label(sopt->sopt_td->td_ucred,
3152                             so, &extmac);
3153 #else
3154                         error = EOPNOTSUPP;
3155 #endif
3156                         break;
3157
3158                 case SO_TS_CLOCK:
3159                         error = sooptcopyin(sopt, &optval, sizeof optval,
3160                             sizeof optval);
3161                         if (error)
3162                                 goto bad;
3163                         if (optval < 0 || optval > SO_TS_CLOCK_MAX) {
3164                                 error = EINVAL;
3165                                 goto bad;
3166                         }
3167                         so->so_ts_clock = optval;
3168                         break;
3169
3170                 case SO_MAX_PACING_RATE:
3171                         error = sooptcopyin(sopt, &val32, sizeof(val32),
3172                             sizeof(val32));
3173                         if (error)
3174                                 goto bad;
3175                         so->so_max_pacing_rate = val32;
3176                         break;
3177
3178                 default:
3179                         if (V_socket_hhh[HHOOK_SOCKET_OPT]->hhh_nhooks > 0)
3180                                 error = hhook_run_socket(so, sopt,
3181                                     HHOOK_SOCKET_OPT);
3182                         else
3183                                 error = ENOPROTOOPT;
3184                         break;
3185                 }
3186                 if (error == 0 && so->so_proto->pr_ctloutput != NULL)
3187                         (void)(*so->so_proto->pr_ctloutput)(so, sopt);
3188         }
3189 bad:
3190         CURVNET_RESTORE();
3191         return (error);
3192 }
3193
3194 /*
3195  * Helper routine for getsockopt.
3196  */
3197 int
3198 sooptcopyout(struct sockopt *sopt, const void *buf, size_t len)
3199 {
3200         int     error;
3201         size_t  valsize;
3202
3203         error = 0;
3204
3205         /*
3206          * Documented get behavior is that we always return a value, possibly
3207          * truncated to fit in the user's buffer.  Traditional behavior is
3208          * that we always tell the user precisely how much we copied, rather
3209          * than something useful like the total amount we had available for
3210          * her.  Note that this interface is not idempotent; the entire
3211          * answer must be generated ahead of time.
3212          */
3213         valsize = min(len, sopt->sopt_valsize);
3214         sopt->sopt_valsize = valsize;
3215         if (sopt->sopt_val != NULL) {
3216                 if (sopt->sopt_td != NULL)
3217                         error = copyout(buf, sopt->sopt_val, valsize);
3218                 else
3219                         bcopy(buf, sopt->sopt_val, valsize);
3220         }
3221         return (error);
3222 }
3223
3224 int
3225 sogetopt(struct socket *so, struct sockopt *sopt)
3226 {
3227         int     error, optval;
3228         struct  linger l;
3229         struct  timeval tv;
3230 #ifdef MAC
3231         struct mac extmac;
3232 #endif
3233
3234         CURVNET_SET(so->so_vnet);
3235         error = 0;
3236         if (sopt->sopt_level != SOL_SOCKET) {
3237                 if (so->so_proto->pr_ctloutput != NULL)
3238                         error = (*so->so_proto->pr_ctloutput)(so, sopt);
3239                 else
3240                         error = ENOPROTOOPT;
3241                 CURVNET_RESTORE();
3242                 return (error);
3243         } else {
3244                 switch (sopt->sopt_name) {
3245                 case SO_ACCEPTFILTER:
3246                         error = accept_filt_getopt(so, sopt);
3247                         break;
3248
3249                 case SO_LINGER:
3250                         SOCK_LOCK(so);
3251                         l.l_onoff = so->so_options & SO_LINGER;
3252                         l.l_linger = so->so_linger;
3253                         SOCK_UNLOCK(so);
3254                         error = sooptcopyout(sopt, &l, sizeof l);
3255                         break;
3256
3257                 case SO_USELOOPBACK:
3258                 case SO_DONTROUTE:
3259                 case SO_DEBUG:
3260                 case SO_KEEPALIVE:
3261                 case SO_REUSEADDR:
3262                 case SO_REUSEPORT:
3263                 case SO_REUSEPORT_LB:
3264                 case SO_BROADCAST:
3265                 case SO_OOBINLINE:
3266                 case SO_ACCEPTCONN:
3267                 case SO_TIMESTAMP:
3268                 case SO_BINTIME:
3269                 case SO_NOSIGPIPE:
3270                 case SO_NO_DDP:
3271                 case SO_NO_OFFLOAD:
3272                 case SO_RERROR:
3273                         optval = so->so_options & sopt->sopt_name;
3274 integer:
3275                         error = sooptcopyout(sopt, &optval, sizeof optval);
3276                         break;
3277
3278                 case SO_DOMAIN:
3279                         optval = so->so_proto->pr_domain->dom_family;
3280                         goto integer;
3281
3282                 case SO_TYPE:
3283                         optval = so->so_type;
3284                         goto integer;
3285
3286                 case SO_PROTOCOL:
3287                         optval = so->so_proto->pr_protocol;
3288                         goto integer;
3289
3290                 case SO_ERROR:
3291                         SOCK_LOCK(so);
3292                         if (so->so_error) {
3293                                 optval = so->so_error;
3294                                 so->so_error = 0;
3295                         } else {
3296                                 optval = so->so_rerror;
3297                                 so->so_rerror = 0;
3298                         }
3299                         SOCK_UNLOCK(so);
3300                         goto integer;
3301
3302                 case SO_SNDBUF:
3303                         optval = SOLISTENING(so) ? so->sol_sbsnd_hiwat :
3304                             so->so_snd.sb_hiwat;
3305                         goto integer;
3306
3307                 case SO_RCVBUF:
3308                         optval = SOLISTENING(so) ? so->sol_sbrcv_hiwat :
3309                             so->so_rcv.sb_hiwat;
3310                         goto integer;
3311
3312                 case SO_SNDLOWAT:
3313                         optval = SOLISTENING(so) ? so->sol_sbsnd_lowat :
3314                             so->so_snd.sb_lowat;
3315                         goto integer;
3316
3317                 case SO_RCVLOWAT:
3318                         optval = SOLISTENING(so) ? so->sol_sbrcv_lowat :
3319                             so->so_rcv.sb_lowat;
3320                         goto integer;
3321
3322                 case SO_SNDTIMEO:
3323                 case SO_RCVTIMEO:
3324                         SOCK_LOCK(so);
3325                         tv = sbttotv(sopt->sopt_name == SO_SNDTIMEO ?
3326                             (SOLISTENING(so) ? so->sol_sbsnd_timeo :
3327                             so->so_snd.sb_timeo) :
3328                             (SOLISTENING(so) ? so->sol_sbrcv_timeo :
3329                             so->so_rcv.sb_timeo));
3330                         SOCK_UNLOCK(so);
3331 #ifdef COMPAT_FREEBSD32
3332                         if (SV_CURPROC_FLAG(SV_ILP32)) {
3333                                 struct timeval32 tv32;
3334
3335                                 CP(tv, tv32, tv_sec);
3336                                 CP(tv, tv32, tv_usec);
3337                                 error = sooptcopyout(sopt, &tv32, sizeof tv32);
3338                         } else
3339 #endif
3340                                 error = sooptcopyout(sopt, &tv, sizeof tv);
3341                         break;
3342
3343                 case SO_LABEL:
3344 #ifdef MAC
3345                         error = sooptcopyin(sopt, &extmac, sizeof(extmac),
3346                             sizeof(extmac));
3347                         if (error)
3348                                 goto bad;
3349                         error = mac_getsockopt_label(sopt->sopt_td->td_ucred,
3350                             so, &extmac);
3351                         if (error)
3352                                 goto bad;
3353                         error = sooptcopyout(sopt, &extmac, sizeof extmac);
3354 #else
3355                         error = EOPNOTSUPP;
3356 #endif
3357                         break;
3358
3359                 case SO_PEERLABEL:
3360 #ifdef MAC
3361                         error = sooptcopyin(sopt, &extmac, sizeof(extmac),
3362                             sizeof(extmac));
3363                         if (error)
3364                                 goto bad;
3365                         error = mac_getsockopt_peerlabel(
3366                             sopt->sopt_td->td_ucred, so, &extmac);
3367                         if (error)
3368                                 goto bad;
3369                         error = sooptcopyout(sopt, &extmac, sizeof extmac);
3370 #else
3371                         error = EOPNOTSUPP;
3372 #endif
3373                         break;
3374
3375                 case SO_LISTENQLIMIT:
3376                         optval = SOLISTENING(so) ? so->sol_qlimit : 0;
3377                         goto integer;
3378
3379                 case SO_LISTENQLEN:
3380                         optval = SOLISTENING(so) ? so->sol_qlen : 0;
3381                         goto integer;
3382
3383                 case SO_LISTENINCQLEN:
3384                         optval = SOLISTENING(so) ? so->sol_incqlen : 0;
3385                         goto integer;
3386
3387                 case SO_TS_CLOCK:
3388                         optval = so->so_ts_clock;
3389                         goto integer;
3390
3391                 case SO_MAX_PACING_RATE:
3392                         optval = so->so_max_pacing_rate;
3393                         goto integer;
3394
3395                 default:
3396                         if (V_socket_hhh[HHOOK_SOCKET_OPT]->hhh_nhooks > 0)
3397                                 error = hhook_run_socket(so, sopt,
3398                                     HHOOK_SOCKET_OPT);
3399                         else
3400                                 error = ENOPROTOOPT;
3401                         break;
3402                 }
3403         }
3404 #ifdef MAC
3405 bad:
3406 #endif
3407         CURVNET_RESTORE();
3408         return (error);
3409 }
3410
3411 int
3412 soopt_getm(struct sockopt *sopt, struct mbuf **mp)
3413 {
3414         struct mbuf *m, *m_prev;
3415         int sopt_size = sopt->sopt_valsize;
3416
3417         MGET(m, sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
3418         if (m == NULL)
3419                 return ENOBUFS;
3420         if (sopt_size > MLEN) {
3421                 MCLGET(m, sopt->sopt_td ? M_WAITOK : M_NOWAIT);
3422                 if ((m->m_flags & M_EXT) == 0) {
3423                         m_free(m);
3424                         return ENOBUFS;
3425                 }
3426                 m->m_len = min(MCLBYTES, sopt_size);
3427         } else {
3428                 m->m_len = min(MLEN, sopt_size);
3429         }
3430         sopt_size -= m->m_len;
3431         *mp = m;
3432         m_prev = m;
3433
3434         while (sopt_size) {
3435                 MGET(m, sopt->sopt_td ? M_WAITOK : M_NOWAIT, MT_DATA);
3436                 if (m == NULL) {
3437                         m_freem(*mp);
3438                         return ENOBUFS;
3439                 }
3440                 if (sopt_size > MLEN) {
3441                         MCLGET(m, sopt->sopt_td != NULL ? M_WAITOK :
3442                             M_NOWAIT);
3443                         if ((m->m_flags & M_EXT) == 0) {
3444                                 m_freem(m);
3445                                 m_freem(*mp);
3446                                 return ENOBUFS;
3447                         }
3448                         m->m_len = min(MCLBYTES, sopt_size);
3449                 } else {
3450                         m->m_len = min(MLEN, sopt_size);
3451                 }
3452                 sopt_size -= m->m_len;
3453                 m_prev->m_next = m;
3454                 m_prev = m;
3455         }
3456         return (0);
3457 }
3458
3459 int
3460 soopt_mcopyin(struct sockopt *sopt, struct mbuf *m)
3461 {
3462         struct mbuf *m0 = m;
3463
3464         if (sopt->sopt_val == NULL)
3465                 return (0);
3466         while (m != NULL && sopt->sopt_valsize >= m->m_len) {
3467                 if (sopt->sopt_td != NULL) {
3468                         int error;
3469
3470                         error = copyin(sopt->sopt_val, mtod(m, char *),
3471                             m->m_len);
3472                         if (error != 0) {
3473                                 m_freem(m0);
3474                                 return(error);
3475                         }
3476                 } else
3477                         bcopy(sopt->sopt_val, mtod(m, char *), m->m_len);
3478                 sopt->sopt_valsize -= m->m_len;
3479                 sopt->sopt_val = (char *)sopt->sopt_val + m->m_len;
3480                 m = m->m_next;
3481         }
3482         if (m != NULL) /* should be allocated enoughly at ip6_sooptmcopyin() */
3483                 panic("ip6_sooptmcopyin");
3484         return (0);
3485 }
3486
3487 int
3488 soopt_mcopyout(struct sockopt *sopt, struct mbuf *m)
3489 {
3490         struct mbuf *m0 = m;
3491         size_t valsize = 0;
3492
3493         if (sopt->sopt_val == NULL)
3494                 return (0);
3495         while (m != NULL && sopt->sopt_valsize >= m->m_len) {
3496                 if (sopt->sopt_td != NULL) {
3497                         int error;
3498
3499                         error = copyout(mtod(m, char *), sopt->sopt_val,
3500                             m->m_len);
3501                         if (error != 0) {
3502                                 m_freem(m0);
3503                                 return(error);
3504                         }
3505                 } else
3506                         bcopy(mtod(m, char *), sopt->sopt_val, m->m_len);
3507                 sopt->sopt_valsize -= m->m_len;
3508                 sopt->sopt_val = (char *)sopt->sopt_val + m->m_len;
3509                 valsize += m->m_len;
3510                 m = m->m_next;
3511         }
3512         if (m != NULL) {
3513                 /* enough soopt buffer should be given from user-land */
3514                 m_freem(m0);
3515                 return(EINVAL);
3516         }
3517         sopt->sopt_valsize = valsize;
3518         return (0);
3519 }
3520
3521 /*
3522  * sohasoutofband(): protocol notifies socket layer of the arrival of new
3523  * out-of-band data, which will then notify socket consumers.
3524  */
3525 void
3526 sohasoutofband(struct socket *so)
3527 {
3528
3529         if (so->so_sigio != NULL)
3530                 pgsigio(&so->so_sigio, SIGURG, 0);
3531         selwakeuppri(&so->so_rdsel, PSOCK);
3532 }
3533
3534 int
3535 sopoll(struct socket *so, int events, struct ucred *active_cred,
3536     struct thread *td)
3537 {
3538
3539         /*
3540          * We do not need to set or assert curvnet as long as everyone uses
3541          * sopoll_generic().
3542          */
3543         return (so->so_proto->pr_sopoll(so, events, active_cred, td));
3544 }
3545
3546 int
3547 sopoll_generic(struct socket *so, int events, struct ucred *active_cred,
3548     struct thread *td)
3549 {
3550         int revents;
3551
3552         SOCK_LOCK(so);
3553         if (SOLISTENING(so)) {
3554                 if (!(events & (POLLIN | POLLRDNORM)))
3555                         revents = 0;
3556                 else if (!TAILQ_EMPTY(&so->sol_comp))
3557                         revents = events & (POLLIN | POLLRDNORM);
3558                 else if ((events & POLLINIGNEOF) == 0 && so->so_error)
3559                         revents = (events & (POLLIN | POLLRDNORM)) | POLLHUP;
3560                 else {
3561                         selrecord(td, &so->so_rdsel);
3562                         revents = 0;
3563                 }
3564         } else {
3565                 revents = 0;
3566                 SOCK_SENDBUF_LOCK(so);
3567                 SOCK_RECVBUF_LOCK(so);
3568                 if (events & (POLLIN | POLLRDNORM))
3569                         if (soreadabledata(so))
3570                                 revents |= events & (POLLIN | POLLRDNORM);
3571                 if (events & (POLLOUT | POLLWRNORM))
3572                         if (sowriteable(so))
3573                                 revents |= events & (POLLOUT | POLLWRNORM);
3574                 if (events & (POLLPRI | POLLRDBAND))
3575                         if (so->so_oobmark ||
3576                             (so->so_rcv.sb_state & SBS_RCVATMARK))
3577                                 revents |= events & (POLLPRI | POLLRDBAND);
3578                 if ((events & POLLINIGNEOF) == 0) {
3579                         if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
3580                                 revents |= events & (POLLIN | POLLRDNORM);
3581                                 if (so->so_snd.sb_state & SBS_CANTSENDMORE)
3582                                         revents |= POLLHUP;
3583                         }
3584                 }
3585                 if (so->so_rcv.sb_state & SBS_CANTRCVMORE)
3586                         revents |= events & POLLRDHUP;
3587                 if (revents == 0) {
3588                         if (events &
3589                             (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND | POLLRDHUP)) {
3590                                 selrecord(td, &so->so_rdsel);
3591                                 so->so_rcv.sb_flags |= SB_SEL;
3592                         }
3593                         if (events & (POLLOUT | POLLWRNORM)) {
3594                                 selrecord(td, &so->so_wrsel);
3595                                 so->so_snd.sb_flags |= SB_SEL;
3596                         }
3597                 }
3598                 SOCK_RECVBUF_UNLOCK(so);
3599                 SOCK_SENDBUF_UNLOCK(so);
3600         }
3601         SOCK_UNLOCK(so);
3602         return (revents);
3603 }
3604
3605 int
3606 soo_kqfilter(struct file *fp, struct knote *kn)
3607 {
3608         struct socket *so = kn->kn_fp->f_data;
3609         struct sockbuf *sb;
3610         sb_which which;
3611         struct knlist *knl;
3612
3613         switch (kn->kn_filter) {
3614         case EVFILT_READ:
3615                 kn->kn_fop = &soread_filtops;
3616                 knl = &so->so_rdsel.si_note;
3617                 sb = &so->so_rcv;
3618                 which = SO_RCV;
3619                 break;
3620         case EVFILT_WRITE:
3621                 kn->kn_fop = &sowrite_filtops;
3622                 knl = &so->so_wrsel.si_note;
3623                 sb = &so->so_snd;
3624                 which = SO_SND;
3625                 break;
3626         case EVFILT_EMPTY:
3627                 kn->kn_fop = &soempty_filtops;
3628                 knl = &so->so_wrsel.si_note;
3629                 sb = &so->so_snd;
3630                 which = SO_SND;
3631                 break;
3632         default:
3633                 return (EINVAL);
3634         }
3635
3636         SOCK_LOCK(so);
3637         if (SOLISTENING(so)) {
3638                 knlist_add(knl, kn, 1);
3639         } else {
3640                 SOCK_BUF_LOCK(so, which);
3641                 knlist_add(knl, kn, 1);
3642                 sb->sb_flags |= SB_KNOTE;
3643                 SOCK_BUF_UNLOCK(so, which);
3644         }
3645         SOCK_UNLOCK(so);
3646         return (0);
3647 }
3648
3649 static void
3650 filt_sordetach(struct knote *kn)
3651 {
3652         struct socket *so = kn->kn_fp->f_data;
3653
3654         so_rdknl_lock(so);
3655         knlist_remove(&so->so_rdsel.si_note, kn, 1);
3656         if (!SOLISTENING(so) && knlist_empty(&so->so_rdsel.si_note))
3657                 so->so_rcv.sb_flags &= ~SB_KNOTE;
3658         so_rdknl_unlock(so);
3659 }
3660
3661 /*ARGSUSED*/
3662 static int
3663 filt_soread(struct knote *kn, long hint)
3664 {
3665         struct socket *so;
3666
3667         so = kn->kn_fp->f_data;
3668
3669         if (SOLISTENING(so)) {
3670                 SOCK_LOCK_ASSERT(so);
3671                 kn->kn_data = so->sol_qlen;
3672                 if (so->so_error) {
3673                         kn->kn_flags |= EV_EOF;
3674                         kn->kn_fflags = so->so_error;
3675                         return (1);
3676                 }
3677                 return (!TAILQ_EMPTY(&so->sol_comp));
3678         }
3679
3680         SOCK_RECVBUF_LOCK_ASSERT(so);
3681
3682         kn->kn_data = sbavail(&so->so_rcv) - so->so_rcv.sb_ctl;
3683         if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {
3684                 kn->kn_flags |= EV_EOF;
3685                 kn->kn_fflags = so->so_error;
3686                 return (1);
3687         } else if (so->so_error || so->so_rerror)
3688                 return (1);
3689
3690         if (kn->kn_sfflags & NOTE_LOWAT) {
3691                 if (kn->kn_data >= kn->kn_sdata)
3692                         return (1);
3693         } else if (sbavail(&so->so_rcv) >= so->so_rcv.sb_lowat)
3694                 return (1);
3695
3696         /* This hook returning non-zero indicates an event, not error */
3697         return (hhook_run_socket(so, NULL, HHOOK_FILT_SOREAD));
3698 }
3699
3700 static void
3701 filt_sowdetach(struct knote *kn)
3702 {
3703         struct socket *so = kn->kn_fp->f_data;
3704
3705         so_wrknl_lock(so);
3706         knlist_remove(&so->so_wrsel.si_note, kn, 1);
3707         if (!SOLISTENING(so) && knlist_empty(&so->so_wrsel.si_note))
3708                 so->so_snd.sb_flags &= ~SB_KNOTE;
3709         so_wrknl_unlock(so);
3710 }
3711
3712 /*ARGSUSED*/
3713 static int
3714 filt_sowrite(struct knote *kn, long hint)
3715 {
3716         struct socket *so;
3717
3718         so = kn->kn_fp->f_data;
3719
3720         if (SOLISTENING(so))
3721                 return (0);
3722
3723         SOCK_SENDBUF_LOCK_ASSERT(so);
3724         kn->kn_data = sbspace(&so->so_snd);
3725
3726         hhook_run_socket(so, kn, HHOOK_FILT_SOWRITE);
3727
3728         if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
3729                 kn->kn_flags |= EV_EOF;
3730                 kn->kn_fflags = so->so_error;
3731                 return (1);
3732         } else if (so->so_error)        /* temporary udp error */
3733                 return (1);
3734         else if (((so->so_state & SS_ISCONNECTED) == 0) &&
3735             (so->so_proto->pr_flags & PR_CONNREQUIRED))
3736                 return (0);
3737         else if (kn->kn_sfflags & NOTE_LOWAT)
3738                 return (kn->kn_data >= kn->kn_sdata);
3739         else
3740                 return (kn->kn_data >= so->so_snd.sb_lowat);
3741 }
3742
3743 static int
3744 filt_soempty(struct knote *kn, long hint)
3745 {
3746         struct socket *so;
3747
3748         so = kn->kn_fp->f_data;
3749
3750         if (SOLISTENING(so))
3751                 return (1);
3752
3753         SOCK_SENDBUF_LOCK_ASSERT(so);
3754         kn->kn_data = sbused(&so->so_snd);
3755
3756         if (kn->kn_data == 0)
3757                 return (1);
3758         else
3759                 return (0);
3760 }
3761
3762 int
3763 socheckuid(struct socket *so, uid_t uid)
3764 {
3765
3766         if (so == NULL)
3767                 return (EPERM);
3768         if (so->so_cred->cr_uid != uid)
3769                 return (EPERM);
3770         return (0);
3771 }
3772
3773 /*
3774  * These functions are used by protocols to notify the socket layer (and its
3775  * consumers) of state changes in the sockets driven by protocol-side events.
3776  */
3777
3778 /*
3779  * Procedures to manipulate state flags of socket and do appropriate wakeups.
3780  *
3781  * Normal sequence from the active (originating) side is that
3782  * soisconnecting() is called during processing of connect() call, resulting
3783  * in an eventual call to soisconnected() if/when the connection is
3784  * established.  When the connection is torn down soisdisconnecting() is
3785  * called during processing of disconnect() call, and soisdisconnected() is
3786  * called when the connection to the peer is totally severed.  The semantics
3787  * of these routines are such that connectionless protocols can call
3788  * soisconnected() and soisdisconnected() only, bypassing the in-progress
3789  * calls when setting up a ``connection'' takes no time.
3790  *
3791  * From the passive side, a socket is created with two queues of sockets:
3792  * so_incomp for connections in progress and so_comp for connections already
3793  * made and awaiting user acceptance.  As a protocol is preparing incoming
3794  * connections, it creates a socket structure queued on so_incomp by calling
3795  * sonewconn().  When the connection is established, soisconnected() is
3796  * called, and transfers the socket structure to so_comp, making it available
3797  * to accept().
3798  *
3799  * If a socket is closed with sockets on either so_incomp or so_comp, these
3800  * sockets are dropped.
3801  *
3802  * If higher-level protocols are implemented in the kernel, the wakeups done
3803  * here will sometimes cause software-interrupt process scheduling.
3804  */
3805 void
3806 soisconnecting(struct socket *so)
3807 {
3808
3809         SOCK_LOCK(so);
3810         so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
3811         so->so_state |= SS_ISCONNECTING;
3812         SOCK_UNLOCK(so);
3813 }
3814
3815 void
3816 soisconnected(struct socket *so)
3817 {
3818         bool last __diagused;
3819
3820         SOCK_LOCK(so);
3821         so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING);
3822         so->so_state |= SS_ISCONNECTED;
3823
3824         if (so->so_qstate == SQ_INCOMP) {
3825                 struct socket *head = so->so_listen;
3826                 int ret;
3827
3828                 KASSERT(head, ("%s: so %p on incomp of NULL", __func__, so));
3829                 /*
3830                  * Promoting a socket from incomplete queue to complete, we
3831                  * need to go through reverse order of locking.  We first do
3832                  * trylock, and if that doesn't succeed, we go the hard way
3833                  * leaving a reference and rechecking consistency after proper
3834                  * locking.
3835                  */
3836                 if (__predict_false(SOLISTEN_TRYLOCK(head) == 0)) {
3837                         soref(head);
3838                         SOCK_UNLOCK(so);
3839                         SOLISTEN_LOCK(head);
3840                         SOCK_LOCK(so);
3841                         if (__predict_false(head != so->so_listen)) {
3842                                 /*
3843                                  * The socket went off the listen queue,
3844                                  * should be lost race to close(2) of sol.
3845                                  * The socket is about to soabort().
3846                                  */
3847                                 SOCK_UNLOCK(so);
3848                                 sorele_locked(head);
3849                                 return;
3850                         }
3851                         last = refcount_release(&head->so_count);
3852                         KASSERT(!last, ("%s: released last reference for %p",
3853                             __func__, head));
3854                 }
3855 again:
3856                 if ((so->so_options & SO_ACCEPTFILTER) == 0) {
3857                         TAILQ_REMOVE(&head->sol_incomp, so, so_list);
3858                         head->sol_incqlen--;
3859                         TAILQ_INSERT_TAIL(&head->sol_comp, so, so_list);
3860                         head->sol_qlen++;
3861                         so->so_qstate = SQ_COMP;
3862                         SOCK_UNLOCK(so);
3863                         solisten_wakeup(head);  /* unlocks */
3864                 } else {
3865                         SOCK_RECVBUF_LOCK(so);
3866                         soupcall_set(so, SO_RCV,
3867                             head->sol_accept_filter->accf_callback,
3868                             head->sol_accept_filter_arg);
3869                         so->so_options &= ~SO_ACCEPTFILTER;
3870                         ret = head->sol_accept_filter->accf_callback(so,
3871                             head->sol_accept_filter_arg, M_NOWAIT);
3872                         if (ret == SU_ISCONNECTED) {
3873                                 soupcall_clear(so, SO_RCV);
3874                                 SOCK_RECVBUF_UNLOCK(so);
3875                                 goto again;
3876                         }
3877                         SOCK_RECVBUF_UNLOCK(so);
3878                         SOCK_UNLOCK(so);
3879                         SOLISTEN_UNLOCK(head);
3880                 }
3881                 return;
3882         }
3883         SOCK_UNLOCK(so);
3884         wakeup(&so->so_timeo);
3885         sorwakeup(so);
3886         sowwakeup(so);
3887 }
3888
3889 void
3890 soisdisconnecting(struct socket *so)
3891 {
3892
3893         SOCK_LOCK(so);
3894         so->so_state &= ~SS_ISCONNECTING;
3895         so->so_state |= SS_ISDISCONNECTING;
3896
3897         if (!SOLISTENING(so)) {
3898                 SOCK_RECVBUF_LOCK(so);
3899                 socantrcvmore_locked(so);
3900                 SOCK_SENDBUF_LOCK(so);
3901                 socantsendmore_locked(so);
3902         }
3903         SOCK_UNLOCK(so);
3904         wakeup(&so->so_timeo);
3905 }
3906
3907 void
3908 soisdisconnected(struct socket *so)
3909 {
3910
3911         SOCK_LOCK(so);
3912
3913         /*
3914          * There is at least one reader of so_state that does not
3915          * acquire socket lock, namely soreceive_generic().  Ensure
3916          * that it never sees all flags that track connection status
3917          * cleared, by ordering the update with a barrier semantic of
3918          * our release thread fence.
3919          */
3920         so->so_state |= SS_ISDISCONNECTED;
3921         atomic_thread_fence_rel();
3922         so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
3923
3924         if (!SOLISTENING(so)) {
3925                 SOCK_UNLOCK(so);
3926                 SOCK_RECVBUF_LOCK(so);
3927                 socantrcvmore_locked(so);
3928                 SOCK_SENDBUF_LOCK(so);
3929                 sbdrop_locked(&so->so_snd, sbused(&so->so_snd));
3930                 socantsendmore_locked(so);
3931         } else
3932                 SOCK_UNLOCK(so);
3933         wakeup(&so->so_timeo);
3934 }
3935
3936 int
3937 soiolock(struct socket *so, struct sx *sx, int flags)
3938 {
3939         int error;
3940
3941         KASSERT((flags & SBL_VALID) == flags,
3942             ("soiolock: invalid flags %#x", flags));
3943
3944         if ((flags & SBL_WAIT) != 0) {
3945                 if ((flags & SBL_NOINTR) != 0) {
3946                         sx_xlock(sx);
3947                 } else {
3948                         error = sx_xlock_sig(sx);
3949                         if (error != 0)
3950                                 return (error);
3951                 }
3952         } else if (!sx_try_xlock(sx)) {
3953                 return (EWOULDBLOCK);
3954         }
3955
3956         if (__predict_false(SOLISTENING(so))) {
3957                 sx_xunlock(sx);
3958                 return (ENOTCONN);
3959         }
3960         return (0);
3961 }
3962
3963 void
3964 soiounlock(struct sx *sx)
3965 {
3966         sx_xunlock(sx);
3967 }
3968
3969 /*
3970  * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.
3971  */
3972 struct sockaddr *
3973 sodupsockaddr(const struct sockaddr *sa, int mflags)
3974 {
3975         struct sockaddr *sa2;
3976
3977         sa2 = malloc(sa->sa_len, M_SONAME, mflags);
3978         if (sa2)
3979                 bcopy(sa, sa2, sa->sa_len);
3980         return sa2;
3981 }
3982
3983 /*
3984  * Register per-socket destructor.
3985  */
3986 void
3987 sodtor_set(struct socket *so, so_dtor_t *func)
3988 {
3989
3990         SOCK_LOCK_ASSERT(so);
3991         so->so_dtor = func;
3992 }
3993
3994 /*
3995  * Register per-socket buffer upcalls.
3996  */
3997 void
3998 soupcall_set(struct socket *so, sb_which which, so_upcall_t func, void *arg)
3999 {
4000         struct sockbuf *sb;
4001
4002         KASSERT(!SOLISTENING(so), ("%s: so %p listening", __func__, so));
4003
4004         switch (which) {
4005         case SO_RCV:
4006                 sb = &so->so_rcv;
4007                 break;
4008         case SO_SND:
4009                 sb = &so->so_snd;
4010                 break;
4011         }
4012         SOCK_BUF_LOCK_ASSERT(so, which);
4013         sb->sb_upcall = func;
4014         sb->sb_upcallarg = arg;
4015         sb->sb_flags |= SB_UPCALL;
4016 }
4017
4018 void
4019 soupcall_clear(struct socket *so, sb_which which)
4020 {
4021         struct sockbuf *sb;
4022
4023         KASSERT(!SOLISTENING(so), ("%s: so %p listening", __func__, so));
4024
4025         switch (which) {
4026         case SO_RCV:
4027                 sb = &so->so_rcv;
4028                 break;
4029         case SO_SND:
4030                 sb = &so->so_snd;
4031                 break;
4032         }
4033         SOCK_BUF_LOCK_ASSERT(so, which);
4034         KASSERT(sb->sb_upcall != NULL,
4035             ("%s: so %p no upcall to clear", __func__, so));
4036         sb->sb_upcall = NULL;
4037         sb->sb_upcallarg = NULL;
4038         sb->sb_flags &= ~SB_UPCALL;
4039 }
4040
4041 void
4042 solisten_upcall_set(struct socket *so, so_upcall_t func, void *arg)
4043 {
4044
4045         SOLISTEN_LOCK_ASSERT(so);
4046         so->sol_upcall = func;
4047         so->sol_upcallarg = arg;
4048 }
4049
4050 static void
4051 so_rdknl_lock(void *arg)
4052 {
4053         struct socket *so = arg;
4054
4055 retry:
4056         if (SOLISTENING(so)) {
4057                 SOLISTEN_LOCK(so);
4058         } else {
4059                 SOCK_RECVBUF_LOCK(so);
4060                 if (__predict_false(SOLISTENING(so))) {
4061                         SOCK_RECVBUF_UNLOCK(so);
4062                         goto retry;
4063                 }
4064         }
4065 }
4066
4067 static void
4068 so_rdknl_unlock(void *arg)
4069 {
4070         struct socket *so = arg;
4071
4072         if (SOLISTENING(so))
4073                 SOLISTEN_UNLOCK(so);
4074         else
4075                 SOCK_RECVBUF_UNLOCK(so);
4076 }
4077
4078 static void
4079 so_rdknl_assert_lock(void *arg, int what)
4080 {
4081         struct socket *so = arg;
4082
4083         if (what == LA_LOCKED) {
4084                 if (SOLISTENING(so))
4085                         SOLISTEN_LOCK_ASSERT(so);
4086                 else
4087                         SOCK_RECVBUF_LOCK_ASSERT(so);
4088         } else {
4089                 if (SOLISTENING(so))
4090                         SOLISTEN_UNLOCK_ASSERT(so);
4091                 else
4092                         SOCK_RECVBUF_UNLOCK_ASSERT(so);
4093         }
4094 }
4095
4096 static void
4097 so_wrknl_lock(void *arg)
4098 {
4099         struct socket *so = arg;
4100
4101 retry:
4102         if (SOLISTENING(so)) {
4103                 SOLISTEN_LOCK(so);
4104         } else {
4105                 SOCK_SENDBUF_LOCK(so);
4106                 if (__predict_false(SOLISTENING(so))) {
4107                         SOCK_SENDBUF_UNLOCK(so);
4108                         goto retry;
4109                 }
4110         }
4111 }
4112
4113 static void
4114 so_wrknl_unlock(void *arg)
4115 {
4116         struct socket *so = arg;
4117
4118         if (SOLISTENING(so))
4119                 SOLISTEN_UNLOCK(so);
4120         else
4121                 SOCK_SENDBUF_UNLOCK(so);
4122 }
4123
4124 static void
4125 so_wrknl_assert_lock(void *arg, int what)
4126 {
4127         struct socket *so = arg;
4128
4129         if (what == LA_LOCKED) {
4130                 if (SOLISTENING(so))
4131                         SOLISTEN_LOCK_ASSERT(so);
4132                 else
4133                         SOCK_SENDBUF_LOCK_ASSERT(so);
4134         } else {
4135                 if (SOLISTENING(so))
4136                         SOLISTEN_UNLOCK_ASSERT(so);
4137                 else
4138                         SOCK_SENDBUF_UNLOCK_ASSERT(so);
4139         }
4140 }
4141
4142 /*
4143  * Create an external-format (``xsocket'') structure using the information in
4144  * the kernel-format socket structure pointed to by so.  This is done to
4145  * reduce the spew of irrelevant information over this interface, to isolate
4146  * user code from changes in the kernel structure, and potentially to provide
4147  * information-hiding if we decide that some of this information should be
4148  * hidden from users.
4149  */
4150 void
4151 sotoxsocket(struct socket *so, struct xsocket *xso)
4152 {
4153
4154         bzero(xso, sizeof(*xso));
4155         xso->xso_len = sizeof *xso;
4156         xso->xso_so = (uintptr_t)so;
4157         xso->so_type = so->so_type;
4158         xso->so_options = so->so_options;
4159         xso->so_linger = so->so_linger;
4160         xso->so_state = so->so_state;
4161         xso->so_pcb = (uintptr_t)so->so_pcb;
4162         xso->xso_protocol = so->so_proto->pr_protocol;
4163         xso->xso_family = so->so_proto->pr_domain->dom_family;
4164         xso->so_timeo = so->so_timeo;
4165         xso->so_error = so->so_error;
4166         xso->so_uid = so->so_cred->cr_uid;
4167         xso->so_pgid = so->so_sigio ? so->so_sigio->sio_pgid : 0;
4168         if (SOLISTENING(so)) {
4169                 xso->so_qlen = so->sol_qlen;
4170                 xso->so_incqlen = so->sol_incqlen;
4171                 xso->so_qlimit = so->sol_qlimit;
4172                 xso->so_oobmark = 0;
4173         } else {
4174                 xso->so_state |= so->so_qstate;
4175                 xso->so_qlen = xso->so_incqlen = xso->so_qlimit = 0;
4176                 xso->so_oobmark = so->so_oobmark;
4177                 sbtoxsockbuf(&so->so_snd, &xso->so_snd);
4178                 sbtoxsockbuf(&so->so_rcv, &xso->so_rcv);
4179         }
4180 }
4181
4182 struct sockbuf *
4183 so_sockbuf_rcv(struct socket *so)
4184 {
4185
4186         return (&so->so_rcv);
4187 }
4188
4189 struct sockbuf *
4190 so_sockbuf_snd(struct socket *so)
4191 {
4192
4193         return (&so->so_snd);
4194 }
4195
4196 int
4197 so_state_get(const struct socket *so)
4198 {
4199
4200         return (so->so_state);
4201 }
4202
4203 void
4204 so_state_set(struct socket *so, int val)
4205 {
4206
4207         so->so_state = val;
4208 }
4209
4210 int
4211 so_options_get(const struct socket *so)
4212 {
4213
4214         return (so->so_options);
4215 }
4216
4217 void
4218 so_options_set(struct socket *so, int val)
4219 {
4220
4221         so->so_options = val;
4222 }
4223
4224 int
4225 so_error_get(const struct socket *so)
4226 {
4227
4228         return (so->so_error);
4229 }
4230
4231 void
4232 so_error_set(struct socket *so, int val)
4233 {
4234
4235         so->so_error = val;
4236 }
4237
4238 int
4239 so_linger_get(const struct socket *so)
4240 {
4241
4242         return (so->so_linger);
4243 }
4244
4245 void
4246 so_linger_set(struct socket *so, int val)
4247 {
4248
4249         KASSERT(val >= 0 && val <= USHRT_MAX && val <= (INT_MAX / hz),
4250             ("%s: val %d out of range", __func__, val));
4251
4252         so->so_linger = val;
4253 }
4254
4255 struct protosw *
4256 so_protosw_get(const struct socket *so)
4257 {
4258
4259         return (so->so_proto);
4260 }
4261
4262 void
4263 so_protosw_set(struct socket *so, struct protosw *val)
4264 {
4265
4266         so->so_proto = val;
4267 }
4268
4269 void
4270 so_sorwakeup(struct socket *so)
4271 {
4272
4273         sorwakeup(so);
4274 }
4275
4276 void
4277 so_sowwakeup(struct socket *so)
4278 {
4279
4280         sowwakeup(so);
4281 }
4282
4283 void
4284 so_sorwakeup_locked(struct socket *so)
4285 {
4286
4287         sorwakeup_locked(so);
4288 }
4289
4290 void
4291 so_sowwakeup_locked(struct socket *so)
4292 {
4293
4294         sowwakeup_locked(so);
4295 }
4296
4297 void
4298 so_lock(struct socket *so)
4299 {
4300
4301         SOCK_LOCK(so);
4302 }
4303
4304 void
4305 so_unlock(struct socket *so)
4306 {
4307
4308         SOCK_UNLOCK(so);
4309 }