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