Home | History | Annotate | Line # | Download | only in kern
uipc_socket.c revision 1.211
      1  1.211       chs /*	$NetBSD: uipc_socket.c,v 1.211 2012/07/09 04:35:13 chs Exp $	*/
      2   1.64   thorpej 
      3   1.64   thorpej /*-
      4  1.188        ad  * Copyright (c) 2002, 2007, 2008, 2009 The NetBSD Foundation, Inc.
      5   1.64   thorpej  * All rights reserved.
      6   1.64   thorpej  *
      7   1.64   thorpej  * This code is derived from software contributed to The NetBSD Foundation
      8  1.188        ad  * by Jason R. Thorpe of Wasabi Systems, Inc, and by Andrew Doran.
      9   1.64   thorpej  *
     10   1.64   thorpej  * Redistribution and use in source and binary forms, with or without
     11   1.64   thorpej  * modification, are permitted provided that the following conditions
     12   1.64   thorpej  * are met:
     13   1.64   thorpej  * 1. Redistributions of source code must retain the above copyright
     14   1.64   thorpej  *    notice, this list of conditions and the following disclaimer.
     15   1.64   thorpej  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.64   thorpej  *    notice, this list of conditions and the following disclaimer in the
     17   1.64   thorpej  *    documentation and/or other materials provided with the distribution.
     18   1.64   thorpej  *
     19   1.64   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20   1.64   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21   1.64   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22   1.64   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23   1.64   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24   1.64   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25   1.64   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26   1.64   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27   1.64   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28   1.64   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29   1.64   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     30   1.64   thorpej  */
     31   1.16       cgd 
     32    1.1       cgd /*
     33  1.159        ad  * Copyright (c) 2004 The FreeBSD Foundation
     34  1.159        ad  * Copyright (c) 2004 Robert Watson
     35   1.15   mycroft  * Copyright (c) 1982, 1986, 1988, 1990, 1993
     36   1.15   mycroft  *	The Regents of the University of California.  All rights reserved.
     37    1.1       cgd  *
     38    1.1       cgd  * Redistribution and use in source and binary forms, with or without
     39    1.1       cgd  * modification, are permitted provided that the following conditions
     40    1.1       cgd  * are met:
     41    1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     42    1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     43    1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     44    1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     45    1.1       cgd  *    documentation and/or other materials provided with the distribution.
     46   1.85       agc  * 3. Neither the name of the University nor the names of its contributors
     47    1.1       cgd  *    may be used to endorse or promote products derived from this software
     48    1.1       cgd  *    without specific prior written permission.
     49    1.1       cgd  *
     50    1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     51    1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     52    1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     53    1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     54    1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     55    1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     56    1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     57    1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     58    1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     59    1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     60    1.1       cgd  * SUCH DAMAGE.
     61    1.1       cgd  *
     62   1.32      fvdl  *	@(#)uipc_socket.c	8.6 (Berkeley) 5/2/95
     63    1.1       cgd  */
     64   1.59     lukem 
     65   1.59     lukem #include <sys/cdefs.h>
     66  1.211       chs __KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.211 2012/07/09 04:35:13 chs Exp $");
     67   1.64   thorpej 
     68  1.179  christos #include "opt_compat_netbsd.h"
     69   1.64   thorpej #include "opt_sock_counters.h"
     70   1.64   thorpej #include "opt_sosend_loan.h"
     71   1.81    martin #include "opt_mbuftrace.h"
     72   1.84     ragge #include "opt_somaxkva.h"
     73  1.167        ad #include "opt_multiprocessor.h"	/* XXX */
     74    1.1       cgd 
     75    1.9   mycroft #include <sys/param.h>
     76    1.9   mycroft #include <sys/systm.h>
     77    1.9   mycroft #include <sys/proc.h>
     78    1.9   mycroft #include <sys/file.h>
     79  1.142    dyoung #include <sys/filedesc.h>
     80  1.173    plunky #include <sys/kmem.h>
     81    1.9   mycroft #include <sys/mbuf.h>
     82    1.9   mycroft #include <sys/domain.h>
     83    1.9   mycroft #include <sys/kernel.h>
     84    1.9   mycroft #include <sys/protosw.h>
     85    1.9   mycroft #include <sys/socket.h>
     86    1.9   mycroft #include <sys/socketvar.h>
     87   1.21  christos #include <sys/signalvar.h>
     88    1.9   mycroft #include <sys/resourcevar.h>
     89  1.174     pooka #include <sys/uidinfo.h>
     90   1.72  jdolecek #include <sys/event.h>
     91   1.89  christos #include <sys/poll.h>
     92  1.118      elad #include <sys/kauth.h>
     93  1.136        ad #include <sys/mutex.h>
     94  1.136        ad #include <sys/condvar.h>
     95  1.205    bouyer #include <sys/kthread.h>
     96   1.37   thorpej 
     97  1.179  christos #ifdef COMPAT_50
     98  1.179  christos #include <compat/sys/time.h>
     99  1.184  christos #include <compat/sys/socket.h>
    100  1.179  christos #endif
    101  1.179  christos 
    102  1.202  uebayasi #include <uvm/uvm_extern.h>
    103  1.202  uebayasi #include <uvm/uvm_loan.h>
    104  1.202  uebayasi #include <uvm/uvm_page.h>
    105   1.64   thorpej 
    106   1.77   thorpej MALLOC_DEFINE(M_SOOPTS, "soopts", "socket options");
    107   1.77   thorpej MALLOC_DEFINE(M_SONAME, "soname", "socket name");
    108   1.37   thorpej 
    109  1.142    dyoung extern const struct fileops socketops;
    110  1.142    dyoung 
    111   1.54     lukem extern int	somaxconn;			/* patchable (XXX sysctl) */
    112   1.54     lukem int		somaxconn = SOMAXCONN;
    113  1.160        ad kmutex_t	*softnet_lock;
    114   1.49  jonathan 
    115   1.64   thorpej #ifdef SOSEND_COUNTERS
    116   1.64   thorpej #include <sys/device.h>
    117   1.64   thorpej 
    118  1.113   thorpej static struct evcnt sosend_loan_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    119   1.64   thorpej     NULL, "sosend", "loan big");
    120  1.113   thorpej static struct evcnt sosend_copy_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    121   1.64   thorpej     NULL, "sosend", "copy big");
    122  1.113   thorpej static struct evcnt sosend_copy_small = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    123   1.64   thorpej     NULL, "sosend", "copy small");
    124  1.113   thorpej static struct evcnt sosend_kvalimit = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    125   1.64   thorpej     NULL, "sosend", "kva limit");
    126   1.64   thorpej 
    127   1.64   thorpej #define	SOSEND_COUNTER_INCR(ev)		(ev)->ev_count++
    128   1.64   thorpej 
    129  1.101      matt EVCNT_ATTACH_STATIC(sosend_loan_big);
    130  1.101      matt EVCNT_ATTACH_STATIC(sosend_copy_big);
    131  1.101      matt EVCNT_ATTACH_STATIC(sosend_copy_small);
    132  1.101      matt EVCNT_ATTACH_STATIC(sosend_kvalimit);
    133   1.64   thorpej #else
    134   1.64   thorpej 
    135   1.64   thorpej #define	SOSEND_COUNTER_INCR(ev)		/* nothing */
    136   1.64   thorpej 
    137   1.64   thorpej #endif /* SOSEND_COUNTERS */
    138   1.64   thorpej 
    139  1.167        ad #if defined(SOSEND_NO_LOAN) || defined(MULTIPROCESSOR)
    140  1.121      yamt int sock_loan_thresh = -1;
    141   1.71   thorpej #else
    142  1.121      yamt int sock_loan_thresh = 4096;
    143   1.65   thorpej #endif
    144   1.64   thorpej 
    145  1.136        ad static kmutex_t so_pendfree_lock;
    146  1.205    bouyer static struct mbuf *so_pendfree = NULL;
    147   1.64   thorpej 
    148   1.84     ragge #ifndef SOMAXKVA
    149   1.84     ragge #define	SOMAXKVA (16 * 1024 * 1024)
    150   1.84     ragge #endif
    151   1.84     ragge int somaxkva = SOMAXKVA;
    152  1.113   thorpej static int socurkva;
    153  1.136        ad static kcondvar_t socurkva_cv;
    154   1.64   thorpej 
    155  1.191      elad static kauth_listener_t socket_listener;
    156  1.191      elad 
    157   1.64   thorpej #define	SOCK_LOAN_CHUNK		65536
    158   1.64   thorpej 
    159  1.205    bouyer static void sopendfree_thread(void *);
    160  1.205    bouyer static kcondvar_t pendfree_thread_cv;
    161  1.205    bouyer static lwp_t *sopendfree_lwp;
    162   1.93      yamt 
    163  1.178     pooka static void sysctl_kern_somaxkva_setup(void);
    164  1.178     pooka static struct sysctllog *socket_sysctllog;
    165  1.178     pooka 
    166  1.113   thorpej static vsize_t
    167  1.129      yamt sokvareserve(struct socket *so, vsize_t len)
    168   1.80      yamt {
    169   1.98  christos 	int error;
    170   1.80      yamt 
    171  1.136        ad 	mutex_enter(&so_pendfree_lock);
    172   1.80      yamt 	while (socurkva + len > somaxkva) {
    173   1.80      yamt 		SOSEND_COUNTER_INCR(&sosend_kvalimit);
    174  1.136        ad 		error = cv_wait_sig(&socurkva_cv, &so_pendfree_lock);
    175   1.98  christos 		if (error) {
    176   1.98  christos 			len = 0;
    177   1.98  christos 			break;
    178   1.98  christos 		}
    179   1.80      yamt 	}
    180   1.93      yamt 	socurkva += len;
    181  1.136        ad 	mutex_exit(&so_pendfree_lock);
    182   1.98  christos 	return len;
    183   1.95      yamt }
    184   1.95      yamt 
    185  1.113   thorpej static void
    186   1.95      yamt sokvaunreserve(vsize_t len)
    187   1.95      yamt {
    188   1.95      yamt 
    189  1.136        ad 	mutex_enter(&so_pendfree_lock);
    190   1.95      yamt 	socurkva -= len;
    191  1.136        ad 	cv_broadcast(&socurkva_cv);
    192  1.136        ad 	mutex_exit(&so_pendfree_lock);
    193   1.95      yamt }
    194   1.95      yamt 
    195   1.95      yamt /*
    196   1.95      yamt  * sokvaalloc: allocate kva for loan.
    197   1.95      yamt  */
    198   1.95      yamt 
    199   1.95      yamt vaddr_t
    200  1.209      matt sokvaalloc(vaddr_t sva, vsize_t len, struct socket *so)
    201   1.95      yamt {
    202   1.95      yamt 	vaddr_t lva;
    203   1.95      yamt 
    204   1.95      yamt 	/*
    205   1.95      yamt 	 * reserve kva.
    206   1.95      yamt 	 */
    207   1.95      yamt 
    208   1.98  christos 	if (sokvareserve(so, len) == 0)
    209   1.98  christos 		return 0;
    210   1.93      yamt 
    211   1.93      yamt 	/*
    212   1.93      yamt 	 * allocate kva.
    213   1.93      yamt 	 */
    214   1.80      yamt 
    215  1.209      matt 	lva = uvm_km_alloc(kernel_map, len, atop(sva) & uvmexp.colormask,
    216  1.209      matt 	    UVM_KMF_COLORMATCH | UVM_KMF_VAONLY | UVM_KMF_WAITVA);
    217   1.95      yamt 	if (lva == 0) {
    218   1.95      yamt 		sokvaunreserve(len);
    219   1.80      yamt 		return (0);
    220   1.95      yamt 	}
    221   1.80      yamt 
    222   1.80      yamt 	return lva;
    223   1.80      yamt }
    224   1.80      yamt 
    225   1.93      yamt /*
    226   1.93      yamt  * sokvafree: free kva for loan.
    227   1.93      yamt  */
    228   1.93      yamt 
    229   1.80      yamt void
    230   1.80      yamt sokvafree(vaddr_t sva, vsize_t len)
    231   1.80      yamt {
    232   1.93      yamt 
    233   1.93      yamt 	/*
    234   1.93      yamt 	 * free kva.
    235   1.93      yamt 	 */
    236   1.80      yamt 
    237  1.109      yamt 	uvm_km_free(kernel_map, sva, len, UVM_KMF_VAONLY);
    238   1.93      yamt 
    239   1.93      yamt 	/*
    240   1.93      yamt 	 * unreserve kva.
    241   1.93      yamt 	 */
    242   1.93      yamt 
    243   1.95      yamt 	sokvaunreserve(len);
    244   1.80      yamt }
    245   1.80      yamt 
    246   1.64   thorpej static void
    247  1.134  christos sodoloanfree(struct vm_page **pgs, void *buf, size_t size)
    248   1.64   thorpej {
    249  1.156      yamt 	vaddr_t sva, eva;
    250   1.64   thorpej 	vsize_t len;
    251  1.156      yamt 	int npgs;
    252  1.156      yamt 
    253  1.156      yamt 	KASSERT(pgs != NULL);
    254   1.64   thorpej 
    255   1.64   thorpej 	eva = round_page((vaddr_t) buf + size);
    256   1.64   thorpej 	sva = trunc_page((vaddr_t) buf);
    257   1.64   thorpej 	len = eva - sva;
    258   1.64   thorpej 	npgs = len >> PAGE_SHIFT;
    259   1.64   thorpej 
    260   1.64   thorpej 	pmap_kremove(sva, len);
    261   1.64   thorpej 	pmap_update(pmap_kernel());
    262   1.64   thorpej 	uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);
    263   1.80      yamt 	sokvafree(sva, len);
    264   1.64   thorpej }
    265   1.64   thorpej 
    266   1.93      yamt /*
    267  1.205    bouyer  * sopendfree_thread: free mbufs on "pendfree" list.
    268  1.136        ad  * unlock and relock so_pendfree_lock when freeing mbufs.
    269   1.93      yamt  */
    270   1.93      yamt 
    271  1.205    bouyer static void
    272  1.205    bouyer sopendfree_thread(void *v)
    273   1.93      yamt {
    274  1.137        ad 	struct mbuf *m, *next;
    275  1.205    bouyer 	size_t rv;
    276   1.93      yamt 
    277  1.205    bouyer 	mutex_enter(&so_pendfree_lock);
    278   1.64   thorpej 
    279  1.205    bouyer 	for (;;) {
    280  1.205    bouyer 		rv = 0;
    281  1.205    bouyer 		while (so_pendfree != NULL) {
    282  1.205    bouyer 			m = so_pendfree;
    283  1.205    bouyer 			so_pendfree = NULL;
    284  1.205    bouyer 			mutex_exit(&so_pendfree_lock);
    285  1.205    bouyer 
    286  1.205    bouyer 			for (; m != NULL; m = next) {
    287  1.205    bouyer 				next = m->m_next;
    288  1.205    bouyer 				KASSERT((~m->m_flags & (M_EXT|M_EXT_PAGES)) == 0);
    289  1.205    bouyer 				KASSERT(m->m_ext.ext_refcnt == 0);
    290  1.205    bouyer 
    291  1.205    bouyer 				rv += m->m_ext.ext_size;
    292  1.205    bouyer 				sodoloanfree(m->m_ext.ext_pgs, m->m_ext.ext_buf,
    293  1.205    bouyer 				    m->m_ext.ext_size);
    294  1.205    bouyer 				pool_cache_put(mb_cache, m);
    295  1.205    bouyer 			}
    296   1.93      yamt 
    297  1.205    bouyer 			mutex_enter(&so_pendfree_lock);
    298   1.93      yamt 		}
    299  1.205    bouyer 		if (rv)
    300  1.205    bouyer 			cv_broadcast(&socurkva_cv);
    301  1.205    bouyer 		cv_wait(&pendfree_thread_cv, &so_pendfree_lock);
    302   1.64   thorpej 	}
    303  1.205    bouyer 	panic("sopendfree_thread");
    304  1.205    bouyer 	/* NOTREACHED */
    305   1.64   thorpej }
    306   1.64   thorpej 
    307   1.80      yamt void
    308  1.134  christos soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)
    309   1.64   thorpej {
    310   1.64   thorpej 
    311  1.156      yamt 	KASSERT(m != NULL);
    312   1.64   thorpej 
    313   1.93      yamt 	/*
    314   1.93      yamt 	 * postpone freeing mbuf.
    315   1.93      yamt 	 *
    316   1.93      yamt 	 * we can't do it in interrupt context
    317   1.93      yamt 	 * because we need to put kva back to kernel_map.
    318   1.93      yamt 	 */
    319   1.93      yamt 
    320  1.136        ad 	mutex_enter(&so_pendfree_lock);
    321   1.92      yamt 	m->m_next = so_pendfree;
    322   1.92      yamt 	so_pendfree = m;
    323  1.205    bouyer 	cv_signal(&pendfree_thread_cv);
    324  1.136        ad 	mutex_exit(&so_pendfree_lock);
    325   1.64   thorpej }
    326   1.64   thorpej 
    327   1.64   thorpej static long
    328   1.64   thorpej sosend_loan(struct socket *so, struct uio *uio, struct mbuf *m, long space)
    329   1.64   thorpej {
    330   1.64   thorpej 	struct iovec *iov = uio->uio_iov;
    331   1.64   thorpej 	vaddr_t sva, eva;
    332   1.64   thorpej 	vsize_t len;
    333  1.156      yamt 	vaddr_t lva;
    334  1.156      yamt 	int npgs, error;
    335  1.156      yamt 	vaddr_t va;
    336  1.156      yamt 	int i;
    337   1.64   thorpej 
    338  1.116      yamt 	if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))
    339   1.64   thorpej 		return (0);
    340   1.64   thorpej 
    341   1.64   thorpej 	if (iov->iov_len < (size_t) space)
    342   1.64   thorpej 		space = iov->iov_len;
    343   1.64   thorpej 	if (space > SOCK_LOAN_CHUNK)
    344   1.64   thorpej 		space = SOCK_LOAN_CHUNK;
    345   1.64   thorpej 
    346   1.64   thorpej 	eva = round_page((vaddr_t) iov->iov_base + space);
    347   1.64   thorpej 	sva = trunc_page((vaddr_t) iov->iov_base);
    348   1.64   thorpej 	len = eva - sva;
    349   1.64   thorpej 	npgs = len >> PAGE_SHIFT;
    350   1.64   thorpej 
    351   1.79   thorpej 	KASSERT(npgs <= M_EXT_MAXPAGES);
    352   1.79   thorpej 
    353  1.209      matt 	lva = sokvaalloc(sva, len, so);
    354   1.64   thorpej 	if (lva == 0)
    355   1.80      yamt 		return 0;
    356   1.64   thorpej 
    357  1.116      yamt 	error = uvm_loan(&uio->uio_vmspace->vm_map, sva, len,
    358   1.79   thorpej 	    m->m_ext.ext_pgs, UVM_LOAN_TOPAGE);
    359   1.64   thorpej 	if (error) {
    360   1.80      yamt 		sokvafree(lva, len);
    361   1.64   thorpej 		return (0);
    362   1.64   thorpej 	}
    363   1.64   thorpej 
    364   1.64   thorpej 	for (i = 0, va = lva; i < npgs; i++, va += PAGE_SIZE)
    365   1.79   thorpej 		pmap_kenter_pa(va, VM_PAGE_TO_PHYS(m->m_ext.ext_pgs[i]),
    366  1.194    cegger 		    VM_PROT_READ, 0);
    367   1.64   thorpej 	pmap_update(pmap_kernel());
    368   1.64   thorpej 
    369   1.64   thorpej 	lva += (vaddr_t) iov->iov_base & PAGE_MASK;
    370   1.64   thorpej 
    371  1.134  christos 	MEXTADD(m, (void *) lva, space, M_MBUF, soloanfree, so);
    372   1.79   thorpej 	m->m_flags |= M_EXT_PAGES | M_EXT_ROMAP;
    373   1.64   thorpej 
    374   1.64   thorpej 	uio->uio_resid -= space;
    375   1.64   thorpej 	/* uio_offset not updated, not set/used for write(2) */
    376  1.134  christos 	uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + space;
    377   1.64   thorpej 	uio->uio_iov->iov_len -= space;
    378   1.64   thorpej 	if (uio->uio_iov->iov_len == 0) {
    379   1.64   thorpej 		uio->uio_iov++;
    380   1.64   thorpej 		uio->uio_iovcnt--;
    381   1.64   thorpej 	}
    382   1.64   thorpej 
    383   1.64   thorpej 	return (space);
    384   1.64   thorpej }
    385   1.64   thorpej 
    386  1.142    dyoung struct mbuf *
    387  1.147    dyoung getsombuf(struct socket *so, int type)
    388  1.142    dyoung {
    389  1.142    dyoung 	struct mbuf *m;
    390  1.142    dyoung 
    391  1.147    dyoung 	m = m_get(M_WAIT, type);
    392  1.142    dyoung 	MCLAIM(m, so->so_mowner);
    393  1.142    dyoung 	return m;
    394  1.142    dyoung }
    395  1.142    dyoung 
    396  1.191      elad static int
    397  1.191      elad socket_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
    398  1.191      elad     void *arg0, void *arg1, void *arg2, void *arg3)
    399  1.191      elad {
    400  1.191      elad 	int result;
    401  1.191      elad 	enum kauth_network_req req;
    402  1.191      elad 
    403  1.191      elad 	result = KAUTH_RESULT_DEFER;
    404  1.191      elad 	req = (enum kauth_network_req)arg0;
    405  1.191      elad 
    406  1.193      elad 	if ((action != KAUTH_NETWORK_SOCKET) &&
    407  1.193      elad 	    (action != KAUTH_NETWORK_BIND))
    408  1.191      elad 		return result;
    409  1.191      elad 
    410  1.191      elad 	switch (req) {
    411  1.193      elad 	case KAUTH_REQ_NETWORK_BIND_PORT:
    412  1.193      elad 		result = KAUTH_RESULT_ALLOW;
    413  1.193      elad 		break;
    414  1.193      elad 
    415  1.191      elad 	case KAUTH_REQ_NETWORK_SOCKET_DROP: {
    416  1.191      elad 		/* Normal users can only drop their own connections. */
    417  1.191      elad 		struct socket *so = (struct socket *)arg1;
    418  1.191      elad 
    419  1.199      elad 		if (proc_uidmatch(cred, so->so_cred))
    420  1.191      elad 			result = KAUTH_RESULT_ALLOW;
    421  1.191      elad 
    422  1.191      elad 		break;
    423  1.191      elad 		}
    424  1.191      elad 
    425  1.191      elad 	case KAUTH_REQ_NETWORK_SOCKET_OPEN:
    426  1.191      elad 		/* We allow "raw" routing/bluetooth sockets to anyone. */
    427  1.203      matt 		if ((u_long)arg1 == PF_ROUTE || (u_long)arg1 == PF_OROUTE
    428  1.203      matt 		    || (u_long)arg1 == PF_BLUETOOTH) {
    429  1.191      elad 			result = KAUTH_RESULT_ALLOW;
    430  1.203      matt 		} else {
    431  1.191      elad 			/* Privileged, let secmodel handle this. */
    432  1.191      elad 			if ((u_long)arg2 == SOCK_RAW)
    433  1.191      elad 				break;
    434  1.191      elad 		}
    435  1.191      elad 
    436  1.191      elad 		result = KAUTH_RESULT_ALLOW;
    437  1.191      elad 
    438  1.191      elad 		break;
    439  1.191      elad 
    440  1.192      elad 	case KAUTH_REQ_NETWORK_SOCKET_CANSEE:
    441  1.192      elad 		result = KAUTH_RESULT_ALLOW;
    442  1.192      elad 
    443  1.192      elad 		break;
    444  1.192      elad 
    445  1.191      elad 	default:
    446  1.191      elad 		break;
    447  1.191      elad 	}
    448  1.191      elad 
    449  1.191      elad 	return result;
    450  1.191      elad }
    451  1.191      elad 
    452  1.119      yamt void
    453  1.119      yamt soinit(void)
    454  1.119      yamt {
    455  1.119      yamt 
    456  1.178     pooka 	sysctl_kern_somaxkva_setup();
    457  1.178     pooka 
    458  1.148        ad 	mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);
    459  1.160        ad 	softnet_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
    460  1.136        ad 	cv_init(&socurkva_cv, "sokva");
    461  1.205    bouyer 	cv_init(&pendfree_thread_cv, "sopendfr");
    462  1.166        ad 	soinit2();
    463  1.136        ad 
    464  1.119      yamt 	/* Set the initial adjusted socket buffer size. */
    465  1.119      yamt 	if (sb_max_set(sb_max))
    466  1.119      yamt 		panic("bad initial sb_max value: %lu", sb_max);
    467  1.119      yamt 
    468  1.191      elad 	socket_listener = kauth_listen_scope(KAUTH_SCOPE_NETWORK,
    469  1.191      elad 	    socket_listener_cb, NULL);
    470  1.119      yamt }
    471  1.119      yamt 
    472  1.205    bouyer void
    473  1.205    bouyer soinit1(void)
    474  1.205    bouyer {
    475  1.205    bouyer 	int error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
    476  1.205    bouyer 	    sopendfree_thread, NULL, &sopendfree_lwp, "sopendfree");
    477  1.205    bouyer 	if (error)
    478  1.205    bouyer 		panic("soinit1 %d", error);
    479  1.205    bouyer }
    480  1.205    bouyer 
    481    1.1       cgd /*
    482    1.1       cgd  * Socket operation routines.
    483    1.1       cgd  * These routines are called by the routines in
    484    1.1       cgd  * sys_socket.c or from a system process, and
    485    1.1       cgd  * implement the semantics of socket operations by
    486    1.1       cgd  * switching out to the protocol specific routines.
    487    1.1       cgd  */
    488    1.1       cgd /*ARGSUSED*/
    489    1.3    andrew int
    490  1.160        ad socreate(int dom, struct socket **aso, int type, int proto, struct lwp *l,
    491  1.160        ad 	 struct socket *lockso)
    492    1.1       cgd {
    493   1.99      matt 	const struct protosw	*prp;
    494   1.54     lukem 	struct socket	*so;
    495  1.115      yamt 	uid_t		uid;
    496  1.160        ad 	int		error;
    497  1.160        ad 	kmutex_t	*lock;
    498    1.1       cgd 
    499  1.132      elad 	error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,
    500  1.132      elad 	    KAUTH_REQ_NETWORK_SOCKET_OPEN, KAUTH_ARG(dom), KAUTH_ARG(type),
    501  1.132      elad 	    KAUTH_ARG(proto));
    502  1.140    dyoung 	if (error != 0)
    503  1.140    dyoung 		return error;
    504  1.127      elad 
    505    1.1       cgd 	if (proto)
    506    1.1       cgd 		prp = pffindproto(dom, proto, type);
    507    1.1       cgd 	else
    508    1.1       cgd 		prp = pffindtype(dom, type);
    509  1.140    dyoung 	if (prp == NULL) {
    510  1.120  ginsbach 		/* no support for domain */
    511  1.120  ginsbach 		if (pffinddomain(dom) == 0)
    512  1.140    dyoung 			return EAFNOSUPPORT;
    513  1.120  ginsbach 		/* no support for socket type */
    514  1.120  ginsbach 		if (proto == 0 && type != 0)
    515  1.140    dyoung 			return EPROTOTYPE;
    516  1.140    dyoung 		return EPROTONOSUPPORT;
    517  1.120  ginsbach 	}
    518  1.140    dyoung 	if (prp->pr_usrreq == NULL)
    519  1.140    dyoung 		return EPROTONOSUPPORT;
    520    1.1       cgd 	if (prp->pr_type != type)
    521  1.140    dyoung 		return EPROTOTYPE;
    522  1.160        ad 
    523  1.160        ad 	so = soget(true);
    524    1.1       cgd 	so->so_type = type;
    525    1.1       cgd 	so->so_proto = prp;
    526   1.33      matt 	so->so_send = sosend;
    527   1.33      matt 	so->so_receive = soreceive;
    528   1.78      matt #ifdef MBUFTRACE
    529   1.78      matt 	so->so_rcv.sb_mowner = &prp->pr_domain->dom_mowner;
    530   1.78      matt 	so->so_snd.sb_mowner = &prp->pr_domain->dom_mowner;
    531   1.78      matt 	so->so_mowner = &prp->pr_domain->dom_mowner;
    532   1.78      matt #endif
    533  1.138     rmind 	uid = kauth_cred_geteuid(l->l_cred);
    534  1.115      yamt 	so->so_uidinfo = uid_find(uid);
    535  1.168      yamt 	so->so_cpid = l->l_proc->p_pid;
    536  1.160        ad 	if (lockso != NULL) {
    537  1.160        ad 		/* Caller wants us to share a lock. */
    538  1.160        ad 		lock = lockso->so_lock;
    539  1.160        ad 		so->so_lock = lock;
    540  1.160        ad 		mutex_obj_hold(lock);
    541  1.160        ad 		mutex_enter(lock);
    542  1.160        ad 	} else {
    543  1.160        ad 		/* Lock assigned and taken during PRU_ATTACH. */
    544  1.160        ad 	}
    545  1.140    dyoung 	error = (*prp->pr_usrreq)(so, PRU_ATTACH, NULL,
    546  1.140    dyoung 	    (struct mbuf *)(long)proto, NULL, l);
    547  1.160        ad 	KASSERT(solocked(so));
    548  1.140    dyoung 	if (error != 0) {
    549    1.1       cgd 		so->so_state |= SS_NOFDREF;
    550    1.1       cgd 		sofree(so);
    551  1.140    dyoung 		return error;
    552    1.1       cgd 	}
    553  1.198      elad 	so->so_cred = kauth_cred_dup(l->l_cred);
    554  1.160        ad 	sounlock(so);
    555    1.1       cgd 	*aso = so;
    556  1.140    dyoung 	return 0;
    557    1.1       cgd }
    558    1.1       cgd 
    559  1.142    dyoung /* On success, write file descriptor to fdout and return zero.  On
    560  1.142    dyoung  * failure, return non-zero; *fdout will be undefined.
    561  1.142    dyoung  */
    562  1.142    dyoung int
    563  1.142    dyoung fsocreate(int domain, struct socket **sop, int type, int protocol,
    564  1.142    dyoung     struct lwp *l, int *fdout)
    565  1.142    dyoung {
    566  1.142    dyoung 	struct socket	*so;
    567  1.142    dyoung 	struct file	*fp;
    568  1.142    dyoung 	int		fd, error;
    569  1.204  christos 	int		flags = type & SOCK_FLAGS_MASK;
    570  1.142    dyoung 
    571  1.204  christos 	type &= ~SOCK_FLAGS_MASK;
    572  1.155        ad 	if ((error = fd_allocfile(&fp, &fd)) != 0)
    573  1.204  christos 		return error;
    574  1.204  christos 	fd_set_exclose(l, fd, (flags & SOCK_CLOEXEC) != 0);
    575  1.207  christos 	fp->f_flag = FREAD|FWRITE|((flags & SOCK_NONBLOCK) ? FNONBLOCK : 0)|
    576  1.207  christos 	    ((flags & SOCK_NOSIGPIPE) ? FNOSIGPIPE : 0);
    577  1.142    dyoung 	fp->f_type = DTYPE_SOCKET;
    578  1.142    dyoung 	fp->f_ops = &socketops;
    579  1.160        ad 	error = socreate(domain, &so, type, protocol, l, NULL);
    580  1.142    dyoung 	if (error != 0) {
    581  1.155        ad 		fd_abort(curproc, fp, fd);
    582  1.142    dyoung 	} else {
    583  1.142    dyoung 		if (sop != NULL)
    584  1.142    dyoung 			*sop = so;
    585  1.142    dyoung 		fp->f_data = so;
    586  1.155        ad 		fd_affix(curproc, fp, fd);
    587  1.142    dyoung 		*fdout = fd;
    588  1.142    dyoung 	}
    589  1.142    dyoung 	return error;
    590  1.142    dyoung }
    591  1.142    dyoung 
    592    1.3    andrew int
    593  1.190    dyoung sofamily(const struct socket *so)
    594  1.190    dyoung {
    595  1.190    dyoung 	const struct protosw *pr;
    596  1.190    dyoung 	const struct domain *dom;
    597  1.190    dyoung 
    598  1.190    dyoung 	if ((pr = so->so_proto) == NULL)
    599  1.190    dyoung 		return AF_UNSPEC;
    600  1.190    dyoung 	if ((dom = pr->pr_domain) == NULL)
    601  1.190    dyoung 		return AF_UNSPEC;
    602  1.190    dyoung 	return dom->dom_family;
    603  1.190    dyoung }
    604  1.190    dyoung 
    605  1.190    dyoung int
    606  1.114  christos sobind(struct socket *so, struct mbuf *nam, struct lwp *l)
    607    1.1       cgd {
    608  1.160        ad 	int	error;
    609    1.1       cgd 
    610  1.160        ad 	solock(so);
    611  1.140    dyoung 	error = (*so->so_proto->pr_usrreq)(so, PRU_BIND, NULL, nam, NULL, l);
    612  1.160        ad 	sounlock(so);
    613  1.140    dyoung 	return error;
    614    1.1       cgd }
    615    1.1       cgd 
    616    1.3    andrew int
    617  1.150      elad solisten(struct socket *so, int backlog, struct lwp *l)
    618    1.1       cgd {
    619  1.160        ad 	int	error;
    620    1.1       cgd 
    621  1.160        ad 	solock(so);
    622  1.158        ad 	if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
    623  1.163        ad 	    SS_ISDISCONNECTING)) != 0) {
    624  1.163        ad 	    	sounlock(so);
    625  1.210      matt 		return (EINVAL);
    626  1.163        ad 	}
    627  1.140    dyoung 	error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, NULL,
    628  1.150      elad 	    NULL, NULL, l);
    629  1.140    dyoung 	if (error != 0) {
    630  1.160        ad 		sounlock(so);
    631  1.140    dyoung 		return error;
    632    1.1       cgd 	}
    633   1.63      matt 	if (TAILQ_EMPTY(&so->so_q))
    634    1.1       cgd 		so->so_options |= SO_ACCEPTCONN;
    635    1.1       cgd 	if (backlog < 0)
    636    1.1       cgd 		backlog = 0;
    637   1.49  jonathan 	so->so_qlimit = min(backlog, somaxconn);
    638  1.160        ad 	sounlock(so);
    639  1.140    dyoung 	return 0;
    640    1.1       cgd }
    641    1.1       cgd 
    642   1.21  christos void
    643   1.54     lukem sofree(struct socket *so)
    644    1.1       cgd {
    645  1.161        ad 	u_int refs;
    646    1.1       cgd 
    647  1.160        ad 	KASSERT(solocked(so));
    648  1.160        ad 
    649  1.160        ad 	if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0) {
    650  1.160        ad 		sounlock(so);
    651    1.1       cgd 		return;
    652  1.160        ad 	}
    653   1.43   mycroft 	if (so->so_head) {
    654   1.43   mycroft 		/*
    655   1.43   mycroft 		 * We must not decommission a socket that's on the accept(2)
    656   1.43   mycroft 		 * queue.  If we do, then accept(2) may hang after select(2)
    657   1.43   mycroft 		 * indicated that the listening socket was ready.
    658   1.43   mycroft 		 */
    659  1.160        ad 		if (!soqremque(so, 0)) {
    660  1.160        ad 			sounlock(so);
    661   1.43   mycroft 			return;
    662  1.160        ad 		}
    663   1.43   mycroft 	}
    664   1.98  christos 	if (so->so_rcv.sb_hiwat)
    665  1.110  christos 		(void)chgsbsize(so->so_uidinfo, &so->so_rcv.sb_hiwat, 0,
    666   1.98  christos 		    RLIM_INFINITY);
    667   1.98  christos 	if (so->so_snd.sb_hiwat)
    668  1.110  christos 		(void)chgsbsize(so->so_uidinfo, &so->so_snd.sb_hiwat, 0,
    669   1.98  christos 		    RLIM_INFINITY);
    670   1.98  christos 	sbrelease(&so->so_snd, so);
    671  1.160        ad 	KASSERT(!cv_has_waiters(&so->so_cv));
    672  1.160        ad 	KASSERT(!cv_has_waiters(&so->so_rcv.sb_cv));
    673  1.160        ad 	KASSERT(!cv_has_waiters(&so->so_snd.sb_cv));
    674    1.1       cgd 	sorflush(so);
    675  1.161        ad 	refs = so->so_aborting;	/* XXX */
    676  1.177        ad 	/* Remove acccept filter if one is present. */
    677  1.170       tls 	if (so->so_accf != NULL)
    678  1.177        ad 		(void)accept_filt_clear(so);
    679  1.160        ad 	sounlock(so);
    680  1.161        ad 	if (refs == 0)		/* XXX */
    681  1.161        ad 		soput(so);
    682    1.1       cgd }
    683    1.1       cgd 
    684    1.1       cgd /*
    685    1.1       cgd  * Close a socket on last file table reference removal.
    686    1.1       cgd  * Initiate disconnect if connected.
    687    1.1       cgd  * Free socket when disconnect complete.
    688    1.1       cgd  */
    689    1.3    andrew int
    690   1.54     lukem soclose(struct socket *so)
    691    1.1       cgd {
    692   1.54     lukem 	struct socket	*so2;
    693  1.160        ad 	int		error;
    694  1.160        ad 	int		error2;
    695    1.1       cgd 
    696   1.54     lukem 	error = 0;
    697  1.160        ad 	solock(so);
    698    1.1       cgd 	if (so->so_options & SO_ACCEPTCONN) {
    699  1.172        ad 		for (;;) {
    700  1.172        ad 			if ((so2 = TAILQ_FIRST(&so->so_q0)) != 0) {
    701  1.160        ad 				KASSERT(solocked2(so, so2));
    702  1.160        ad 				(void) soqremque(so2, 0);
    703  1.160        ad 				/* soabort drops the lock. */
    704  1.160        ad 				(void) soabort(so2);
    705  1.160        ad 				solock(so);
    706  1.172        ad 				continue;
    707  1.160        ad 			}
    708  1.172        ad 			if ((so2 = TAILQ_FIRST(&so->so_q)) != 0) {
    709  1.160        ad 				KASSERT(solocked2(so, so2));
    710  1.160        ad 				(void) soqremque(so2, 1);
    711  1.160        ad 				/* soabort drops the lock. */
    712  1.160        ad 				(void) soabort(so2);
    713  1.160        ad 				solock(so);
    714  1.172        ad 				continue;
    715  1.160        ad 			}
    716  1.172        ad 			break;
    717  1.172        ad 		}
    718    1.1       cgd 	}
    719    1.1       cgd 	if (so->so_pcb == 0)
    720    1.1       cgd 		goto discard;
    721    1.1       cgd 	if (so->so_state & SS_ISCONNECTED) {
    722    1.1       cgd 		if ((so->so_state & SS_ISDISCONNECTING) == 0) {
    723    1.1       cgd 			error = sodisconnect(so);
    724    1.1       cgd 			if (error)
    725    1.1       cgd 				goto drop;
    726    1.1       cgd 		}
    727    1.1       cgd 		if (so->so_options & SO_LINGER) {
    728  1.206  christos 			if ((so->so_state & (SS_ISDISCONNECTING|SS_NBIO)) ==
    729  1.206  christos 			    (SS_ISDISCONNECTING|SS_NBIO))
    730    1.1       cgd 				goto drop;
    731   1.21  christos 			while (so->so_state & SS_ISCONNECTED) {
    732  1.185      yamt 				error = sowait(so, true, so->so_linger * hz);
    733   1.21  christos 				if (error)
    734    1.1       cgd 					break;
    735   1.21  christos 			}
    736    1.1       cgd 		}
    737    1.1       cgd 	}
    738   1.54     lukem  drop:
    739    1.1       cgd 	if (so->so_pcb) {
    740  1.160        ad 		error2 = (*so->so_proto->pr_usrreq)(so, PRU_DETACH,
    741  1.140    dyoung 		    NULL, NULL, NULL, NULL);
    742    1.1       cgd 		if (error == 0)
    743    1.1       cgd 			error = error2;
    744    1.1       cgd 	}
    745   1.54     lukem  discard:
    746    1.1       cgd 	if (so->so_state & SS_NOFDREF)
    747    1.1       cgd 		panic("soclose: NOFDREF");
    748  1.198      elad 	kauth_cred_free(so->so_cred);
    749    1.1       cgd 	so->so_state |= SS_NOFDREF;
    750    1.1       cgd 	sofree(so);
    751    1.1       cgd 	return (error);
    752    1.1       cgd }
    753    1.1       cgd 
    754    1.1       cgd /*
    755  1.160        ad  * Must be called with the socket locked..  Will return with it unlocked.
    756    1.1       cgd  */
    757    1.3    andrew int
    758   1.54     lukem soabort(struct socket *so)
    759    1.1       cgd {
    760  1.161        ad 	u_int refs;
    761  1.139      yamt 	int error;
    762  1.160        ad 
    763  1.160        ad 	KASSERT(solocked(so));
    764  1.160        ad 	KASSERT(so->so_head == NULL);
    765    1.1       cgd 
    766  1.161        ad 	so->so_aborting++;		/* XXX */
    767  1.140    dyoung 	error = (*so->so_proto->pr_usrreq)(so, PRU_ABORT, NULL,
    768  1.140    dyoung 	    NULL, NULL, NULL);
    769  1.161        ad 	refs = --so->so_aborting;	/* XXX */
    770  1.164  drochner 	if (error || (refs == 0)) {
    771  1.139      yamt 		sofree(so);
    772  1.160        ad 	} else {
    773  1.160        ad 		sounlock(so);
    774  1.139      yamt 	}
    775  1.139      yamt 	return error;
    776    1.1       cgd }
    777    1.1       cgd 
    778    1.3    andrew int
    779   1.54     lukem soaccept(struct socket *so, struct mbuf *nam)
    780    1.1       cgd {
    781  1.160        ad 	int	error;
    782  1.160        ad 
    783  1.160        ad 	KASSERT(solocked(so));
    784    1.1       cgd 
    785   1.54     lukem 	error = 0;
    786    1.1       cgd 	if ((so->so_state & SS_NOFDREF) == 0)
    787    1.1       cgd 		panic("soaccept: !NOFDREF");
    788    1.1       cgd 	so->so_state &= ~SS_NOFDREF;
    789   1.55   thorpej 	if ((so->so_state & SS_ISDISCONNECTED) == 0 ||
    790   1.55   thorpej 	    (so->so_proto->pr_flags & PR_ABRTACPTDIS) == 0)
    791   1.41   mycroft 		error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,
    792  1.140    dyoung 		    NULL, nam, NULL, NULL);
    793   1.41   mycroft 	else
    794   1.53    itojun 		error = ECONNABORTED;
    795   1.52    itojun 
    796    1.1       cgd 	return (error);
    797    1.1       cgd }
    798    1.1       cgd 
    799    1.3    andrew int
    800  1.114  christos soconnect(struct socket *so, struct mbuf *nam, struct lwp *l)
    801    1.1       cgd {
    802  1.160        ad 	int		error;
    803  1.160        ad 
    804  1.160        ad 	KASSERT(solocked(so));
    805    1.1       cgd 
    806    1.1       cgd 	if (so->so_options & SO_ACCEPTCONN)
    807    1.1       cgd 		return (EOPNOTSUPP);
    808    1.1       cgd 	/*
    809    1.1       cgd 	 * If protocol is connection-based, can only connect once.
    810    1.1       cgd 	 * Otherwise, if connected, try to disconnect first.
    811    1.1       cgd 	 * This allows user to disconnect by connecting to, e.g.,
    812    1.1       cgd 	 * a null address.
    813    1.1       cgd 	 */
    814    1.1       cgd 	if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
    815    1.1       cgd 	    ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
    816    1.1       cgd 	    (error = sodisconnect(so))))
    817    1.1       cgd 		error = EISCONN;
    818    1.1       cgd 	else
    819    1.1       cgd 		error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,
    820  1.140    dyoung 		    NULL, nam, NULL, l);
    821    1.1       cgd 	return (error);
    822    1.1       cgd }
    823    1.1       cgd 
    824    1.3    andrew int
    825   1.54     lukem soconnect2(struct socket *so1, struct socket *so2)
    826    1.1       cgd {
    827  1.160        ad 	int	error;
    828  1.160        ad 
    829  1.160        ad 	KASSERT(solocked2(so1, so2));
    830    1.1       cgd 
    831   1.22   mycroft 	error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,
    832  1.140    dyoung 	    NULL, (struct mbuf *)so2, NULL, NULL);
    833    1.1       cgd 	return (error);
    834    1.1       cgd }
    835    1.1       cgd 
    836    1.3    andrew int
    837   1.54     lukem sodisconnect(struct socket *so)
    838    1.1       cgd {
    839  1.160        ad 	int	error;
    840  1.160        ad 
    841  1.160        ad 	KASSERT(solocked(so));
    842    1.1       cgd 
    843    1.1       cgd 	if ((so->so_state & SS_ISCONNECTED) == 0) {
    844    1.1       cgd 		error = ENOTCONN;
    845  1.160        ad 	} else if (so->so_state & SS_ISDISCONNECTING) {
    846    1.1       cgd 		error = EALREADY;
    847  1.160        ad 	} else {
    848  1.160        ad 		error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
    849  1.160        ad 		    NULL, NULL, NULL, NULL);
    850    1.1       cgd 	}
    851    1.1       cgd 	return (error);
    852    1.1       cgd }
    853    1.1       cgd 
    854   1.15   mycroft #define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
    855    1.1       cgd /*
    856    1.1       cgd  * Send on a socket.
    857    1.1       cgd  * If send must go all at once and message is larger than
    858    1.1       cgd  * send buffering, then hard error.
    859    1.1       cgd  * Lock against other senders.
    860    1.1       cgd  * If must go all at once and not enough room now, then
    861    1.1       cgd  * inform user that this would block and do nothing.
    862    1.1       cgd  * Otherwise, if nonblocking, send as much as possible.
    863    1.1       cgd  * The data to be sent is described by "uio" if nonzero,
    864    1.1       cgd  * otherwise by the mbuf chain "top" (which must be null
    865    1.1       cgd  * if uio is not).  Data provided in mbuf chain must be small
    866    1.1       cgd  * enough to send all at once.
    867    1.1       cgd  *
    868    1.1       cgd  * Returns nonzero on error, timeout or signal; callers
    869    1.1       cgd  * must check for short counts if EINTR/ERESTART are returned.
    870    1.1       cgd  * Data and control buffers are freed on return.
    871    1.1       cgd  */
    872    1.3    andrew int
    873   1.54     lukem sosend(struct socket *so, struct mbuf *addr, struct uio *uio, struct mbuf *top,
    874  1.114  christos 	struct mbuf *control, int flags, struct lwp *l)
    875    1.1       cgd {
    876   1.54     lukem 	struct mbuf	**mp, *m;
    877  1.114  christos 	struct proc	*p;
    878   1.58  jdolecek 	long		space, len, resid, clen, mlen;
    879   1.58  jdolecek 	int		error, s, dontroute, atomic;
    880  1.196       dsl 	short		wakeup_state = 0;
    881   1.54     lukem 
    882  1.114  christos 	p = l->l_proc;
    883  1.160        ad 	clen = 0;
    884   1.64   thorpej 
    885  1.160        ad 	/*
    886  1.160        ad 	 * solock() provides atomicity of access.  splsoftnet() prevents
    887  1.160        ad 	 * protocol processing soft interrupts from interrupting us and
    888  1.160        ad 	 * blocking (expensive).
    889  1.160        ad 	 */
    890  1.160        ad 	s = splsoftnet();
    891  1.160        ad 	solock(so);
    892   1.54     lukem 	atomic = sosendallatonce(so) || top;
    893    1.1       cgd 	if (uio)
    894    1.1       cgd 		resid = uio->uio_resid;
    895    1.1       cgd 	else
    896    1.1       cgd 		resid = top->m_pkthdr.len;
    897    1.7       cgd 	/*
    898    1.7       cgd 	 * In theory resid should be unsigned.
    899    1.7       cgd 	 * However, space must be signed, as it might be less than 0
    900    1.7       cgd 	 * if we over-committed, and we must use a signed comparison
    901    1.7       cgd 	 * of space and resid.  On the other hand, a negative resid
    902    1.7       cgd 	 * causes us to loop sending 0-length segments to the protocol.
    903    1.7       cgd 	 */
    904   1.29   mycroft 	if (resid < 0) {
    905   1.29   mycroft 		error = EINVAL;
    906   1.29   mycroft 		goto out;
    907   1.29   mycroft 	}
    908    1.1       cgd 	dontroute =
    909    1.1       cgd 	    (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
    910    1.1       cgd 	    (so->so_proto->pr_flags & PR_ATOMIC);
    911  1.165  christos 	l->l_ru.ru_msgsnd++;
    912    1.1       cgd 	if (control)
    913    1.1       cgd 		clen = control->m_len;
    914   1.54     lukem  restart:
    915   1.21  christos 	if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
    916    1.1       cgd 		goto out;
    917    1.1       cgd 	do {
    918  1.160        ad 		if (so->so_state & SS_CANTSENDMORE) {
    919  1.160        ad 			error = EPIPE;
    920  1.160        ad 			goto release;
    921  1.160        ad 		}
    922   1.48   thorpej 		if (so->so_error) {
    923   1.48   thorpej 			error = so->so_error;
    924   1.48   thorpej 			so->so_error = 0;
    925   1.48   thorpej 			goto release;
    926   1.48   thorpej 		}
    927    1.1       cgd 		if ((so->so_state & SS_ISCONNECTED) == 0) {
    928    1.1       cgd 			if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
    929    1.1       cgd 				if ((so->so_state & SS_ISCONFIRMING) == 0 &&
    930  1.160        ad 				    !(resid == 0 && clen != 0)) {
    931  1.160        ad 					error = ENOTCONN;
    932  1.160        ad 					goto release;
    933  1.160        ad 				}
    934  1.160        ad 			} else if (addr == 0) {
    935  1.160        ad 				error = EDESTADDRREQ;
    936  1.160        ad 				goto release;
    937  1.160        ad 			}
    938    1.1       cgd 		}
    939    1.1       cgd 		space = sbspace(&so->so_snd);
    940    1.1       cgd 		if (flags & MSG_OOB)
    941    1.1       cgd 			space += 1024;
    942   1.21  christos 		if ((atomic && resid > so->so_snd.sb_hiwat) ||
    943  1.160        ad 		    clen > so->so_snd.sb_hiwat) {
    944  1.160        ad 			error = EMSGSIZE;
    945  1.160        ad 			goto release;
    946  1.160        ad 		}
    947   1.96   mycroft 		if (space < resid + clen &&
    948    1.1       cgd 		    (atomic || space < so->so_snd.sb_lowat || space < clen)) {
    949  1.206  christos 			if ((so->so_state & SS_NBIO) || (flags & MSG_NBIO)) {
    950  1.160        ad 				error = EWOULDBLOCK;
    951  1.160        ad 				goto release;
    952  1.160        ad 			}
    953    1.1       cgd 			sbunlock(&so->so_snd);
    954  1.196       dsl 			if (wakeup_state & SS_RESTARTSYS) {
    955  1.196       dsl 				error = ERESTART;
    956  1.196       dsl 				goto out;
    957  1.196       dsl 			}
    958    1.1       cgd 			error = sbwait(&so->so_snd);
    959    1.1       cgd 			if (error)
    960    1.1       cgd 				goto out;
    961  1.196       dsl 			wakeup_state = so->so_state;
    962    1.1       cgd 			goto restart;
    963    1.1       cgd 		}
    964  1.196       dsl 		wakeup_state = 0;
    965    1.1       cgd 		mp = &top;
    966    1.1       cgd 		space -= clen;
    967    1.1       cgd 		do {
    968   1.45        tv 			if (uio == NULL) {
    969   1.45        tv 				/*
    970   1.45        tv 				 * Data is prepackaged in "top".
    971   1.45        tv 				 */
    972   1.45        tv 				resid = 0;
    973   1.45        tv 				if (flags & MSG_EOR)
    974   1.45        tv 					top->m_flags |= M_EOR;
    975   1.45        tv 			} else do {
    976  1.160        ad 				sounlock(so);
    977  1.160        ad 				splx(s);
    978  1.144    dyoung 				if (top == NULL) {
    979   1.78      matt 					m = m_gethdr(M_WAIT, MT_DATA);
    980   1.45        tv 					mlen = MHLEN;
    981   1.45        tv 					m->m_pkthdr.len = 0;
    982  1.140    dyoung 					m->m_pkthdr.rcvif = NULL;
    983   1.45        tv 				} else {
    984   1.78      matt 					m = m_get(M_WAIT, MT_DATA);
    985   1.45        tv 					mlen = MLEN;
    986   1.45        tv 				}
    987   1.78      matt 				MCLAIM(m, so->so_snd.sb_mowner);
    988  1.121      yamt 				if (sock_loan_thresh >= 0 &&
    989  1.121      yamt 				    uio->uio_iov->iov_len >= sock_loan_thresh &&
    990  1.121      yamt 				    space >= sock_loan_thresh &&
    991   1.64   thorpej 				    (len = sosend_loan(so, uio, m,
    992   1.64   thorpej 						       space)) != 0) {
    993   1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_loan_big);
    994   1.64   thorpej 					space -= len;
    995   1.64   thorpej 					goto have_data;
    996   1.64   thorpej 				}
    997   1.45        tv 				if (resid >= MINCLSIZE && space >= MCLBYTES) {
    998   1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_copy_big);
    999  1.201       oki 					m_clget(m, M_DONTWAIT);
   1000   1.45        tv 					if ((m->m_flags & M_EXT) == 0)
   1001   1.45        tv 						goto nopages;
   1002   1.45        tv 					mlen = MCLBYTES;
   1003   1.45        tv 					if (atomic && top == 0) {
   1004   1.58  jdolecek 						len = lmin(MCLBYTES - max_hdr,
   1005   1.54     lukem 						    resid);
   1006   1.45        tv 						m->m_data += max_hdr;
   1007   1.45        tv 					} else
   1008   1.58  jdolecek 						len = lmin(MCLBYTES, resid);
   1009   1.45        tv 					space -= len;
   1010   1.45        tv 				} else {
   1011   1.64   thorpej  nopages:
   1012   1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_copy_small);
   1013   1.58  jdolecek 					len = lmin(lmin(mlen, resid), space);
   1014   1.45        tv 					space -= len;
   1015   1.45        tv 					/*
   1016   1.45        tv 					 * For datagram protocols, leave room
   1017   1.45        tv 					 * for protocol headers in first mbuf.
   1018   1.45        tv 					 */
   1019   1.45        tv 					if (atomic && top == 0 && len < mlen)
   1020   1.45        tv 						MH_ALIGN(m, len);
   1021   1.45        tv 				}
   1022  1.144    dyoung 				error = uiomove(mtod(m, void *), (int)len, uio);
   1023   1.64   thorpej  have_data:
   1024   1.45        tv 				resid = uio->uio_resid;
   1025   1.45        tv 				m->m_len = len;
   1026   1.45        tv 				*mp = m;
   1027   1.45        tv 				top->m_pkthdr.len += len;
   1028  1.160        ad 				s = splsoftnet();
   1029  1.160        ad 				solock(so);
   1030  1.144    dyoung 				if (error != 0)
   1031   1.45        tv 					goto release;
   1032   1.45        tv 				mp = &m->m_next;
   1033   1.45        tv 				if (resid <= 0) {
   1034   1.45        tv 					if (flags & MSG_EOR)
   1035   1.45        tv 						top->m_flags |= M_EOR;
   1036   1.45        tv 					break;
   1037   1.45        tv 				}
   1038   1.45        tv 			} while (space > 0 && atomic);
   1039  1.108     perry 
   1040  1.160        ad 			if (so->so_state & SS_CANTSENDMORE) {
   1041  1.160        ad 				error = EPIPE;
   1042  1.160        ad 				goto release;
   1043  1.160        ad 			}
   1044   1.45        tv 			if (dontroute)
   1045   1.45        tv 				so->so_options |= SO_DONTROUTE;
   1046   1.45        tv 			if (resid > 0)
   1047   1.45        tv 				so->so_state |= SS_MORETOCOME;
   1048   1.46  sommerfe 			error = (*so->so_proto->pr_usrreq)(so,
   1049   1.46  sommerfe 			    (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
   1050  1.160        ad 			    top, addr, control, curlwp);
   1051   1.45        tv 			if (dontroute)
   1052   1.45        tv 				so->so_options &= ~SO_DONTROUTE;
   1053   1.45        tv 			if (resid > 0)
   1054   1.45        tv 				so->so_state &= ~SS_MORETOCOME;
   1055   1.45        tv 			clen = 0;
   1056  1.144    dyoung 			control = NULL;
   1057  1.144    dyoung 			top = NULL;
   1058   1.45        tv 			mp = &top;
   1059  1.144    dyoung 			if (error != 0)
   1060    1.1       cgd 				goto release;
   1061    1.1       cgd 		} while (resid && space > 0);
   1062    1.1       cgd 	} while (resid);
   1063    1.1       cgd 
   1064   1.54     lukem  release:
   1065    1.1       cgd 	sbunlock(&so->so_snd);
   1066   1.54     lukem  out:
   1067  1.160        ad 	sounlock(so);
   1068  1.160        ad 	splx(s);
   1069    1.1       cgd 	if (top)
   1070    1.1       cgd 		m_freem(top);
   1071    1.1       cgd 	if (control)
   1072    1.1       cgd 		m_freem(control);
   1073    1.1       cgd 	return (error);
   1074    1.1       cgd }
   1075    1.1       cgd 
   1076    1.1       cgd /*
   1077  1.159        ad  * Following replacement or removal of the first mbuf on the first
   1078  1.159        ad  * mbuf chain of a socket buffer, push necessary state changes back
   1079  1.159        ad  * into the socket buffer so that other consumers see the values
   1080  1.159        ad  * consistently.  'nextrecord' is the callers locally stored value of
   1081  1.159        ad  * the original value of sb->sb_mb->m_nextpkt which must be restored
   1082  1.159        ad  * when the lead mbuf changes.  NOTE: 'nextrecord' may be NULL.
   1083  1.159        ad  */
   1084  1.159        ad static void
   1085  1.159        ad sbsync(struct sockbuf *sb, struct mbuf *nextrecord)
   1086  1.159        ad {
   1087  1.159        ad 
   1088  1.160        ad 	KASSERT(solocked(sb->sb_so));
   1089  1.160        ad 
   1090  1.159        ad 	/*
   1091  1.159        ad 	 * First, update for the new value of nextrecord.  If necessary,
   1092  1.159        ad 	 * make it the first record.
   1093  1.159        ad 	 */
   1094  1.159        ad 	if (sb->sb_mb != NULL)
   1095  1.159        ad 		sb->sb_mb->m_nextpkt = nextrecord;
   1096  1.159        ad 	else
   1097  1.159        ad 		sb->sb_mb = nextrecord;
   1098  1.159        ad 
   1099  1.159        ad         /*
   1100  1.159        ad          * Now update any dependent socket buffer fields to reflect
   1101  1.159        ad          * the new state.  This is an inline of SB_EMPTY_FIXUP, with
   1102  1.159        ad          * the addition of a second clause that takes care of the
   1103  1.159        ad          * case where sb_mb has been updated, but remains the last
   1104  1.159        ad          * record.
   1105  1.159        ad          */
   1106  1.159        ad         if (sb->sb_mb == NULL) {
   1107  1.159        ad                 sb->sb_mbtail = NULL;
   1108  1.159        ad                 sb->sb_lastrecord = NULL;
   1109  1.159        ad         } else if (sb->sb_mb->m_nextpkt == NULL)
   1110  1.159        ad                 sb->sb_lastrecord = sb->sb_mb;
   1111  1.159        ad }
   1112  1.159        ad 
   1113  1.159        ad /*
   1114    1.1       cgd  * Implement receive operations on a socket.
   1115    1.1       cgd  * We depend on the way that records are added to the sockbuf
   1116    1.1       cgd  * by sbappend*.  In particular, each record (mbufs linked through m_next)
   1117    1.1       cgd  * must begin with an address if the protocol so specifies,
   1118    1.1       cgd  * followed by an optional mbuf or mbufs containing ancillary data,
   1119    1.1       cgd  * and then zero or more mbufs of data.
   1120    1.1       cgd  * In order to avoid blocking network interrupts for the entire time here,
   1121    1.1       cgd  * we splx() while doing the actual copy to user space.
   1122    1.1       cgd  * Although the sockbuf is locked, new data may still be appended,
   1123    1.1       cgd  * and thus we must maintain consistency of the sockbuf during that time.
   1124    1.1       cgd  *
   1125    1.1       cgd  * The caller may receive the data as a single mbuf chain by supplying
   1126    1.1       cgd  * an mbuf **mp0 for use in returning the chain.  The uio is then used
   1127    1.1       cgd  * only for the count in uio_resid.
   1128    1.1       cgd  */
   1129    1.3    andrew int
   1130   1.54     lukem soreceive(struct socket *so, struct mbuf **paddr, struct uio *uio,
   1131   1.54     lukem 	struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
   1132    1.1       cgd {
   1133  1.116      yamt 	struct lwp *l = curlwp;
   1134  1.160        ad 	struct mbuf	*m, **mp, *mt;
   1135  1.211       chs 	size_t len, offset, moff, orig_resid;
   1136  1.211       chs 	int atomic, flags, error, s, type;
   1137   1.99      matt 	const struct protosw	*pr;
   1138   1.54     lukem 	struct mbuf	*nextrecord;
   1139   1.67        he 	int		mbuf_removed = 0;
   1140  1.146    dyoung 	const struct domain *dom;
   1141  1.196       dsl 	short		wakeup_state = 0;
   1142   1.64   thorpej 
   1143   1.54     lukem 	pr = so->so_proto;
   1144  1.146    dyoung 	atomic = pr->pr_flags & PR_ATOMIC;
   1145  1.146    dyoung 	dom = pr->pr_domain;
   1146    1.1       cgd 	mp = mp0;
   1147   1.54     lukem 	type = 0;
   1148   1.54     lukem 	orig_resid = uio->uio_resid;
   1149  1.102  jonathan 
   1150  1.144    dyoung 	if (paddr != NULL)
   1151  1.144    dyoung 		*paddr = NULL;
   1152  1.144    dyoung 	if (controlp != NULL)
   1153  1.144    dyoung 		*controlp = NULL;
   1154  1.144    dyoung 	if (flagsp != NULL)
   1155    1.1       cgd 		flags = *flagsp &~ MSG_EOR;
   1156    1.1       cgd 	else
   1157    1.1       cgd 		flags = 0;
   1158   1.66     enami 
   1159    1.1       cgd 	if (flags & MSG_OOB) {
   1160    1.1       cgd 		m = m_get(M_WAIT, MT_DATA);
   1161  1.160        ad 		solock(so);
   1162   1.17       cgd 		error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,
   1163  1.140    dyoung 		    (struct mbuf *)(long)(flags & MSG_PEEK), NULL, l);
   1164  1.160        ad 		sounlock(so);
   1165    1.1       cgd 		if (error)
   1166    1.1       cgd 			goto bad;
   1167    1.1       cgd 		do {
   1168  1.134  christos 			error = uiomove(mtod(m, void *),
   1169  1.211       chs 			    MIN(uio->uio_resid, m->m_len), uio);
   1170    1.1       cgd 			m = m_free(m);
   1171  1.144    dyoung 		} while (uio->uio_resid > 0 && error == 0 && m);
   1172   1.54     lukem  bad:
   1173  1.144    dyoung 		if (m != NULL)
   1174    1.1       cgd 			m_freem(m);
   1175  1.144    dyoung 		return error;
   1176    1.1       cgd 	}
   1177  1.144    dyoung 	if (mp != NULL)
   1178  1.140    dyoung 		*mp = NULL;
   1179  1.160        ad 
   1180  1.160        ad 	/*
   1181  1.160        ad 	 * solock() provides atomicity of access.  splsoftnet() prevents
   1182  1.160        ad 	 * protocol processing soft interrupts from interrupting us and
   1183  1.160        ad 	 * blocking (expensive).
   1184  1.160        ad 	 */
   1185  1.160        ad 	s = splsoftnet();
   1186  1.160        ad 	solock(so);
   1187    1.1       cgd 	if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
   1188  1.140    dyoung 		(*pr->pr_usrreq)(so, PRU_RCVD, NULL, NULL, NULL, l);
   1189    1.1       cgd 
   1190   1.54     lukem  restart:
   1191  1.160        ad 	if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0) {
   1192  1.160        ad 		sounlock(so);
   1193  1.160        ad 		splx(s);
   1194  1.144    dyoung 		return error;
   1195  1.160        ad 	}
   1196    1.1       cgd 
   1197    1.1       cgd 	m = so->so_rcv.sb_mb;
   1198    1.1       cgd 	/*
   1199    1.1       cgd 	 * If we have less data than requested, block awaiting more
   1200    1.1       cgd 	 * (subject to any timeout) if:
   1201   1.15   mycroft 	 *   1. the current count is less than the low water mark,
   1202    1.1       cgd 	 *   2. MSG_WAITALL is set, and it is possible to do the entire
   1203   1.15   mycroft 	 *	receive operation at once if we block (resid <= hiwat), or
   1204   1.15   mycroft 	 *   3. MSG_DONTWAIT is not set.
   1205    1.1       cgd 	 * If MSG_WAITALL is set but resid is larger than the receive buffer,
   1206    1.1       cgd 	 * we have to do the receive in sections, and thus risk returning
   1207    1.1       cgd 	 * a short count if a timeout or signal occurs after we start.
   1208    1.1       cgd 	 */
   1209  1.144    dyoung 	if (m == NULL ||
   1210  1.144    dyoung 	    ((flags & MSG_DONTWAIT) == 0 &&
   1211  1.144    dyoung 	     so->so_rcv.sb_cc < uio->uio_resid &&
   1212  1.144    dyoung 	     (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
   1213  1.144    dyoung 	      ((flags & MSG_WAITALL) &&
   1214  1.144    dyoung 	       uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
   1215  1.146    dyoung 	     m->m_nextpkt == NULL && !atomic)) {
   1216    1.1       cgd #ifdef DIAGNOSTIC
   1217  1.144    dyoung 		if (m == NULL && so->so_rcv.sb_cc)
   1218    1.1       cgd 			panic("receive 1");
   1219    1.1       cgd #endif
   1220    1.1       cgd 		if (so->so_error) {
   1221  1.144    dyoung 			if (m != NULL)
   1222   1.15   mycroft 				goto dontblock;
   1223    1.1       cgd 			error = so->so_error;
   1224    1.1       cgd 			if ((flags & MSG_PEEK) == 0)
   1225    1.1       cgd 				so->so_error = 0;
   1226    1.1       cgd 			goto release;
   1227    1.1       cgd 		}
   1228    1.1       cgd 		if (so->so_state & SS_CANTRCVMORE) {
   1229  1.144    dyoung 			if (m != NULL)
   1230   1.15   mycroft 				goto dontblock;
   1231    1.1       cgd 			else
   1232    1.1       cgd 				goto release;
   1233    1.1       cgd 		}
   1234  1.144    dyoung 		for (; m != NULL; m = m->m_next)
   1235    1.1       cgd 			if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
   1236    1.1       cgd 				m = so->so_rcv.sb_mb;
   1237    1.1       cgd 				goto dontblock;
   1238    1.1       cgd 			}
   1239    1.1       cgd 		if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
   1240    1.1       cgd 		    (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
   1241    1.1       cgd 			error = ENOTCONN;
   1242    1.1       cgd 			goto release;
   1243    1.1       cgd 		}
   1244    1.1       cgd 		if (uio->uio_resid == 0)
   1245    1.1       cgd 			goto release;
   1246  1.206  christos 		if ((so->so_state & SS_NBIO) ||
   1247  1.206  christos 		    (flags & (MSG_DONTWAIT|MSG_NBIO))) {
   1248    1.1       cgd 			error = EWOULDBLOCK;
   1249    1.1       cgd 			goto release;
   1250    1.1       cgd 		}
   1251   1.69   thorpej 		SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 1");
   1252   1.69   thorpej 		SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 1");
   1253    1.1       cgd 		sbunlock(&so->so_rcv);
   1254  1.196       dsl 		if (wakeup_state & SS_RESTARTSYS)
   1255  1.196       dsl 			error = ERESTART;
   1256  1.196       dsl 		else
   1257  1.196       dsl 			error = sbwait(&so->so_rcv);
   1258  1.160        ad 		if (error != 0) {
   1259  1.160        ad 			sounlock(so);
   1260  1.160        ad 			splx(s);
   1261  1.144    dyoung 			return error;
   1262  1.160        ad 		}
   1263  1.196       dsl 		wakeup_state = so->so_state;
   1264    1.1       cgd 		goto restart;
   1265    1.1       cgd 	}
   1266   1.54     lukem  dontblock:
   1267   1.69   thorpej 	/*
   1268   1.69   thorpej 	 * On entry here, m points to the first record of the socket buffer.
   1269  1.159        ad 	 * From this point onward, we maintain 'nextrecord' as a cache of the
   1270  1.159        ad 	 * pointer to the next record in the socket buffer.  We must keep the
   1271  1.159        ad 	 * various socket buffer pointers and local stack versions of the
   1272  1.159        ad 	 * pointers in sync, pushing out modifications before dropping the
   1273  1.160        ad 	 * socket lock, and re-reading them when picking it up.
   1274  1.159        ad 	 *
   1275  1.159        ad 	 * Otherwise, we will race with the network stack appending new data
   1276  1.159        ad 	 * or records onto the socket buffer by using inconsistent/stale
   1277  1.159        ad 	 * versions of the field, possibly resulting in socket buffer
   1278  1.159        ad 	 * corruption.
   1279  1.159        ad 	 *
   1280  1.159        ad 	 * By holding the high-level sblock(), we prevent simultaneous
   1281  1.159        ad 	 * readers from pulling off the front of the socket buffer.
   1282   1.69   thorpej 	 */
   1283  1.144    dyoung 	if (l != NULL)
   1284  1.157        ad 		l->l_ru.ru_msgrcv++;
   1285   1.69   thorpej 	KASSERT(m == so->so_rcv.sb_mb);
   1286   1.69   thorpej 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 1");
   1287   1.69   thorpej 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 1");
   1288    1.1       cgd 	nextrecord = m->m_nextpkt;
   1289    1.1       cgd 	if (pr->pr_flags & PR_ADDR) {
   1290    1.1       cgd #ifdef DIAGNOSTIC
   1291    1.1       cgd 		if (m->m_type != MT_SONAME)
   1292    1.1       cgd 			panic("receive 1a");
   1293    1.1       cgd #endif
   1294    1.3    andrew 		orig_resid = 0;
   1295    1.1       cgd 		if (flags & MSG_PEEK) {
   1296    1.1       cgd 			if (paddr)
   1297    1.1       cgd 				*paddr = m_copy(m, 0, m->m_len);
   1298    1.1       cgd 			m = m->m_next;
   1299    1.1       cgd 		} else {
   1300    1.1       cgd 			sbfree(&so->so_rcv, m);
   1301   1.67        he 			mbuf_removed = 1;
   1302  1.144    dyoung 			if (paddr != NULL) {
   1303    1.1       cgd 				*paddr = m;
   1304    1.1       cgd 				so->so_rcv.sb_mb = m->m_next;
   1305  1.144    dyoung 				m->m_next = NULL;
   1306    1.1       cgd 				m = so->so_rcv.sb_mb;
   1307    1.1       cgd 			} else {
   1308    1.1       cgd 				MFREE(m, so->so_rcv.sb_mb);
   1309    1.1       cgd 				m = so->so_rcv.sb_mb;
   1310    1.1       cgd 			}
   1311  1.159        ad 			sbsync(&so->so_rcv, nextrecord);
   1312    1.1       cgd 		}
   1313    1.1       cgd 	}
   1314  1.159        ad 
   1315  1.159        ad 	/*
   1316  1.159        ad 	 * Process one or more MT_CONTROL mbufs present before any data mbufs
   1317  1.159        ad 	 * in the first mbuf chain on the socket buffer.  If MSG_PEEK, we
   1318  1.159        ad 	 * just copy the data; if !MSG_PEEK, we call into the protocol to
   1319  1.159        ad 	 * perform externalization (or freeing if controlp == NULL).
   1320  1.159        ad 	 */
   1321  1.159        ad 	if (__predict_false(m != NULL && m->m_type == MT_CONTROL)) {
   1322  1.159        ad 		struct mbuf *cm = NULL, *cmn;
   1323  1.159        ad 		struct mbuf **cme = &cm;
   1324  1.159        ad 
   1325  1.159        ad 		do {
   1326  1.159        ad 			if (flags & MSG_PEEK) {
   1327  1.159        ad 				if (controlp != NULL) {
   1328  1.159        ad 					*controlp = m_copy(m, 0, m->m_len);
   1329  1.159        ad 					controlp = &(*controlp)->m_next;
   1330  1.159        ad 				}
   1331  1.159        ad 				m = m->m_next;
   1332  1.159        ad 			} else {
   1333  1.159        ad 				sbfree(&so->so_rcv, m);
   1334    1.1       cgd 				so->so_rcv.sb_mb = m->m_next;
   1335  1.144    dyoung 				m->m_next = NULL;
   1336  1.159        ad 				*cme = m;
   1337  1.159        ad 				cme = &(*cme)->m_next;
   1338    1.1       cgd 				m = so->so_rcv.sb_mb;
   1339  1.159        ad 			}
   1340  1.159        ad 		} while (m != NULL && m->m_type == MT_CONTROL);
   1341  1.159        ad 		if ((flags & MSG_PEEK) == 0)
   1342  1.159        ad 			sbsync(&so->so_rcv, nextrecord);
   1343  1.159        ad 		for (; cm != NULL; cm = cmn) {
   1344  1.159        ad 			cmn = cm->m_next;
   1345  1.159        ad 			cm->m_next = NULL;
   1346  1.159        ad 			type = mtod(cm, struct cmsghdr *)->cmsg_type;
   1347  1.159        ad 			if (controlp != NULL) {
   1348  1.159        ad 				if (dom->dom_externalize != NULL &&
   1349  1.159        ad 				    type == SCM_RIGHTS) {
   1350  1.160        ad 					sounlock(so);
   1351  1.159        ad 					splx(s);
   1352  1.204  christos 					error = (*dom->dom_externalize)(cm, l,
   1353  1.204  christos 					    (flags & MSG_CMSG_CLOEXEC) ?
   1354  1.204  christos 					    O_CLOEXEC : 0);
   1355  1.159        ad 					s = splsoftnet();
   1356  1.160        ad 					solock(so);
   1357  1.159        ad 				}
   1358  1.159        ad 				*controlp = cm;
   1359  1.159        ad 				while (*controlp != NULL)
   1360  1.159        ad 					controlp = &(*controlp)->m_next;
   1361    1.1       cgd 			} else {
   1362  1.106    itojun 				/*
   1363  1.106    itojun 				 * Dispose of any SCM_RIGHTS message that went
   1364  1.106    itojun 				 * through the read path rather than recv.
   1365  1.106    itojun 				 */
   1366  1.159        ad 				if (dom->dom_dispose != NULL &&
   1367  1.159        ad 				    type == SCM_RIGHTS) {
   1368  1.160        ad 				    	sounlock(so);
   1369  1.159        ad 					(*dom->dom_dispose)(cm);
   1370  1.160        ad 					solock(so);
   1371  1.159        ad 				}
   1372  1.159        ad 				m_freem(cm);
   1373    1.1       cgd 			}
   1374    1.1       cgd 		}
   1375  1.159        ad 		if (m != NULL)
   1376  1.159        ad 			nextrecord = so->so_rcv.sb_mb->m_nextpkt;
   1377  1.159        ad 		else
   1378  1.159        ad 			nextrecord = so->so_rcv.sb_mb;
   1379  1.159        ad 		orig_resid = 0;
   1380    1.1       cgd 	}
   1381   1.69   thorpej 
   1382  1.159        ad 	/* If m is non-NULL, we have some data to read. */
   1383  1.159        ad 	if (__predict_true(m != NULL)) {
   1384    1.1       cgd 		type = m->m_type;
   1385    1.1       cgd 		if (type == MT_OOBDATA)
   1386    1.1       cgd 			flags |= MSG_OOB;
   1387    1.1       cgd 	}
   1388   1.69   thorpej 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 2");
   1389   1.69   thorpej 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 2");
   1390   1.69   thorpej 
   1391    1.1       cgd 	moff = 0;
   1392    1.1       cgd 	offset = 0;
   1393  1.144    dyoung 	while (m != NULL && uio->uio_resid > 0 && error == 0) {
   1394    1.1       cgd 		if (m->m_type == MT_OOBDATA) {
   1395    1.1       cgd 			if (type != MT_OOBDATA)
   1396    1.1       cgd 				break;
   1397    1.1       cgd 		} else if (type == MT_OOBDATA)
   1398    1.1       cgd 			break;
   1399    1.1       cgd #ifdef DIAGNOSTIC
   1400    1.1       cgd 		else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
   1401    1.1       cgd 			panic("receive 3");
   1402    1.1       cgd #endif
   1403    1.1       cgd 		so->so_state &= ~SS_RCVATMARK;
   1404  1.196       dsl 		wakeup_state = 0;
   1405    1.1       cgd 		len = uio->uio_resid;
   1406    1.1       cgd 		if (so->so_oobmark && len > so->so_oobmark - offset)
   1407    1.1       cgd 			len = so->so_oobmark - offset;
   1408    1.1       cgd 		if (len > m->m_len - moff)
   1409    1.1       cgd 			len = m->m_len - moff;
   1410    1.1       cgd 		/*
   1411    1.1       cgd 		 * If mp is set, just pass back the mbufs.
   1412    1.1       cgd 		 * Otherwise copy them out via the uio, then free.
   1413    1.1       cgd 		 * Sockbuf must be consistent here (points to current mbuf,
   1414    1.1       cgd 		 * it points to next record) when we drop priority;
   1415    1.1       cgd 		 * we must note any additions to the sockbuf when we
   1416    1.1       cgd 		 * block interrupts again.
   1417    1.1       cgd 		 */
   1418  1.144    dyoung 		if (mp == NULL) {
   1419   1.69   thorpej 			SBLASTRECORDCHK(&so->so_rcv, "soreceive uiomove");
   1420   1.69   thorpej 			SBLASTMBUFCHK(&so->so_rcv, "soreceive uiomove");
   1421  1.160        ad 			sounlock(so);
   1422    1.1       cgd 			splx(s);
   1423  1.211       chs 			error = uiomove(mtod(m, char *) + moff, len, uio);
   1424   1.20   mycroft 			s = splsoftnet();
   1425  1.160        ad 			solock(so);
   1426  1.144    dyoung 			if (error != 0) {
   1427   1.67        he 				/*
   1428   1.67        he 				 * If any part of the record has been removed
   1429   1.67        he 				 * (such as the MT_SONAME mbuf, which will
   1430   1.67        he 				 * happen when PR_ADDR, and thus also
   1431   1.67        he 				 * PR_ATOMIC, is set), then drop the entire
   1432   1.67        he 				 * record to maintain the atomicity of the
   1433   1.67        he 				 * receive operation.
   1434   1.67        he 				 *
   1435   1.67        he 				 * This avoids a later panic("receive 1a")
   1436   1.67        he 				 * when compiled with DIAGNOSTIC.
   1437   1.67        he 				 */
   1438  1.146    dyoung 				if (m && mbuf_removed && atomic)
   1439   1.67        he 					(void) sbdroprecord(&so->so_rcv);
   1440   1.67        he 
   1441   1.57  jdolecek 				goto release;
   1442   1.67        he 			}
   1443    1.1       cgd 		} else
   1444    1.1       cgd 			uio->uio_resid -= len;
   1445    1.1       cgd 		if (len == m->m_len - moff) {
   1446    1.1       cgd 			if (m->m_flags & M_EOR)
   1447    1.1       cgd 				flags |= MSG_EOR;
   1448    1.1       cgd 			if (flags & MSG_PEEK) {
   1449    1.1       cgd 				m = m->m_next;
   1450    1.1       cgd 				moff = 0;
   1451    1.1       cgd 			} else {
   1452    1.1       cgd 				nextrecord = m->m_nextpkt;
   1453    1.1       cgd 				sbfree(&so->so_rcv, m);
   1454    1.1       cgd 				if (mp) {
   1455    1.1       cgd 					*mp = m;
   1456    1.1       cgd 					mp = &m->m_next;
   1457    1.1       cgd 					so->so_rcv.sb_mb = m = m->m_next;
   1458  1.140    dyoung 					*mp = NULL;
   1459    1.1       cgd 				} else {
   1460    1.1       cgd 					MFREE(m, so->so_rcv.sb_mb);
   1461    1.1       cgd 					m = so->so_rcv.sb_mb;
   1462    1.1       cgd 				}
   1463   1.69   thorpej 				/*
   1464   1.69   thorpej 				 * If m != NULL, we also know that
   1465   1.69   thorpej 				 * so->so_rcv.sb_mb != NULL.
   1466   1.69   thorpej 				 */
   1467   1.69   thorpej 				KASSERT(so->so_rcv.sb_mb == m);
   1468   1.69   thorpej 				if (m) {
   1469    1.1       cgd 					m->m_nextpkt = nextrecord;
   1470   1.69   thorpej 					if (nextrecord == NULL)
   1471   1.69   thorpej 						so->so_rcv.sb_lastrecord = m;
   1472   1.69   thorpej 				} else {
   1473   1.69   thorpej 					so->so_rcv.sb_mb = nextrecord;
   1474   1.70   thorpej 					SB_EMPTY_FIXUP(&so->so_rcv);
   1475   1.69   thorpej 				}
   1476   1.69   thorpej 				SBLASTRECORDCHK(&so->so_rcv, "soreceive 3");
   1477   1.69   thorpej 				SBLASTMBUFCHK(&so->so_rcv, "soreceive 3");
   1478    1.1       cgd 			}
   1479  1.144    dyoung 		} else if (flags & MSG_PEEK)
   1480  1.144    dyoung 			moff += len;
   1481  1.144    dyoung 		else {
   1482  1.160        ad 			if (mp != NULL) {
   1483  1.160        ad 				mt = m_copym(m, 0, len, M_NOWAIT);
   1484  1.160        ad 				if (__predict_false(mt == NULL)) {
   1485  1.160        ad 					sounlock(so);
   1486  1.160        ad 					mt = m_copym(m, 0, len, M_WAIT);
   1487  1.160        ad 					solock(so);
   1488  1.160        ad 				}
   1489  1.160        ad 				*mp = mt;
   1490  1.160        ad 			}
   1491  1.144    dyoung 			m->m_data += len;
   1492  1.144    dyoung 			m->m_len -= len;
   1493  1.144    dyoung 			so->so_rcv.sb_cc -= len;
   1494    1.1       cgd 		}
   1495    1.1       cgd 		if (so->so_oobmark) {
   1496    1.1       cgd 			if ((flags & MSG_PEEK) == 0) {
   1497    1.1       cgd 				so->so_oobmark -= len;
   1498    1.1       cgd 				if (so->so_oobmark == 0) {
   1499    1.1       cgd 					so->so_state |= SS_RCVATMARK;
   1500    1.1       cgd 					break;
   1501    1.1       cgd 				}
   1502    1.7       cgd 			} else {
   1503    1.1       cgd 				offset += len;
   1504    1.7       cgd 				if (offset == so->so_oobmark)
   1505    1.7       cgd 					break;
   1506    1.7       cgd 			}
   1507    1.1       cgd 		}
   1508    1.1       cgd 		if (flags & MSG_EOR)
   1509    1.1       cgd 			break;
   1510    1.1       cgd 		/*
   1511    1.1       cgd 		 * If the MSG_WAITALL flag is set (for non-atomic socket),
   1512    1.1       cgd 		 * we must not quit until "uio->uio_resid == 0" or an error
   1513    1.1       cgd 		 * termination.  If a signal/timeout occurs, return
   1514    1.1       cgd 		 * with a short count but without error.
   1515    1.1       cgd 		 * Keep sockbuf locked against other readers.
   1516    1.1       cgd 		 */
   1517  1.144    dyoung 		while (flags & MSG_WAITALL && m == NULL && uio->uio_resid > 0 &&
   1518    1.3    andrew 		    !sosendallatonce(so) && !nextrecord) {
   1519    1.1       cgd 			if (so->so_error || so->so_state & SS_CANTRCVMORE)
   1520    1.1       cgd 				break;
   1521   1.68      matt 			/*
   1522   1.68      matt 			 * If we are peeking and the socket receive buffer is
   1523   1.68      matt 			 * full, stop since we can't get more data to peek at.
   1524   1.68      matt 			 */
   1525   1.68      matt 			if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
   1526   1.68      matt 				break;
   1527   1.68      matt 			/*
   1528   1.68      matt 			 * If we've drained the socket buffer, tell the
   1529   1.68      matt 			 * protocol in case it needs to do something to
   1530   1.68      matt 			 * get it filled again.
   1531   1.68      matt 			 */
   1532   1.68      matt 			if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb)
   1533   1.68      matt 				(*pr->pr_usrreq)(so, PRU_RCVD,
   1534  1.140    dyoung 				    NULL, (struct mbuf *)(long)flags, NULL, l);
   1535   1.69   thorpej 			SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");
   1536   1.69   thorpej 			SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");
   1537  1.196       dsl 			if (wakeup_state & SS_RESTARTSYS)
   1538  1.196       dsl 				error = ERESTART;
   1539  1.196       dsl 			else
   1540  1.196       dsl 				error = sbwait(&so->so_rcv);
   1541  1.144    dyoung 			if (error != 0) {
   1542    1.1       cgd 				sbunlock(&so->so_rcv);
   1543  1.160        ad 				sounlock(so);
   1544    1.1       cgd 				splx(s);
   1545  1.144    dyoung 				return 0;
   1546    1.1       cgd 			}
   1547   1.21  christos 			if ((m = so->so_rcv.sb_mb) != NULL)
   1548    1.1       cgd 				nextrecord = m->m_nextpkt;
   1549  1.196       dsl 			wakeup_state = so->so_state;
   1550    1.1       cgd 		}
   1551    1.1       cgd 	}
   1552    1.3    andrew 
   1553  1.146    dyoung 	if (m && atomic) {
   1554    1.3    andrew 		flags |= MSG_TRUNC;
   1555    1.3    andrew 		if ((flags & MSG_PEEK) == 0)
   1556    1.3    andrew 			(void) sbdroprecord(&so->so_rcv);
   1557    1.3    andrew 	}
   1558    1.1       cgd 	if ((flags & MSG_PEEK) == 0) {
   1559  1.144    dyoung 		if (m == NULL) {
   1560   1.69   thorpej 			/*
   1561   1.70   thorpej 			 * First part is an inline SB_EMPTY_FIXUP().  Second
   1562   1.69   thorpej 			 * part makes sure sb_lastrecord is up-to-date if
   1563   1.69   thorpej 			 * there is still data in the socket buffer.
   1564   1.69   thorpej 			 */
   1565    1.1       cgd 			so->so_rcv.sb_mb = nextrecord;
   1566   1.69   thorpej 			if (so->so_rcv.sb_mb == NULL) {
   1567   1.69   thorpej 				so->so_rcv.sb_mbtail = NULL;
   1568   1.69   thorpej 				so->so_rcv.sb_lastrecord = NULL;
   1569   1.69   thorpej 			} else if (nextrecord->m_nextpkt == NULL)
   1570   1.69   thorpej 				so->so_rcv.sb_lastrecord = nextrecord;
   1571   1.69   thorpej 		}
   1572   1.69   thorpej 		SBLASTRECORDCHK(&so->so_rcv, "soreceive 4");
   1573   1.69   thorpej 		SBLASTMBUFCHK(&so->so_rcv, "soreceive 4");
   1574    1.1       cgd 		if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
   1575  1.140    dyoung 			(*pr->pr_usrreq)(so, PRU_RCVD, NULL,
   1576  1.140    dyoung 			    (struct mbuf *)(long)flags, NULL, l);
   1577    1.1       cgd 	}
   1578    1.3    andrew 	if (orig_resid == uio->uio_resid && orig_resid &&
   1579    1.3    andrew 	    (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
   1580    1.3    andrew 		sbunlock(&so->so_rcv);
   1581    1.3    andrew 		goto restart;
   1582    1.3    andrew 	}
   1583  1.108     perry 
   1584  1.144    dyoung 	if (flagsp != NULL)
   1585    1.1       cgd 		*flagsp |= flags;
   1586   1.54     lukem  release:
   1587    1.1       cgd 	sbunlock(&so->so_rcv);
   1588  1.160        ad 	sounlock(so);
   1589    1.1       cgd 	splx(s);
   1590  1.144    dyoung 	return error;
   1591    1.1       cgd }
   1592    1.1       cgd 
   1593   1.14   mycroft int
   1594   1.54     lukem soshutdown(struct socket *so, int how)
   1595    1.1       cgd {
   1596   1.99      matt 	const struct protosw	*pr;
   1597  1.160        ad 	int	error;
   1598  1.160        ad 
   1599  1.160        ad 	KASSERT(solocked(so));
   1600   1.34    kleink 
   1601   1.54     lukem 	pr = so->so_proto;
   1602   1.34    kleink 	if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
   1603   1.34    kleink 		return (EINVAL);
   1604    1.1       cgd 
   1605  1.160        ad 	if (how == SHUT_RD || how == SHUT_RDWR) {
   1606    1.1       cgd 		sorflush(so);
   1607  1.160        ad 		error = 0;
   1608  1.160        ad 	}
   1609   1.34    kleink 	if (how == SHUT_WR || how == SHUT_RDWR)
   1610  1.160        ad 		error = (*pr->pr_usrreq)(so, PRU_SHUTDOWN, NULL,
   1611  1.140    dyoung 		    NULL, NULL, NULL);
   1612  1.160        ad 
   1613  1.160        ad 	return error;
   1614    1.1       cgd }
   1615    1.1       cgd 
   1616  1.195       dsl void
   1617  1.196       dsl sorestart(struct socket *so)
   1618  1.188        ad {
   1619  1.196       dsl 	/*
   1620  1.196       dsl 	 * An application has called close() on an fd on which another
   1621  1.196       dsl 	 * of its threads has called a socket system call.
   1622  1.196       dsl 	 * Mark this and wake everyone up, and code that would block again
   1623  1.196       dsl 	 * instead returns ERESTART.
   1624  1.196       dsl 	 * On system call re-entry the fd is validated and EBADF returned.
   1625  1.196       dsl 	 * Any other fd will block again on the 2nd syscall.
   1626  1.196       dsl 	 */
   1627  1.188        ad 	solock(so);
   1628  1.196       dsl 	so->so_state |= SS_RESTARTSYS;
   1629  1.188        ad 	cv_broadcast(&so->so_cv);
   1630  1.196       dsl 	cv_broadcast(&so->so_snd.sb_cv);
   1631  1.196       dsl 	cv_broadcast(&so->so_rcv.sb_cv);
   1632  1.188        ad 	sounlock(so);
   1633  1.188        ad }
   1634  1.188        ad 
   1635   1.14   mycroft void
   1636   1.54     lukem sorflush(struct socket *so)
   1637    1.1       cgd {
   1638   1.54     lukem 	struct sockbuf	*sb, asb;
   1639   1.99      matt 	const struct protosw	*pr;
   1640  1.160        ad 
   1641  1.160        ad 	KASSERT(solocked(so));
   1642    1.1       cgd 
   1643   1.54     lukem 	sb = &so->so_rcv;
   1644   1.54     lukem 	pr = so->so_proto;
   1645  1.160        ad 	socantrcvmore(so);
   1646    1.1       cgd 	sb->sb_flags |= SB_NOINTR;
   1647  1.160        ad 	(void )sblock(sb, M_WAITOK);
   1648    1.1       cgd 	sbunlock(sb);
   1649    1.1       cgd 	asb = *sb;
   1650   1.86  wrstuden 	/*
   1651   1.86  wrstuden 	 * Clear most of the sockbuf structure, but leave some of the
   1652   1.86  wrstuden 	 * fields valid.
   1653   1.86  wrstuden 	 */
   1654   1.86  wrstuden 	memset(&sb->sb_startzero, 0,
   1655   1.86  wrstuden 	    sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
   1656  1.160        ad 	if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose) {
   1657  1.160        ad 		sounlock(so);
   1658    1.1       cgd 		(*pr->pr_domain->dom_dispose)(asb.sb_mb);
   1659  1.160        ad 		solock(so);
   1660  1.160        ad 	}
   1661   1.98  christos 	sbrelease(&asb, so);
   1662    1.1       cgd }
   1663    1.1       cgd 
   1664  1.171    plunky /*
   1665  1.171    plunky  * internal set SOL_SOCKET options
   1666  1.171    plunky  */
   1667  1.142    dyoung static int
   1668  1.171    plunky sosetopt1(struct socket *so, const struct sockopt *sopt)
   1669    1.1       cgd {
   1670  1.182  christos 	int error = EINVAL, optval, opt;
   1671  1.171    plunky 	struct linger l;
   1672  1.171    plunky 	struct timeval tv;
   1673  1.142    dyoung 
   1674  1.179  christos 	switch ((opt = sopt->sopt_name)) {
   1675  1.142    dyoung 
   1676  1.170       tls 	case SO_ACCEPTFILTER:
   1677  1.177        ad 		error = accept_filt_setopt(so, sopt);
   1678  1.177        ad 		KASSERT(solocked(so));
   1679  1.170       tls 		break;
   1680  1.170       tls 
   1681  1.171    plunky   	case SO_LINGER:
   1682  1.171    plunky  		error = sockopt_get(sopt, &l, sizeof(l));
   1683  1.177        ad 		solock(so);
   1684  1.171    plunky  		if (error)
   1685  1.177        ad  			break;
   1686  1.171    plunky  		if (l.l_linger < 0 || l.l_linger > USHRT_MAX ||
   1687  1.177        ad  		    l.l_linger > (INT_MAX / hz)) {
   1688  1.177        ad 			error = EDOM;
   1689  1.177        ad 			break;
   1690  1.177        ad 		}
   1691  1.171    plunky  		so->so_linger = l.l_linger;
   1692  1.171    plunky  		if (l.l_onoff)
   1693  1.171    plunky  			so->so_options |= SO_LINGER;
   1694  1.171    plunky  		else
   1695  1.171    plunky  			so->so_options &= ~SO_LINGER;
   1696  1.177        ad    		break;
   1697    1.1       cgd 
   1698  1.142    dyoung 	case SO_DEBUG:
   1699  1.142    dyoung 	case SO_KEEPALIVE:
   1700  1.142    dyoung 	case SO_DONTROUTE:
   1701  1.142    dyoung 	case SO_USELOOPBACK:
   1702  1.142    dyoung 	case SO_BROADCAST:
   1703  1.142    dyoung 	case SO_REUSEADDR:
   1704  1.142    dyoung 	case SO_REUSEPORT:
   1705  1.142    dyoung 	case SO_OOBINLINE:
   1706  1.142    dyoung 	case SO_TIMESTAMP:
   1707  1.207  christos 	case SO_NOSIGPIPE:
   1708  1.184  christos #ifdef SO_OTIMESTAMP
   1709  1.184  christos 	case SO_OTIMESTAMP:
   1710  1.184  christos #endif
   1711  1.171    plunky 		error = sockopt_getint(sopt, &optval);
   1712  1.177        ad 		solock(so);
   1713  1.171    plunky 		if (error)
   1714  1.177        ad 			break;
   1715  1.171    plunky 		if (optval)
   1716  1.179  christos 			so->so_options |= opt;
   1717  1.142    dyoung 		else
   1718  1.179  christos 			so->so_options &= ~opt;
   1719  1.142    dyoung 		break;
   1720  1.142    dyoung 
   1721  1.142    dyoung 	case SO_SNDBUF:
   1722  1.142    dyoung 	case SO_RCVBUF:
   1723  1.142    dyoung 	case SO_SNDLOWAT:
   1724  1.142    dyoung 	case SO_RCVLOWAT:
   1725  1.171    plunky 		error = sockopt_getint(sopt, &optval);
   1726  1.177        ad 		solock(so);
   1727  1.171    plunky 		if (error)
   1728  1.177        ad 			break;
   1729    1.1       cgd 
   1730  1.142    dyoung 		/*
   1731  1.142    dyoung 		 * Values < 1 make no sense for any of these
   1732  1.142    dyoung 		 * options, so disallow them.
   1733  1.142    dyoung 		 */
   1734  1.177        ad 		if (optval < 1) {
   1735  1.177        ad 			error = EINVAL;
   1736  1.177        ad 			break;
   1737  1.177        ad 		}
   1738    1.1       cgd 
   1739  1.179  christos 		switch (opt) {
   1740  1.171    plunky 		case SO_SNDBUF:
   1741  1.177        ad 			if (sbreserve(&so->so_snd, (u_long)optval, so) == 0) {
   1742  1.177        ad 				error = ENOBUFS;
   1743  1.177        ad 				break;
   1744  1.177        ad 			}
   1745  1.171    plunky 			so->so_snd.sb_flags &= ~SB_AUTOSIZE;
   1746  1.171    plunky 			break;
   1747    1.1       cgd 
   1748    1.1       cgd 		case SO_RCVBUF:
   1749  1.177        ad 			if (sbreserve(&so->so_rcv, (u_long)optval, so) == 0) {
   1750  1.177        ad 				error = ENOBUFS;
   1751  1.177        ad 				break;
   1752  1.177        ad 			}
   1753  1.171    plunky 			so->so_rcv.sb_flags &= ~SB_AUTOSIZE;
   1754  1.142    dyoung 			break;
   1755  1.142    dyoung 
   1756  1.142    dyoung 		/*
   1757  1.142    dyoung 		 * Make sure the low-water is never greater than
   1758  1.142    dyoung 		 * the high-water.
   1759  1.142    dyoung 		 */
   1760    1.1       cgd 		case SO_SNDLOWAT:
   1761  1.171    plunky 			if (optval > so->so_snd.sb_hiwat)
   1762  1.171    plunky 				optval = so->so_snd.sb_hiwat;
   1763  1.171    plunky 
   1764  1.171    plunky 			so->so_snd.sb_lowat = optval;
   1765  1.142    dyoung 			break;
   1766  1.171    plunky 
   1767    1.1       cgd 		case SO_RCVLOWAT:
   1768  1.171    plunky 			if (optval > so->so_rcv.sb_hiwat)
   1769  1.171    plunky 				optval = so->so_rcv.sb_hiwat;
   1770  1.171    plunky 
   1771  1.171    plunky 			so->so_rcv.sb_lowat = optval;
   1772  1.142    dyoung 			break;
   1773  1.142    dyoung 		}
   1774  1.142    dyoung 		break;
   1775   1.28   thorpej 
   1776  1.179  christos #ifdef COMPAT_50
   1777  1.179  christos 	case SO_OSNDTIMEO:
   1778  1.179  christos 	case SO_ORCVTIMEO: {
   1779  1.179  christos 		struct timeval50 otv;
   1780  1.179  christos 		error = sockopt_get(sopt, &otv, sizeof(otv));
   1781  1.186     pooka 		if (error) {
   1782  1.186     pooka 			solock(so);
   1783  1.183  christos 			break;
   1784  1.186     pooka 		}
   1785  1.179  christos 		timeval50_to_timeval(&otv, &tv);
   1786  1.179  christos 		opt = opt == SO_OSNDTIMEO ? SO_SNDTIMEO : SO_RCVTIMEO;
   1787  1.182  christos 		error = 0;
   1788  1.179  christos 		/*FALLTHROUGH*/
   1789  1.179  christos 	}
   1790  1.179  christos #endif /* COMPAT_50 */
   1791  1.179  christos 
   1792  1.142    dyoung 	case SO_SNDTIMEO:
   1793  1.142    dyoung 	case SO_RCVTIMEO:
   1794  1.182  christos 		if (error)
   1795  1.179  christos 			error = sockopt_get(sopt, &tv, sizeof(tv));
   1796  1.177        ad 		solock(so);
   1797  1.171    plunky 		if (error)
   1798  1.177        ad 			break;
   1799  1.171    plunky 
   1800  1.177        ad 		if (tv.tv_sec > (INT_MAX - tv.tv_usec / tick) / hz) {
   1801  1.177        ad 			error = EDOM;
   1802  1.177        ad 			break;
   1803  1.177        ad 		}
   1804   1.28   thorpej 
   1805  1.171    plunky 		optval = tv.tv_sec * hz + tv.tv_usec / tick;
   1806  1.171    plunky 		if (optval == 0 && tv.tv_usec != 0)
   1807  1.171    plunky 			optval = 1;
   1808   1.28   thorpej 
   1809  1.179  christos 		switch (opt) {
   1810  1.142    dyoung 		case SO_SNDTIMEO:
   1811  1.171    plunky 			so->so_snd.sb_timeo = optval;
   1812    1.1       cgd 			break;
   1813    1.1       cgd 		case SO_RCVTIMEO:
   1814  1.171    plunky 			so->so_rcv.sb_timeo = optval;
   1815  1.142    dyoung 			break;
   1816  1.142    dyoung 		}
   1817  1.142    dyoung 		break;
   1818    1.1       cgd 
   1819  1.142    dyoung 	default:
   1820  1.177        ad 		solock(so);
   1821  1.177        ad 		error = ENOPROTOOPT;
   1822  1.177        ad 		break;
   1823  1.142    dyoung 	}
   1824  1.177        ad 	KASSERT(solocked(so));
   1825  1.177        ad 	return error;
   1826  1.142    dyoung }
   1827    1.1       cgd 
   1828  1.142    dyoung int
   1829  1.171    plunky sosetopt(struct socket *so, struct sockopt *sopt)
   1830  1.142    dyoung {
   1831  1.142    dyoung 	int error, prerr;
   1832    1.1       cgd 
   1833  1.177        ad 	if (sopt->sopt_level == SOL_SOCKET) {
   1834  1.171    plunky 		error = sosetopt1(so, sopt);
   1835  1.177        ad 		KASSERT(solocked(so));
   1836  1.177        ad 	} else {
   1837  1.142    dyoung 		error = ENOPROTOOPT;
   1838  1.177        ad 		solock(so);
   1839  1.177        ad 	}
   1840    1.1       cgd 
   1841  1.142    dyoung 	if ((error == 0 || error == ENOPROTOOPT) &&
   1842  1.142    dyoung 	    so->so_proto != NULL && so->so_proto->pr_ctloutput != NULL) {
   1843  1.142    dyoung 		/* give the protocol stack a shot */
   1844  1.171    plunky 		prerr = (*so->so_proto->pr_ctloutput)(PRCO_SETOPT, so, sopt);
   1845  1.142    dyoung 		if (prerr == 0)
   1846  1.142    dyoung 			error = 0;
   1847  1.142    dyoung 		else if (prerr != ENOPROTOOPT)
   1848  1.142    dyoung 			error = prerr;
   1849  1.171    plunky 	}
   1850  1.160        ad 	sounlock(so);
   1851  1.142    dyoung 	return error;
   1852    1.1       cgd }
   1853    1.1       cgd 
   1854  1.171    plunky /*
   1855  1.171    plunky  * so_setsockopt() is a wrapper providing a sockopt structure for sosetopt()
   1856  1.171    plunky  */
   1857  1.171    plunky int
   1858  1.171    plunky so_setsockopt(struct lwp *l, struct socket *so, int level, int name,
   1859  1.171    plunky     const void *val, size_t valsize)
   1860  1.171    plunky {
   1861  1.171    plunky 	struct sockopt sopt;
   1862  1.171    plunky 	int error;
   1863  1.171    plunky 
   1864  1.171    plunky 	KASSERT(valsize == 0 || val != NULL);
   1865  1.171    plunky 
   1866  1.171    plunky 	sockopt_init(&sopt, level, name, valsize);
   1867  1.171    plunky 	sockopt_set(&sopt, val, valsize);
   1868  1.171    plunky 
   1869  1.171    plunky 	error = sosetopt(so, &sopt);
   1870  1.171    plunky 
   1871  1.171    plunky 	sockopt_destroy(&sopt);
   1872  1.171    plunky 
   1873  1.171    plunky 	return error;
   1874  1.171    plunky }
   1875  1.171    plunky 
   1876  1.171    plunky /*
   1877  1.171    plunky  * internal get SOL_SOCKET options
   1878  1.171    plunky  */
   1879  1.171    plunky static int
   1880  1.171    plunky sogetopt1(struct socket *so, struct sockopt *sopt)
   1881  1.171    plunky {
   1882  1.179  christos 	int error, optval, opt;
   1883  1.171    plunky 	struct linger l;
   1884  1.171    plunky 	struct timeval tv;
   1885  1.171    plunky 
   1886  1.179  christos 	switch ((opt = sopt->sopt_name)) {
   1887  1.171    plunky 
   1888  1.171    plunky 	case SO_ACCEPTFILTER:
   1889  1.177        ad 		error = accept_filt_getopt(so, sopt);
   1890  1.171    plunky 		break;
   1891  1.171    plunky 
   1892  1.171    plunky 	case SO_LINGER:
   1893  1.171    plunky 		l.l_onoff = (so->so_options & SO_LINGER) ? 1 : 0;
   1894  1.171    plunky 		l.l_linger = so->so_linger;
   1895  1.171    plunky 
   1896  1.171    plunky 		error = sockopt_set(sopt, &l, sizeof(l));
   1897  1.171    plunky 		break;
   1898  1.171    plunky 
   1899  1.171    plunky 	case SO_USELOOPBACK:
   1900  1.171    plunky 	case SO_DONTROUTE:
   1901  1.171    plunky 	case SO_DEBUG:
   1902  1.171    plunky 	case SO_KEEPALIVE:
   1903  1.171    plunky 	case SO_REUSEADDR:
   1904  1.171    plunky 	case SO_REUSEPORT:
   1905  1.171    plunky 	case SO_BROADCAST:
   1906  1.171    plunky 	case SO_OOBINLINE:
   1907  1.171    plunky 	case SO_TIMESTAMP:
   1908  1.207  christos 	case SO_NOSIGPIPE:
   1909  1.184  christos #ifdef SO_OTIMESTAMP
   1910  1.184  christos 	case SO_OTIMESTAMP:
   1911  1.184  christos #endif
   1912  1.179  christos 		error = sockopt_setint(sopt, (so->so_options & opt) ? 1 : 0);
   1913  1.171    plunky 		break;
   1914  1.171    plunky 
   1915  1.171    plunky 	case SO_TYPE:
   1916  1.171    plunky 		error = sockopt_setint(sopt, so->so_type);
   1917  1.171    plunky 		break;
   1918  1.171    plunky 
   1919  1.171    plunky 	case SO_ERROR:
   1920  1.171    plunky 		error = sockopt_setint(sopt, so->so_error);
   1921  1.171    plunky 		so->so_error = 0;
   1922  1.171    plunky 		break;
   1923  1.171    plunky 
   1924  1.171    plunky 	case SO_SNDBUF:
   1925  1.171    plunky 		error = sockopt_setint(sopt, so->so_snd.sb_hiwat);
   1926  1.171    plunky 		break;
   1927  1.171    plunky 
   1928  1.171    plunky 	case SO_RCVBUF:
   1929  1.171    plunky 		error = sockopt_setint(sopt, so->so_rcv.sb_hiwat);
   1930  1.171    plunky 		break;
   1931  1.171    plunky 
   1932  1.171    plunky 	case SO_SNDLOWAT:
   1933  1.171    plunky 		error = sockopt_setint(sopt, so->so_snd.sb_lowat);
   1934  1.171    plunky 		break;
   1935  1.171    plunky 
   1936  1.171    plunky 	case SO_RCVLOWAT:
   1937  1.171    plunky 		error = sockopt_setint(sopt, so->so_rcv.sb_lowat);
   1938  1.171    plunky 		break;
   1939  1.171    plunky 
   1940  1.179  christos #ifdef COMPAT_50
   1941  1.179  christos 	case SO_OSNDTIMEO:
   1942  1.179  christos 	case SO_ORCVTIMEO: {
   1943  1.179  christos 		struct timeval50 otv;
   1944  1.179  christos 
   1945  1.179  christos 		optval = (opt == SO_OSNDTIMEO ?
   1946  1.179  christos 		     so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
   1947  1.179  christos 
   1948  1.179  christos 		otv.tv_sec = optval / hz;
   1949  1.179  christos 		otv.tv_usec = (optval % hz) * tick;
   1950  1.179  christos 
   1951  1.179  christos 		error = sockopt_set(sopt, &otv, sizeof(otv));
   1952  1.179  christos 		break;
   1953  1.179  christos 	}
   1954  1.179  christos #endif /* COMPAT_50 */
   1955  1.179  christos 
   1956  1.171    plunky 	case SO_SNDTIMEO:
   1957  1.171    plunky 	case SO_RCVTIMEO:
   1958  1.179  christos 		optval = (opt == SO_SNDTIMEO ?
   1959  1.171    plunky 		     so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
   1960  1.171    plunky 
   1961  1.171    plunky 		tv.tv_sec = optval / hz;
   1962  1.171    plunky 		tv.tv_usec = (optval % hz) * tick;
   1963  1.171    plunky 
   1964  1.171    plunky 		error = sockopt_set(sopt, &tv, sizeof(tv));
   1965  1.171    plunky 		break;
   1966  1.171    plunky 
   1967  1.171    plunky 	case SO_OVERFLOWED:
   1968  1.171    plunky 		error = sockopt_setint(sopt, so->so_rcv.sb_overflowed);
   1969  1.171    plunky 		break;
   1970  1.171    plunky 
   1971  1.171    plunky 	default:
   1972  1.171    plunky 		error = ENOPROTOOPT;
   1973  1.171    plunky 		break;
   1974  1.171    plunky 	}
   1975  1.171    plunky 
   1976  1.171    plunky 	return (error);
   1977  1.171    plunky }
   1978  1.171    plunky 
   1979   1.14   mycroft int
   1980  1.171    plunky sogetopt(struct socket *so, struct sockopt *sopt)
   1981    1.1       cgd {
   1982  1.160        ad 	int		error;
   1983    1.1       cgd 
   1984  1.160        ad 	solock(so);
   1985  1.171    plunky 	if (sopt->sopt_level != SOL_SOCKET) {
   1986    1.1       cgd 		if (so->so_proto && so->so_proto->pr_ctloutput) {
   1987  1.160        ad 			error = ((*so->so_proto->pr_ctloutput)
   1988  1.171    plunky 			    (PRCO_GETOPT, so, sopt));
   1989    1.1       cgd 		} else
   1990  1.160        ad 			error = (ENOPROTOOPT);
   1991    1.1       cgd 	} else {
   1992  1.171    plunky 		error = sogetopt1(so, sopt);
   1993  1.171    plunky 	}
   1994  1.171    plunky 	sounlock(so);
   1995  1.171    plunky 	return (error);
   1996  1.171    plunky }
   1997  1.171    plunky 
   1998  1.171    plunky /*
   1999  1.171    plunky  * alloc sockopt data buffer buffer
   2000  1.171    plunky  *	- will be released at destroy
   2001  1.171    plunky  */
   2002  1.176    plunky static int
   2003  1.176    plunky sockopt_alloc(struct sockopt *sopt, size_t len, km_flag_t kmflag)
   2004  1.171    plunky {
   2005  1.171    plunky 
   2006  1.171    plunky 	KASSERT(sopt->sopt_size == 0);
   2007  1.171    plunky 
   2008  1.176    plunky 	if (len > sizeof(sopt->sopt_buf)) {
   2009  1.176    plunky 		sopt->sopt_data = kmem_zalloc(len, kmflag);
   2010  1.176    plunky 		if (sopt->sopt_data == NULL)
   2011  1.176    plunky 			return ENOMEM;
   2012  1.176    plunky 	} else
   2013  1.171    plunky 		sopt->sopt_data = sopt->sopt_buf;
   2014  1.171    plunky 
   2015  1.171    plunky 	sopt->sopt_size = len;
   2016  1.176    plunky 	return 0;
   2017  1.171    plunky }
   2018  1.171    plunky 
   2019  1.171    plunky /*
   2020  1.171    plunky  * initialise sockopt storage
   2021  1.176    plunky  *	- MAY sleep during allocation
   2022  1.171    plunky  */
   2023  1.171    plunky void
   2024  1.171    plunky sockopt_init(struct sockopt *sopt, int level, int name, size_t size)
   2025  1.171    plunky {
   2026    1.1       cgd 
   2027  1.171    plunky 	memset(sopt, 0, sizeof(*sopt));
   2028    1.1       cgd 
   2029  1.171    plunky 	sopt->sopt_level = level;
   2030  1.171    plunky 	sopt->sopt_name = name;
   2031  1.176    plunky 	(void)sockopt_alloc(sopt, size, KM_SLEEP);
   2032  1.171    plunky }
   2033  1.171    plunky 
   2034  1.171    plunky /*
   2035  1.171    plunky  * destroy sockopt storage
   2036  1.171    plunky  *	- will release any held memory references
   2037  1.171    plunky  */
   2038  1.171    plunky void
   2039  1.171    plunky sockopt_destroy(struct sockopt *sopt)
   2040  1.171    plunky {
   2041  1.171    plunky 
   2042  1.171    plunky 	if (sopt->sopt_data != sopt->sopt_buf)
   2043  1.173    plunky 		kmem_free(sopt->sopt_data, sopt->sopt_size);
   2044  1.171    plunky 
   2045  1.171    plunky 	memset(sopt, 0, sizeof(*sopt));
   2046  1.171    plunky }
   2047  1.171    plunky 
   2048  1.171    plunky /*
   2049  1.171    plunky  * set sockopt value
   2050  1.171    plunky  *	- value is copied into sockopt
   2051  1.176    plunky  * 	- memory is allocated when necessary, will not sleep
   2052  1.171    plunky  */
   2053  1.171    plunky int
   2054  1.171    plunky sockopt_set(struct sockopt *sopt, const void *buf, size_t len)
   2055  1.171    plunky {
   2056  1.176    plunky 	int error;
   2057  1.171    plunky 
   2058  1.176    plunky 	if (sopt->sopt_size == 0) {
   2059  1.176    plunky 		error = sockopt_alloc(sopt, len, KM_NOSLEEP);
   2060  1.176    plunky 		if (error)
   2061  1.176    plunky 			return error;
   2062  1.176    plunky 	}
   2063  1.171    plunky 
   2064  1.171    plunky 	KASSERT(sopt->sopt_size == len);
   2065  1.171    plunky 	memcpy(sopt->sopt_data, buf, len);
   2066  1.171    plunky 	return 0;
   2067  1.171    plunky }
   2068  1.171    plunky 
   2069  1.171    plunky /*
   2070  1.171    plunky  * common case of set sockopt integer value
   2071  1.171    plunky  */
   2072  1.171    plunky int
   2073  1.171    plunky sockopt_setint(struct sockopt *sopt, int val)
   2074  1.171    plunky {
   2075  1.171    plunky 
   2076  1.171    plunky 	return sockopt_set(sopt, &val, sizeof(int));
   2077  1.171    plunky }
   2078  1.171    plunky 
   2079  1.171    plunky /*
   2080  1.171    plunky  * get sockopt value
   2081  1.171    plunky  *	- correct size must be given
   2082  1.171    plunky  */
   2083  1.171    plunky int
   2084  1.171    plunky sockopt_get(const struct sockopt *sopt, void *buf, size_t len)
   2085  1.171    plunky {
   2086  1.170       tls 
   2087  1.171    plunky 	if (sopt->sopt_size != len)
   2088  1.171    plunky 		return EINVAL;
   2089    1.1       cgd 
   2090  1.171    plunky 	memcpy(buf, sopt->sopt_data, len);
   2091  1.171    plunky 	return 0;
   2092  1.171    plunky }
   2093    1.1       cgd 
   2094  1.171    plunky /*
   2095  1.171    plunky  * common case of get sockopt integer value
   2096  1.171    plunky  */
   2097  1.171    plunky int
   2098  1.171    plunky sockopt_getint(const struct sockopt *sopt, int *valp)
   2099  1.171    plunky {
   2100    1.1       cgd 
   2101  1.171    plunky 	return sockopt_get(sopt, valp, sizeof(int));
   2102  1.171    plunky }
   2103    1.1       cgd 
   2104  1.171    plunky /*
   2105  1.171    plunky  * set sockopt value from mbuf
   2106  1.171    plunky  *	- ONLY for legacy code
   2107  1.171    plunky  *	- mbuf is released by sockopt
   2108  1.176    plunky  *	- will not sleep
   2109  1.171    plunky  */
   2110  1.171    plunky int
   2111  1.171    plunky sockopt_setmbuf(struct sockopt *sopt, struct mbuf *m)
   2112  1.171    plunky {
   2113  1.171    plunky 	size_t len;
   2114  1.176    plunky 	int error;
   2115    1.1       cgd 
   2116  1.171    plunky 	len = m_length(m);
   2117    1.1       cgd 
   2118  1.176    plunky 	if (sopt->sopt_size == 0) {
   2119  1.176    plunky 		error = sockopt_alloc(sopt, len, KM_NOSLEEP);
   2120  1.176    plunky 		if (error)
   2121  1.176    plunky 			return error;
   2122  1.176    plunky 	}
   2123    1.1       cgd 
   2124  1.171    plunky 	KASSERT(sopt->sopt_size == len);
   2125  1.171    plunky 	m_copydata(m, 0, len, sopt->sopt_data);
   2126  1.171    plunky 	m_freem(m);
   2127    1.1       cgd 
   2128  1.171    plunky 	return 0;
   2129  1.171    plunky }
   2130    1.1       cgd 
   2131  1.171    plunky /*
   2132  1.171    plunky  * get sockopt value into mbuf
   2133  1.171    plunky  *	- ONLY for legacy code
   2134  1.171    plunky  *	- mbuf to be released by the caller
   2135  1.176    plunky  *	- will not sleep
   2136  1.171    plunky  */
   2137  1.171    plunky struct mbuf *
   2138  1.171    plunky sockopt_getmbuf(const struct sockopt *sopt)
   2139  1.171    plunky {
   2140  1.171    plunky 	struct mbuf *m;
   2141  1.107   darrenr 
   2142  1.176    plunky 	if (sopt->sopt_size > MCLBYTES)
   2143  1.176    plunky 		return NULL;
   2144  1.176    plunky 
   2145  1.176    plunky 	m = m_get(M_DONTWAIT, MT_SOOPTS);
   2146  1.171    plunky 	if (m == NULL)
   2147  1.171    plunky 		return NULL;
   2148  1.171    plunky 
   2149  1.176    plunky 	if (sopt->sopt_size > MLEN) {
   2150  1.176    plunky 		MCLGET(m, M_DONTWAIT);
   2151  1.176    plunky 		if ((m->m_flags & M_EXT) == 0) {
   2152  1.176    plunky 			m_free(m);
   2153  1.176    plunky 			return NULL;
   2154  1.176    plunky 		}
   2155    1.1       cgd 	}
   2156  1.176    plunky 
   2157  1.176    plunky 	memcpy(mtod(m, void *), sopt->sopt_data, sopt->sopt_size);
   2158  1.176    plunky 	m->m_len = sopt->sopt_size;
   2159  1.160        ad 
   2160  1.171    plunky 	return m;
   2161    1.1       cgd }
   2162    1.1       cgd 
   2163   1.14   mycroft void
   2164   1.54     lukem sohasoutofband(struct socket *so)
   2165    1.1       cgd {
   2166  1.153     rmind 
   2167   1.90  christos 	fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);
   2168  1.189        ad 	selnotify(&so->so_rcv.sb_sel, POLLPRI | POLLRDBAND, NOTE_SUBMIT);
   2169    1.1       cgd }
   2170   1.72  jdolecek 
   2171   1.72  jdolecek static void
   2172   1.72  jdolecek filt_sordetach(struct knote *kn)
   2173   1.72  jdolecek {
   2174   1.72  jdolecek 	struct socket	*so;
   2175   1.72  jdolecek 
   2176  1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2177  1.160        ad 	solock(so);
   2178   1.73  christos 	SLIST_REMOVE(&so->so_rcv.sb_sel.sel_klist, kn, knote, kn_selnext);
   2179   1.73  christos 	if (SLIST_EMPTY(&so->so_rcv.sb_sel.sel_klist))
   2180   1.72  jdolecek 		so->so_rcv.sb_flags &= ~SB_KNOTE;
   2181  1.160        ad 	sounlock(so);
   2182   1.72  jdolecek }
   2183   1.72  jdolecek 
   2184   1.72  jdolecek /*ARGSUSED*/
   2185   1.72  jdolecek static int
   2186  1.129      yamt filt_soread(struct knote *kn, long hint)
   2187   1.72  jdolecek {
   2188   1.72  jdolecek 	struct socket	*so;
   2189  1.160        ad 	int rv;
   2190   1.72  jdolecek 
   2191  1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2192  1.160        ad 	if (hint != NOTE_SUBMIT)
   2193  1.160        ad 		solock(so);
   2194   1.72  jdolecek 	kn->kn_data = so->so_rcv.sb_cc;
   2195   1.72  jdolecek 	if (so->so_state & SS_CANTRCVMORE) {
   2196  1.108     perry 		kn->kn_flags |= EV_EOF;
   2197   1.72  jdolecek 		kn->kn_fflags = so->so_error;
   2198  1.160        ad 		rv = 1;
   2199  1.160        ad 	} else if (so->so_error)	/* temporary udp error */
   2200  1.160        ad 		rv = 1;
   2201  1.160        ad 	else if (kn->kn_sfflags & NOTE_LOWAT)
   2202  1.160        ad 		rv = (kn->kn_data >= kn->kn_sdata);
   2203  1.160        ad 	else
   2204  1.160        ad 		rv = (kn->kn_data >= so->so_rcv.sb_lowat);
   2205  1.160        ad 	if (hint != NOTE_SUBMIT)
   2206  1.160        ad 		sounlock(so);
   2207  1.160        ad 	return rv;
   2208   1.72  jdolecek }
   2209   1.72  jdolecek 
   2210   1.72  jdolecek static void
   2211   1.72  jdolecek filt_sowdetach(struct knote *kn)
   2212   1.72  jdolecek {
   2213   1.72  jdolecek 	struct socket	*so;
   2214   1.72  jdolecek 
   2215  1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2216  1.160        ad 	solock(so);
   2217   1.73  christos 	SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);
   2218   1.73  christos 	if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))
   2219   1.72  jdolecek 		so->so_snd.sb_flags &= ~SB_KNOTE;
   2220  1.160        ad 	sounlock(so);
   2221   1.72  jdolecek }
   2222   1.72  jdolecek 
   2223   1.72  jdolecek /*ARGSUSED*/
   2224   1.72  jdolecek static int
   2225  1.129      yamt filt_sowrite(struct knote *kn, long hint)
   2226   1.72  jdolecek {
   2227   1.72  jdolecek 	struct socket	*so;
   2228  1.160        ad 	int rv;
   2229   1.72  jdolecek 
   2230  1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2231  1.160        ad 	if (hint != NOTE_SUBMIT)
   2232  1.160        ad 		solock(so);
   2233   1.72  jdolecek 	kn->kn_data = sbspace(&so->so_snd);
   2234   1.72  jdolecek 	if (so->so_state & SS_CANTSENDMORE) {
   2235  1.108     perry 		kn->kn_flags |= EV_EOF;
   2236   1.72  jdolecek 		kn->kn_fflags = so->so_error;
   2237  1.160        ad 		rv = 1;
   2238  1.160        ad 	} else if (so->so_error)	/* temporary udp error */
   2239  1.160        ad 		rv = 1;
   2240  1.160        ad 	else if (((so->so_state & SS_ISCONNECTED) == 0) &&
   2241   1.72  jdolecek 	    (so->so_proto->pr_flags & PR_CONNREQUIRED))
   2242  1.160        ad 		rv = 0;
   2243  1.160        ad 	else if (kn->kn_sfflags & NOTE_LOWAT)
   2244  1.160        ad 		rv = (kn->kn_data >= kn->kn_sdata);
   2245  1.160        ad 	else
   2246  1.160        ad 		rv = (kn->kn_data >= so->so_snd.sb_lowat);
   2247  1.160        ad 	if (hint != NOTE_SUBMIT)
   2248  1.160        ad 		sounlock(so);
   2249  1.160        ad 	return rv;
   2250   1.72  jdolecek }
   2251   1.72  jdolecek 
   2252   1.72  jdolecek /*ARGSUSED*/
   2253   1.72  jdolecek static int
   2254  1.129      yamt filt_solisten(struct knote *kn, long hint)
   2255   1.72  jdolecek {
   2256   1.72  jdolecek 	struct socket	*so;
   2257  1.160        ad 	int rv;
   2258   1.72  jdolecek 
   2259  1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2260   1.72  jdolecek 
   2261   1.72  jdolecek 	/*
   2262   1.72  jdolecek 	 * Set kn_data to number of incoming connections, not
   2263   1.72  jdolecek 	 * counting partial (incomplete) connections.
   2264  1.108     perry 	 */
   2265  1.160        ad 	if (hint != NOTE_SUBMIT)
   2266  1.160        ad 		solock(so);
   2267   1.72  jdolecek 	kn->kn_data = so->so_qlen;
   2268  1.160        ad 	rv = (kn->kn_data > 0);
   2269  1.160        ad 	if (hint != NOTE_SUBMIT)
   2270  1.160        ad 		sounlock(so);
   2271  1.160        ad 	return rv;
   2272   1.72  jdolecek }
   2273   1.72  jdolecek 
   2274   1.72  jdolecek static const struct filterops solisten_filtops =
   2275   1.72  jdolecek 	{ 1, NULL, filt_sordetach, filt_solisten };
   2276   1.72  jdolecek static const struct filterops soread_filtops =
   2277   1.72  jdolecek 	{ 1, NULL, filt_sordetach, filt_soread };
   2278   1.72  jdolecek static const struct filterops sowrite_filtops =
   2279   1.72  jdolecek 	{ 1, NULL, filt_sowdetach, filt_sowrite };
   2280   1.72  jdolecek 
   2281   1.72  jdolecek int
   2282  1.129      yamt soo_kqfilter(struct file *fp, struct knote *kn)
   2283   1.72  jdolecek {
   2284   1.72  jdolecek 	struct socket	*so;
   2285   1.72  jdolecek 	struct sockbuf	*sb;
   2286   1.72  jdolecek 
   2287  1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2288  1.160        ad 	solock(so);
   2289   1.72  jdolecek 	switch (kn->kn_filter) {
   2290   1.72  jdolecek 	case EVFILT_READ:
   2291   1.72  jdolecek 		if (so->so_options & SO_ACCEPTCONN)
   2292   1.72  jdolecek 			kn->kn_fop = &solisten_filtops;
   2293   1.72  jdolecek 		else
   2294   1.72  jdolecek 			kn->kn_fop = &soread_filtops;
   2295   1.72  jdolecek 		sb = &so->so_rcv;
   2296   1.72  jdolecek 		break;
   2297   1.72  jdolecek 	case EVFILT_WRITE:
   2298   1.72  jdolecek 		kn->kn_fop = &sowrite_filtops;
   2299   1.72  jdolecek 		sb = &so->so_snd;
   2300   1.72  jdolecek 		break;
   2301   1.72  jdolecek 	default:
   2302  1.160        ad 		sounlock(so);
   2303  1.149     pooka 		return (EINVAL);
   2304   1.72  jdolecek 	}
   2305   1.73  christos 	SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);
   2306   1.72  jdolecek 	sb->sb_flags |= SB_KNOTE;
   2307  1.160        ad 	sounlock(so);
   2308   1.72  jdolecek 	return (0);
   2309   1.72  jdolecek }
   2310   1.72  jdolecek 
   2311  1.154        ad static int
   2312  1.154        ad sodopoll(struct socket *so, int events)
   2313  1.154        ad {
   2314  1.154        ad 	int revents;
   2315  1.154        ad 
   2316  1.154        ad 	revents = 0;
   2317  1.154        ad 
   2318  1.154        ad 	if (events & (POLLIN | POLLRDNORM))
   2319  1.154        ad 		if (soreadable(so))
   2320  1.154        ad 			revents |= events & (POLLIN | POLLRDNORM);
   2321  1.154        ad 
   2322  1.154        ad 	if (events & (POLLOUT | POLLWRNORM))
   2323  1.154        ad 		if (sowritable(so))
   2324  1.154        ad 			revents |= events & (POLLOUT | POLLWRNORM);
   2325  1.154        ad 
   2326  1.154        ad 	if (events & (POLLPRI | POLLRDBAND))
   2327  1.154        ad 		if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
   2328  1.154        ad 			revents |= events & (POLLPRI | POLLRDBAND);
   2329  1.154        ad 
   2330  1.154        ad 	return revents;
   2331  1.154        ad }
   2332  1.154        ad 
   2333  1.154        ad int
   2334  1.154        ad sopoll(struct socket *so, int events)
   2335  1.154        ad {
   2336  1.154        ad 	int revents = 0;
   2337  1.154        ad 
   2338  1.160        ad #ifndef DIAGNOSTIC
   2339  1.160        ad 	/*
   2340  1.160        ad 	 * Do a quick, unlocked check in expectation that the socket
   2341  1.160        ad 	 * will be ready for I/O.  Don't do this check if DIAGNOSTIC,
   2342  1.160        ad 	 * as the solocked() assertions will fail.
   2343  1.160        ad 	 */
   2344  1.154        ad 	if ((revents = sodopoll(so, events)) != 0)
   2345  1.154        ad 		return revents;
   2346  1.160        ad #endif
   2347  1.154        ad 
   2348  1.160        ad 	solock(so);
   2349  1.154        ad 	if ((revents = sodopoll(so, events)) == 0) {
   2350  1.154        ad 		if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
   2351  1.154        ad 			selrecord(curlwp, &so->so_rcv.sb_sel);
   2352  1.160        ad 			so->so_rcv.sb_flags |= SB_NOTIFY;
   2353  1.154        ad 		}
   2354  1.154        ad 
   2355  1.154        ad 		if (events & (POLLOUT | POLLWRNORM)) {
   2356  1.154        ad 			selrecord(curlwp, &so->so_snd.sb_sel);
   2357  1.160        ad 			so->so_snd.sb_flags |= SB_NOTIFY;
   2358  1.154        ad 		}
   2359  1.154        ad 	}
   2360  1.160        ad 	sounlock(so);
   2361  1.154        ad 
   2362  1.154        ad 	return revents;
   2363  1.154        ad }
   2364  1.154        ad 
   2365  1.154        ad 
   2366   1.94      yamt #include <sys/sysctl.h>
   2367   1.94      yamt 
   2368   1.94      yamt static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);
   2369   1.94      yamt 
   2370   1.94      yamt /*
   2371   1.94      yamt  * sysctl helper routine for kern.somaxkva.  ensures that the given
   2372   1.94      yamt  * value is not too small.
   2373   1.94      yamt  * (XXX should we maybe make sure it's not too large as well?)
   2374   1.94      yamt  */
   2375   1.94      yamt static int
   2376   1.94      yamt sysctl_kern_somaxkva(SYSCTLFN_ARGS)
   2377   1.94      yamt {
   2378   1.94      yamt 	int error, new_somaxkva;
   2379   1.94      yamt 	struct sysctlnode node;
   2380   1.94      yamt 
   2381   1.94      yamt 	new_somaxkva = somaxkva;
   2382   1.94      yamt 	node = *rnode;
   2383   1.94      yamt 	node.sysctl_data = &new_somaxkva;
   2384   1.94      yamt 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   2385   1.94      yamt 	if (error || newp == NULL)
   2386   1.94      yamt 		return (error);
   2387   1.94      yamt 
   2388   1.94      yamt 	if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */
   2389   1.94      yamt 		return (EINVAL);
   2390   1.94      yamt 
   2391  1.136        ad 	mutex_enter(&so_pendfree_lock);
   2392   1.94      yamt 	somaxkva = new_somaxkva;
   2393  1.136        ad 	cv_broadcast(&socurkva_cv);
   2394  1.136        ad 	mutex_exit(&so_pendfree_lock);
   2395   1.94      yamt 
   2396   1.94      yamt 	return (error);
   2397   1.94      yamt }
   2398   1.94      yamt 
   2399  1.178     pooka static void
   2400  1.187    cegger sysctl_kern_somaxkva_setup(void)
   2401   1.94      yamt {
   2402   1.94      yamt 
   2403  1.178     pooka 	KASSERT(socket_sysctllog == NULL);
   2404  1.178     pooka 	sysctl_createv(&socket_sysctllog, 0, NULL, NULL,
   2405   1.97    atatat 		       CTLFLAG_PERMANENT,
   2406   1.97    atatat 		       CTLTYPE_NODE, "kern", NULL,
   2407   1.97    atatat 		       NULL, 0, NULL, 0,
   2408   1.97    atatat 		       CTL_KERN, CTL_EOL);
   2409   1.97    atatat 
   2410  1.178     pooka 	sysctl_createv(&socket_sysctllog, 0, NULL, NULL,
   2411   1.97    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2412  1.103    atatat 		       CTLTYPE_INT, "somaxkva",
   2413  1.103    atatat 		       SYSCTL_DESCR("Maximum amount of kernel memory to be "
   2414  1.103    atatat 				    "used for socket buffers"),
   2415   1.94      yamt 		       sysctl_kern_somaxkva, 0, NULL, 0,
   2416   1.94      yamt 		       CTL_KERN, KERN_SOMAXKVA, CTL_EOL);
   2417   1.94      yamt }
   2418