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