xref: /freebsd/sys/kern/uipc_usrreq.c (revision 4f590175b7f3a4efecdd28ffd3306d30724d32c9)
19454b2d8SWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3e1ac28e2SRobert Watson  *	The Regents of the University of California.
44d4b555eSRobert Watson  * Copyright 2004-2006 Robert N. M. Watson
5e1ac28e2SRobert Watson  * All rights reserved.
6df8bae1dSRodney W. Grimes  *
7df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
8df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
9df8bae1dSRodney W. Grimes  * are met:
10df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
12df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
13df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
14df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
15df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
16df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
17df8bae1dSRodney W. Grimes  *    without specific prior written permission.
18df8bae1dSRodney W. Grimes  *
19df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
30df8bae1dSRodney W. Grimes  *
31748e0b0aSGarrett Wollman  *	From: @(#)uipc_usrreq.c	8.3 (Berkeley) 1/4/94
32df8bae1dSRodney W. Grimes  */
33df8bae1dSRodney W. Grimes 
34677b542eSDavid E. O'Brien #include <sys/cdefs.h>
35677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
36677b542eSDavid E. O'Brien 
37335654d7SRobert Watson #include "opt_mac.h"
38335654d7SRobert Watson 
39df8bae1dSRodney W. Grimes #include <sys/param.h>
40fb919e4dSMark Murray #include <sys/domain.h>
41960ed29cSSeigo Tanimura #include <sys/fcntl.h>
42d826c479SBruce Evans #include <sys/malloc.h>		/* XXX must be before <sys/file.h> */
434f590175SPaul Saab #include <sys/eventhandler.h>
44639acc13SGarrett Wollman #include <sys/file.h>
45960ed29cSSeigo Tanimura #include <sys/filedesc.h>
46960ed29cSSeigo Tanimura #include <sys/jail.h>
47960ed29cSSeigo Tanimura #include <sys/kernel.h>
48960ed29cSSeigo Tanimura #include <sys/lock.h>
496ea48a90SRobert Watson #include <sys/mac.h>
50639acc13SGarrett Wollman #include <sys/mbuf.h>
51033eb86eSJeff Roberson #include <sys/mount.h>
52960ed29cSSeigo Tanimura #include <sys/mutex.h>
53639acc13SGarrett Wollman #include <sys/namei.h>
54639acc13SGarrett Wollman #include <sys/proc.h>
55df8bae1dSRodney W. Grimes #include <sys/protosw.h>
56960ed29cSSeigo Tanimura #include <sys/resourcevar.h>
57df8bae1dSRodney W. Grimes #include <sys/socket.h>
58df8bae1dSRodney W. Grimes #include <sys/socketvar.h>
59960ed29cSSeigo Tanimura #include <sys/signalvar.h>
60df8bae1dSRodney W. Grimes #include <sys/stat.h>
61960ed29cSSeigo Tanimura #include <sys/sx.h>
62639acc13SGarrett Wollman #include <sys/sysctl.h>
63960ed29cSSeigo Tanimura #include <sys/systm.h>
64a0ec558aSRobert Watson #include <sys/taskqueue.h>
65639acc13SGarrett Wollman #include <sys/un.h>
6698271db4SGarrett Wollman #include <sys/unpcb.h>
67639acc13SGarrett Wollman #include <sys/vnode.h>
68df8bae1dSRodney W. Grimes 
699e9d298aSJeff Roberson #include <vm/uma.h>
7098271db4SGarrett Wollman 
719e9d298aSJeff Roberson static uma_zone_t unp_zone;
7298271db4SGarrett Wollman static	unp_gen_t unp_gencnt;
7398271db4SGarrett Wollman static	u_int unp_count;
7498271db4SGarrett Wollman 
7598271db4SGarrett Wollman static	struct unp_head unp_shead, unp_dhead;
7698271db4SGarrett Wollman 
77df8bae1dSRodney W. Grimes /*
78df8bae1dSRodney W. Grimes  * Unix communications domain.
79df8bae1dSRodney W. Grimes  *
80df8bae1dSRodney W. Grimes  * TODO:
81df8bae1dSRodney W. Grimes  *	SEQPACKET, RDM
82df8bae1dSRodney W. Grimes  *	rethink name space problems
83df8bae1dSRodney W. Grimes  *	need a proper out-of-band
8498271db4SGarrett Wollman  *	lock pushdown
85df8bae1dSRodney W. Grimes  */
86e7dd9a10SRobert Watson static const struct	sockaddr sun_noname = { sizeof(sun_noname), AF_LOCAL };
87f708ef1bSPoul-Henning Kamp static ino_t	unp_ino;		/* prototype for fake inode numbers */
886a2989fdSMatthew N. Dodd struct mbuf *unp_addsockcred(struct thread *, struct mbuf *);
89f708ef1bSPoul-Henning Kamp 
90ce5f32deSRobert Watson /*
91ce5f32deSRobert Watson  * Currently, UNIX domain sockets are protected by a single subsystem lock,
92ce5f32deSRobert Watson  * which covers global data structures and variables, the contents of each
93ce5f32deSRobert Watson  * per-socket unpcb structure, and the so_pcb field in sockets attached to
94ce5f32deSRobert Watson  * the UNIX domain.  This provides for a moderate degree of paralellism, as
95ce5f32deSRobert Watson  * receive operations on UNIX domain sockets do not need to acquire the
96ce5f32deSRobert Watson  * subsystem lock.  Finer grained locking to permit send() without acquiring
97ce5f32deSRobert Watson  * a global lock would be a logical next step.
98ce5f32deSRobert Watson  *
99ce5f32deSRobert Watson  * The UNIX domain socket lock preceds all socket layer locks, including the
100ce5f32deSRobert Watson  * socket lock and socket buffer lock, permitting UNIX domain socket code to
101ce5f32deSRobert Watson  * call into socket support routines without releasing its locks.
102ce5f32deSRobert Watson  *
103ce5f32deSRobert Watson  * Some caution is required in areas where the UNIX domain socket code enters
104ce5f32deSRobert Watson  * VFS in order to create or find rendezvous points.  This results in
105ce5f32deSRobert Watson  * dropping of the UNIX domain socket subsystem lock, acquisition of the
106ce5f32deSRobert Watson  * Giant lock, and potential sleeping.  This increases the chances of races,
107ce5f32deSRobert Watson  * and exposes weaknesses in the socket->protocol API by offering poor
108ce5f32deSRobert Watson  * failure modes.
109ce5f32deSRobert Watson  */
1100d9ce3a1SRobert Watson static struct mtx unp_mtx;
1110d9ce3a1SRobert Watson #define	UNP_LOCK_INIT() \
1120d9ce3a1SRobert Watson 	mtx_init(&unp_mtx, "unp", NULL, MTX_DEF)
1130d9ce3a1SRobert Watson #define	UNP_LOCK()		mtx_lock(&unp_mtx)
1140d9ce3a1SRobert Watson #define	UNP_UNLOCK()		mtx_unlock(&unp_mtx)
1150d9ce3a1SRobert Watson #define	UNP_LOCK_ASSERT()	mtx_assert(&unp_mtx, MA_OWNED)
1164c5bc1caSRobert Watson #define	UNP_UNLOCK_ASSERT()	mtx_assert(&unp_mtx, MA_NOTOWNED)
1170d9ce3a1SRobert Watson 
118a0ec558aSRobert Watson /*
119a0ec558aSRobert Watson  * Garbage collection of cyclic file descriptor/socket references occurs
120a0ec558aSRobert Watson  * asynchronously in a taskqueue context in order to avoid recursion and
121a0ec558aSRobert Watson  * reentrance in the UNIX domain socket, file descriptor, and socket layer
122a0ec558aSRobert Watson  * code.  See unp_gc() for a full description.
123a0ec558aSRobert Watson  */
124a0ec558aSRobert Watson static struct task	unp_gc_task;
125a0ec558aSRobert Watson 
1264d77a549SAlfred Perlstein static int     unp_attach(struct socket *);
1274d77a549SAlfred Perlstein static void    unp_detach(struct unpcb *);
1284d77a549SAlfred Perlstein static int     unp_bind(struct unpcb *,struct sockaddr *, struct thread *);
12970f52b48SBruce Evans static int     unp_connect(struct socket *,struct sockaddr *, struct thread *);
1306a2989fdSMatthew N. Dodd static int     unp_connect2(struct socket *so, struct socket *so2, int);
1314d77a549SAlfred Perlstein static void    unp_disconnect(struct unpcb *);
1324d77a549SAlfred Perlstein static void    unp_shutdown(struct unpcb *);
1334d77a549SAlfred Perlstein static void    unp_drop(struct unpcb *, int);
134a0ec558aSRobert Watson static void    unp_gc(__unused void *, int);
1354d77a549SAlfred Perlstein static void    unp_scan(struct mbuf *, void (*)(struct file *));
1364d77a549SAlfred Perlstein static void    unp_mark(struct file *);
1374d77a549SAlfred Perlstein static void    unp_discard(struct file *);
1384d77a549SAlfred Perlstein static void    unp_freerights(struct file **, int);
1394d77a549SAlfred Perlstein static int     unp_internalize(struct mbuf **, struct thread *);
140d374e81eSRobert Watson static int     unp_listen(struct socket *, struct unpcb *, int,
141d374e81eSRobert Watson 		   struct thread *);
142f708ef1bSPoul-Henning Kamp 
143ac45e92fSRobert Watson static void
144a29f300eSGarrett Wollman uipc_abort(struct socket *so)
145df8bae1dSRodney W. Grimes {
14640f2ac28SRobert Watson 	struct unpcb *unp;
147df8bae1dSRodney W. Grimes 
14840f2ac28SRobert Watson 	unp = sotounpcb(so);
1494d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_abort: unp == NULL"));
1504d4b555eSRobert Watson 	UNP_LOCK();
151a29f300eSGarrett Wollman 	unp_drop(unp, ECONNABORTED);
1524c5bc1caSRobert Watson 	unp_detach(unp);
1534c5bc1caSRobert Watson 	UNP_UNLOCK_ASSERT();
154df8bae1dSRodney W. Grimes }
155df8bae1dSRodney W. Grimes 
156a29f300eSGarrett Wollman static int
15757bf258eSGarrett Wollman uipc_accept(struct socket *so, struct sockaddr **nam)
158a29f300eSGarrett Wollman {
15940f2ac28SRobert Watson 	struct unpcb *unp;
1600d9ce3a1SRobert Watson 	const struct sockaddr *sa;
161df8bae1dSRodney W. Grimes 
162df8bae1dSRodney W. Grimes 	/*
163df8bae1dSRodney W. Grimes 	 * Pass back name of connected socket,
164df8bae1dSRodney W. Grimes 	 * if it was bound and we are still connected
165df8bae1dSRodney W. Grimes 	 * (our peer may have closed already!).
166df8bae1dSRodney W. Grimes 	 */
1674d4b555eSRobert Watson 	unp = sotounpcb(so);
1684d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_accept: unp == NULL"));
1690d9ce3a1SRobert Watson 	*nam = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
1700d9ce3a1SRobert Watson 	UNP_LOCK();
1710d9ce3a1SRobert Watson 	if (unp->unp_conn != NULL && unp->unp_conn->unp_addr != NULL)
1720d9ce3a1SRobert Watson 		sa = (struct sockaddr *) unp->unp_conn->unp_addr;
1730d9ce3a1SRobert Watson 	else
1740d9ce3a1SRobert Watson 		sa = &sun_noname;
1750d9ce3a1SRobert Watson 	bcopy(sa, *nam, sa->sa_len);
1760d9ce3a1SRobert Watson 	UNP_UNLOCK();
177e5aeaa0cSDag-Erling Smørgrav 	return (0);
178a29f300eSGarrett Wollman }
179df8bae1dSRodney W. Grimes 
180a29f300eSGarrett Wollman static int
181b40ce416SJulian Elischer uipc_attach(struct socket *so, int proto, struct thread *td)
182a29f300eSGarrett Wollman {
183df8bae1dSRodney W. Grimes 
184e5aeaa0cSDag-Erling Smørgrav 	return (unp_attach(so));
185a29f300eSGarrett Wollman }
186a29f300eSGarrett Wollman 
187a29f300eSGarrett Wollman static int
188b40ce416SJulian Elischer uipc_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
189a29f300eSGarrett Wollman {
19040f2ac28SRobert Watson 	struct unpcb *unp;
19140f2ac28SRobert Watson 	int error;
192a29f300eSGarrett Wollman 
19340f2ac28SRobert Watson 	unp = sotounpcb(so);
1944d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_bind: unp == NULL"));
1954d4b555eSRobert Watson 	UNP_LOCK();
19640f2ac28SRobert Watson 	error = unp_bind(unp, nam, td);
19740f2ac28SRobert Watson 	UNP_UNLOCK();
19840f2ac28SRobert Watson 	return (error);
199a29f300eSGarrett Wollman }
200a29f300eSGarrett Wollman 
201a29f300eSGarrett Wollman static int
202b40ce416SJulian Elischer uipc_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
203a29f300eSGarrett Wollman {
204b295bdcdSRobert Watson 	struct unpcb *unp;
2050d9ce3a1SRobert Watson 	int error;
206a29f300eSGarrett Wollman 
207fd179ee9SRobert Watson 	KASSERT(td == curthread, ("uipc_connect: td != curthread"));
208b295bdcdSRobert Watson 	unp = sotounpcb(so);
2094d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_connect: unp == NULL"));
2104d4b555eSRobert Watson 	UNP_LOCK();
211fd179ee9SRobert Watson 	error = unp_connect(so, nam, td);
2120d9ce3a1SRobert Watson 	UNP_UNLOCK();
2130d9ce3a1SRobert Watson 	return (error);
214a29f300eSGarrett Wollman }
215a29f300eSGarrett Wollman 
216db48c0d2SRobert Watson int
217a29f300eSGarrett Wollman uipc_connect2(struct socket *so1, struct socket *so2)
218a29f300eSGarrett Wollman {
21940f2ac28SRobert Watson 	struct unpcb *unp;
2200d9ce3a1SRobert Watson 	int error;
221a29f300eSGarrett Wollman 
22240f2ac28SRobert Watson 	unp = sotounpcb(so1);
2234d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_connect2: unp == NULL"));
2244d4b555eSRobert Watson 	UNP_LOCK();
2256a2989fdSMatthew N. Dodd 	error = unp_connect2(so1, so2, PRU_CONNECT2);
2260d9ce3a1SRobert Watson 	UNP_UNLOCK();
2270d9ce3a1SRobert Watson 	return (error);
228a29f300eSGarrett Wollman }
229a29f300eSGarrett Wollman 
230a29f300eSGarrett Wollman /* control is EOPNOTSUPP */
231a29f300eSGarrett Wollman 
232bc725eafSRobert Watson static void
233a29f300eSGarrett Wollman uipc_detach(struct socket *so)
234a29f300eSGarrett Wollman {
23540f2ac28SRobert Watson 	struct unpcb *unp;
236a29f300eSGarrett Wollman 
23740f2ac28SRobert Watson 	unp = sotounpcb(so);
2384d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_detach: unp == NULL"));
2394d4b555eSRobert Watson 	UNP_LOCK();
2404c5bc1caSRobert Watson 	unp_detach(unp);
2414c5bc1caSRobert Watson 	UNP_UNLOCK_ASSERT();
242a29f300eSGarrett Wollman }
243a29f300eSGarrett Wollman 
244a29f300eSGarrett Wollman static int
245a29f300eSGarrett Wollman uipc_disconnect(struct socket *so)
246a29f300eSGarrett Wollman {
24740f2ac28SRobert Watson 	struct unpcb *unp;
248a29f300eSGarrett Wollman 
24940f2ac28SRobert Watson 	unp = sotounpcb(so);
2504d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_disconnect: unp == NULL"));
2514d4b555eSRobert Watson 	UNP_LOCK();
252a29f300eSGarrett Wollman 	unp_disconnect(unp);
2530d9ce3a1SRobert Watson 	UNP_UNLOCK();
254e5aeaa0cSDag-Erling Smørgrav 	return (0);
255a29f300eSGarrett Wollman }
256a29f300eSGarrett Wollman 
257a29f300eSGarrett Wollman static int
258d374e81eSRobert Watson uipc_listen(struct socket *so, int backlog, struct thread *td)
259a29f300eSGarrett Wollman {
26040f2ac28SRobert Watson 	struct unpcb *unp;
2610d9ce3a1SRobert Watson 	int error;
262a29f300eSGarrett Wollman 
26340f2ac28SRobert Watson 	unp = sotounpcb(so);
2644d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_listen: unp == NULL"));
2654d4b555eSRobert Watson 	UNP_LOCK();
2664d4b555eSRobert Watson 	if (unp->unp_vnode == NULL) {
26740f2ac28SRobert Watson 		UNP_UNLOCK();
26840f2ac28SRobert Watson 		return (EINVAL);
26940f2ac28SRobert Watson 	}
270d374e81eSRobert Watson 	error = unp_listen(so, unp, backlog, td);
2710d9ce3a1SRobert Watson 	UNP_UNLOCK();
2720d9ce3a1SRobert Watson 	return (error);
273a29f300eSGarrett Wollman }
274a29f300eSGarrett Wollman 
275a29f300eSGarrett Wollman static int
27657bf258eSGarrett Wollman uipc_peeraddr(struct socket *so, struct sockaddr **nam)
277a29f300eSGarrett Wollman {
27840f2ac28SRobert Watson 	struct unpcb *unp;
2790d9ce3a1SRobert Watson 	const struct sockaddr *sa;
280a29f300eSGarrett Wollman 
2814d4b555eSRobert Watson 	unp = sotounpcb(so);
2824d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_peeraddr: unp == NULL"));
2830d9ce3a1SRobert Watson 	*nam = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
2840d9ce3a1SRobert Watson 	UNP_LOCK();
285fc3fcacfSRobert Watson 	if (unp->unp_conn != NULL && unp->unp_conn->unp_addr!= NULL)
2860d9ce3a1SRobert Watson 		sa = (struct sockaddr *) unp->unp_conn->unp_addr;
287bdc5f6a3SHajimu UMEMOTO 	else {
288bdc5f6a3SHajimu UMEMOTO 		/*
289bdc5f6a3SHajimu UMEMOTO 		 * XXX: It seems that this test always fails even when
290bdc5f6a3SHajimu UMEMOTO 		 * connection is established.  So, this else clause is
291bdc5f6a3SHajimu UMEMOTO 		 * added as workaround to return PF_LOCAL sockaddr.
292bdc5f6a3SHajimu UMEMOTO 		 */
2930d9ce3a1SRobert Watson 		sa = &sun_noname;
294bdc5f6a3SHajimu UMEMOTO 	}
2950d9ce3a1SRobert Watson 	bcopy(sa, *nam, sa->sa_len);
2960d9ce3a1SRobert Watson 	UNP_UNLOCK();
297e5aeaa0cSDag-Erling Smørgrav 	return (0);
298a29f300eSGarrett Wollman }
299a29f300eSGarrett Wollman 
300a29f300eSGarrett Wollman static int
301a29f300eSGarrett Wollman uipc_rcvd(struct socket *so, int flags)
302a29f300eSGarrett Wollman {
30340f2ac28SRobert Watson 	struct unpcb *unp;
304a29f300eSGarrett Wollman 	struct socket *so2;
3056aef685fSBrian Feldman 	u_long newhiwat;
306a29f300eSGarrett Wollman 
30740f2ac28SRobert Watson 	unp = sotounpcb(so);
3084d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_rcvd: unp == NULL"));
3094d4b555eSRobert Watson 	UNP_LOCK();
310df8bae1dSRodney W. Grimes 	switch (so->so_type) {
311df8bae1dSRodney W. Grimes 	case SOCK_DGRAM:
312a29f300eSGarrett Wollman 		panic("uipc_rcvd DGRAM?");
313df8bae1dSRodney W. Grimes 		/*NOTREACHED*/
314df8bae1dSRodney W. Grimes 
315df8bae1dSRodney W. Grimes 	case SOCK_STREAM:
316fc3fcacfSRobert Watson 		if (unp->unp_conn == NULL)
317df8bae1dSRodney W. Grimes 			break;
318df8bae1dSRodney W. Grimes 		so2 = unp->unp_conn->unp_socket;
319c9f69064SRobert Watson 		SOCKBUF_LOCK(&so2->so_snd);
320c9f69064SRobert Watson 		SOCKBUF_LOCK(&so->so_rcv);
321df8bae1dSRodney W. Grimes 		/*
322df8bae1dSRodney W. Grimes 		 * Adjust backpressure on sender
323df8bae1dSRodney W. Grimes 		 * and wakeup any waiting to write.
324df8bae1dSRodney W. Grimes 		 */
325ff8b0106SBrian Feldman 		so2->so_snd.sb_mbmax += unp->unp_mbcnt - so->so_rcv.sb_mbcnt;
326ff8b0106SBrian Feldman 		unp->unp_mbcnt = so->so_rcv.sb_mbcnt;
3276aef685fSBrian Feldman 		newhiwat = so2->so_snd.sb_hiwat + unp->unp_cc -
3286aef685fSBrian Feldman 		    so->so_rcv.sb_cc;
329f535380cSDon Lewis 		(void)chgsbsize(so2->so_cred->cr_uidinfo, &so2->so_snd.sb_hiwat,
3306aef685fSBrian Feldman 		    newhiwat, RLIM_INFINITY);
331ff8b0106SBrian Feldman 		unp->unp_cc = so->so_rcv.sb_cc;
332c9f69064SRobert Watson 		SOCKBUF_UNLOCK(&so->so_rcv);
3331e4d7da7SRobert Watson 		sowwakeup_locked(so2);
334df8bae1dSRodney W. Grimes 		break;
335df8bae1dSRodney W. Grimes 
336df8bae1dSRodney W. Grimes 	default:
337a29f300eSGarrett Wollman 		panic("uipc_rcvd unknown socktype");
338df8bae1dSRodney W. Grimes 	}
3390d9ce3a1SRobert Watson 	UNP_UNLOCK();
340e5aeaa0cSDag-Erling Smørgrav 	return (0);
341a29f300eSGarrett Wollman }
342df8bae1dSRodney W. Grimes 
343a29f300eSGarrett Wollman /* pru_rcvoob is EOPNOTSUPP */
344a29f300eSGarrett Wollman 
345a29f300eSGarrett Wollman static int
34657bf258eSGarrett Wollman uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
347b40ce416SJulian Elischer     struct mbuf *control, struct thread *td)
348a29f300eSGarrett Wollman {
349a29f300eSGarrett Wollman 	int error = 0;
35040f2ac28SRobert Watson 	struct unpcb *unp;
351a29f300eSGarrett Wollman 	struct socket *so2;
3526aef685fSBrian Feldman 	u_long newhiwat;
353a29f300eSGarrett Wollman 
35440f2ac28SRobert Watson 	unp = sotounpcb(so);
3554d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_send: unp == NULL"));
356a29f300eSGarrett Wollman 	if (flags & PRUS_OOB) {
357a29f300eSGarrett Wollman 		error = EOPNOTSUPP;
358a29f300eSGarrett Wollman 		goto release;
359a29f300eSGarrett Wollman 	}
360a29f300eSGarrett Wollman 
361fc3fcacfSRobert Watson 	if (control != NULL && (error = unp_internalize(&control, td)))
362a29f300eSGarrett Wollman 		goto release;
363df8bae1dSRodney W. Grimes 
3640d9ce3a1SRobert Watson 	UNP_LOCK();
365a29f300eSGarrett Wollman 	switch (so->so_type) {
366a29f300eSGarrett Wollman 	case SOCK_DGRAM:
367a29f300eSGarrett Wollman 	{
368e7dd9a10SRobert Watson 		const struct sockaddr *from;
369df8bae1dSRodney W. Grimes 
370fc3fcacfSRobert Watson 		if (nam != NULL) {
371fc3fcacfSRobert Watson 			if (unp->unp_conn != NULL) {
372df8bae1dSRodney W. Grimes 				error = EISCONN;
373df8bae1dSRodney W. Grimes 				break;
374df8bae1dSRodney W. Grimes 			}
375b40ce416SJulian Elischer 			error = unp_connect(so, nam, td);
376df8bae1dSRodney W. Grimes 			if (error)
377df8bae1dSRodney W. Grimes 				break;
378df8bae1dSRodney W. Grimes 		} else {
379fc3fcacfSRobert Watson 			if (unp->unp_conn == NULL) {
380df8bae1dSRodney W. Grimes 				error = ENOTCONN;
381df8bae1dSRodney W. Grimes 				break;
382df8bae1dSRodney W. Grimes 			}
383df8bae1dSRodney W. Grimes 		}
384df8bae1dSRodney W. Grimes 		so2 = unp->unp_conn->unp_socket;
385fc3fcacfSRobert Watson 		if (unp->unp_addr != NULL)
38657bf258eSGarrett Wollman 			from = (struct sockaddr *)unp->unp_addr;
387df8bae1dSRodney W. Grimes 		else
388df8bae1dSRodney W. Grimes 			from = &sun_noname;
3896a2989fdSMatthew N. Dodd 		if (unp->unp_conn->unp_flags & UNP_WANTCRED)
3906a2989fdSMatthew N. Dodd 			control = unp_addsockcred(td, control);
391a34b7046SRobert Watson 		SOCKBUF_LOCK(&so2->so_rcv);
392a34b7046SRobert Watson 		if (sbappendaddr_locked(&so2->so_rcv, from, m, control)) {
3931e4d7da7SRobert Watson 			sorwakeup_locked(so2);
394fc3fcacfSRobert Watson 			m = NULL;
395fc3fcacfSRobert Watson 			control = NULL;
396e5aeaa0cSDag-Erling Smørgrav 		} else {
397a34b7046SRobert Watson 			SOCKBUF_UNLOCK(&so2->so_rcv);
398df8bae1dSRodney W. Grimes 			error = ENOBUFS;
399e5aeaa0cSDag-Erling Smørgrav 		}
400fc3fcacfSRobert Watson 		if (nam != NULL)
401df8bae1dSRodney W. Grimes 			unp_disconnect(unp);
402df8bae1dSRodney W. Grimes 		break;
403df8bae1dSRodney W. Grimes 	}
404df8bae1dSRodney W. Grimes 
405df8bae1dSRodney W. Grimes 	case SOCK_STREAM:
4066b8fda4dSGarrett Wollman 		/* Connect if not connected yet. */
4076b8fda4dSGarrett Wollman 		/*
4086b8fda4dSGarrett Wollman 		 * Note: A better implementation would complain
409402cc72dSDavid Greenman 		 * if not equal to the peer's address.
4106b8fda4dSGarrett Wollman 		 */
411402cc72dSDavid Greenman 		if ((so->so_state & SS_ISCONNECTED) == 0) {
412fc3fcacfSRobert Watson 			if (nam != NULL) {
413b40ce416SJulian Elischer 				error = unp_connect(so, nam, td);
414402cc72dSDavid Greenman 				if (error)
4156b8fda4dSGarrett Wollman 					break;	/* XXX */
416402cc72dSDavid Greenman 			} else {
417402cc72dSDavid Greenman 				error = ENOTCONN;
418402cc72dSDavid Greenman 				break;
419402cc72dSDavid Greenman 			}
420402cc72dSDavid Greenman 		}
421402cc72dSDavid Greenman 
4227abe2ac2SAlan Cox 		SOCKBUF_LOCK(&so->so_snd);
423c0b99ffaSRobert Watson 		if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
4247abe2ac2SAlan Cox 			SOCKBUF_UNLOCK(&so->so_snd);
425df8bae1dSRodney W. Grimes 			error = EPIPE;
426df8bae1dSRodney W. Grimes 			break;
427df8bae1dSRodney W. Grimes 		}
428fc3fcacfSRobert Watson 		if (unp->unp_conn == NULL)
429a29f300eSGarrett Wollman 			panic("uipc_send connected but no connection?");
430df8bae1dSRodney W. Grimes 		so2 = unp->unp_conn->unp_socket;
431a34b7046SRobert Watson 		SOCKBUF_LOCK(&so2->so_rcv);
4326a2989fdSMatthew N. Dodd 		if (unp->unp_conn->unp_flags & UNP_WANTCRED) {
4336a2989fdSMatthew N. Dodd 			/*
4346a2989fdSMatthew N. Dodd 			 * Credentials are passed only once on
4356a2989fdSMatthew N. Dodd 			 * SOCK_STREAM.
4366a2989fdSMatthew N. Dodd 			 */
4376a2989fdSMatthew N. Dodd 			unp->unp_conn->unp_flags &= ~UNP_WANTCRED;
4386a2989fdSMatthew N. Dodd 			control = unp_addsockcred(td, control);
4396a2989fdSMatthew N. Dodd 		}
440df8bae1dSRodney W. Grimes 		/*
441df8bae1dSRodney W. Grimes 		 * Send to paired receive port, and then reduce
442df8bae1dSRodney W. Grimes 		 * send buffer hiwater marks to maintain backpressure.
443df8bae1dSRodney W. Grimes 		 * Wake up readers.
444df8bae1dSRodney W. Grimes 		 */
445fc3fcacfSRobert Watson 		if (control != NULL) {
446a34b7046SRobert Watson 			if (sbappendcontrol_locked(&so2->so_rcv, m, control))
447fc3fcacfSRobert Watson 				control = NULL;
448e5aeaa0cSDag-Erling Smørgrav 		} else {
449a34b7046SRobert Watson 			sbappend_locked(&so2->so_rcv, m);
450e5aeaa0cSDag-Erling Smørgrav 		}
451ff8b0106SBrian Feldman 		so->so_snd.sb_mbmax -=
452ff8b0106SBrian Feldman 			so2->so_rcv.sb_mbcnt - unp->unp_conn->unp_mbcnt;
453ff8b0106SBrian Feldman 		unp->unp_conn->unp_mbcnt = so2->so_rcv.sb_mbcnt;
4546aef685fSBrian Feldman 		newhiwat = so->so_snd.sb_hiwat -
4556aef685fSBrian Feldman 		    (so2->so_rcv.sb_cc - unp->unp_conn->unp_cc);
456f535380cSDon Lewis 		(void)chgsbsize(so->so_cred->cr_uidinfo, &so->so_snd.sb_hiwat,
4576aef685fSBrian Feldman 		    newhiwat, RLIM_INFINITY);
4587abe2ac2SAlan Cox 		SOCKBUF_UNLOCK(&so->so_snd);
459ff8b0106SBrian Feldman 		unp->unp_conn->unp_cc = so2->so_rcv.sb_cc;
4601e4d7da7SRobert Watson 		sorwakeup_locked(so2);
461fc3fcacfSRobert Watson 		m = NULL;
462df8bae1dSRodney W. Grimes 		break;
463df8bae1dSRodney W. Grimes 
464df8bae1dSRodney W. Grimes 	default:
465a29f300eSGarrett Wollman 		panic("uipc_send unknown socktype");
466df8bae1dSRodney W. Grimes 	}
467a29f300eSGarrett Wollman 
4686b8fda4dSGarrett Wollman 	/*
4696b8fda4dSGarrett Wollman 	 * SEND_EOF is equivalent to a SEND followed by
4706b8fda4dSGarrett Wollman 	 * a SHUTDOWN.
4716b8fda4dSGarrett Wollman 	 */
472a29f300eSGarrett Wollman 	if (flags & PRUS_EOF) {
4736b8fda4dSGarrett Wollman 		socantsendmore(so);
4746b8fda4dSGarrett Wollman 		unp_shutdown(unp);
4756b8fda4dSGarrett Wollman 	}
4760d9ce3a1SRobert Watson 	UNP_UNLOCK();
477df8bae1dSRodney W. Grimes 
478fc3fcacfSRobert Watson 	if (control != NULL && error != 0)
479bd508d39SDon Lewis 		unp_dispose(control);
480bd508d39SDon Lewis 
481a29f300eSGarrett Wollman release:
482fc3fcacfSRobert Watson 	if (control != NULL)
483a29f300eSGarrett Wollman 		m_freem(control);
484fc3fcacfSRobert Watson 	if (m != NULL)
485a29f300eSGarrett Wollman 		m_freem(m);
486e5aeaa0cSDag-Erling Smørgrav 	return (error);
487a29f300eSGarrett Wollman }
488df8bae1dSRodney W. Grimes 
489a29f300eSGarrett Wollman static int
490a29f300eSGarrett Wollman uipc_sense(struct socket *so, struct stat *sb)
491a29f300eSGarrett Wollman {
49240f2ac28SRobert Watson 	struct unpcb *unp;
493a29f300eSGarrett Wollman 	struct socket *so2;
494a29f300eSGarrett Wollman 
49540f2ac28SRobert Watson 	unp = sotounpcb(so);
4964d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_sense: unp == NULL"));
4974d4b555eSRobert Watson 	UNP_LOCK();
498a29f300eSGarrett Wollman 	sb->st_blksize = so->so_snd.sb_hiwat;
499fc3fcacfSRobert Watson 	if (so->so_type == SOCK_STREAM && unp->unp_conn != NULL) {
500df8bae1dSRodney W. Grimes 		so2 = unp->unp_conn->unp_socket;
501a29f300eSGarrett Wollman 		sb->st_blksize += so2->so_rcv.sb_cc;
502df8bae1dSRodney W. Grimes 	}
503f3732fd1SPoul-Henning Kamp 	sb->st_dev = NODEV;
504df8bae1dSRodney W. Grimes 	if (unp->unp_ino == 0)
5056f782c46SJeffrey Hsu 		unp->unp_ino = (++unp_ino == 0) ? ++unp_ino : unp_ino;
506a29f300eSGarrett Wollman 	sb->st_ino = unp->unp_ino;
5070d9ce3a1SRobert Watson 	UNP_UNLOCK();
508df8bae1dSRodney W. Grimes 	return (0);
509a29f300eSGarrett Wollman }
510df8bae1dSRodney W. Grimes 
511a29f300eSGarrett Wollman static int
512a29f300eSGarrett Wollman uipc_shutdown(struct socket *so)
513a29f300eSGarrett Wollman {
51440f2ac28SRobert Watson 	struct unpcb *unp;
515df8bae1dSRodney W. Grimes 
51640f2ac28SRobert Watson 	unp = sotounpcb(so);
5174d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_shutdown: unp == NULL"));
5184d4b555eSRobert Watson 	UNP_LOCK();
519a29f300eSGarrett Wollman 	socantsendmore(so);
520a29f300eSGarrett Wollman 	unp_shutdown(unp);
5210d9ce3a1SRobert Watson 	UNP_UNLOCK();
522e5aeaa0cSDag-Erling Smørgrav 	return (0);
523a29f300eSGarrett Wollman }
524df8bae1dSRodney W. Grimes 
525a29f300eSGarrett Wollman static int
52657bf258eSGarrett Wollman uipc_sockaddr(struct socket *so, struct sockaddr **nam)
527a29f300eSGarrett Wollman {
52840f2ac28SRobert Watson 	struct unpcb *unp;
5290d9ce3a1SRobert Watson 	const struct sockaddr *sa;
530a29f300eSGarrett Wollman 
5314d4b555eSRobert Watson 	unp = sotounpcb(so);
5324d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_sockaddr: unp == NULL"));
5330d9ce3a1SRobert Watson 	*nam = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
5340d9ce3a1SRobert Watson 	UNP_LOCK();
535fc3fcacfSRobert Watson 	if (unp->unp_addr != NULL)
5360d9ce3a1SRobert Watson 		sa = (struct sockaddr *) unp->unp_addr;
53783f3198bSThomas Moestl 	else
5380d9ce3a1SRobert Watson 		sa = &sun_noname;
5390d9ce3a1SRobert Watson 	bcopy(sa, *nam, sa->sa_len);
5400d9ce3a1SRobert Watson 	UNP_UNLOCK();
541e5aeaa0cSDag-Erling Smørgrav 	return (0);
542df8bae1dSRodney W. Grimes }
543a29f300eSGarrett Wollman 
544a29f300eSGarrett Wollman struct pr_usrreqs uipc_usrreqs = {
545756d52a1SPoul-Henning Kamp 	.pru_abort = 		uipc_abort,
546756d52a1SPoul-Henning Kamp 	.pru_accept =		uipc_accept,
547756d52a1SPoul-Henning Kamp 	.pru_attach =		uipc_attach,
548756d52a1SPoul-Henning Kamp 	.pru_bind =		uipc_bind,
549756d52a1SPoul-Henning Kamp 	.pru_connect =		uipc_connect,
550756d52a1SPoul-Henning Kamp 	.pru_connect2 =		uipc_connect2,
551756d52a1SPoul-Henning Kamp 	.pru_detach =		uipc_detach,
552756d52a1SPoul-Henning Kamp 	.pru_disconnect =	uipc_disconnect,
553756d52a1SPoul-Henning Kamp 	.pru_listen =		uipc_listen,
554756d52a1SPoul-Henning Kamp 	.pru_peeraddr =		uipc_peeraddr,
555756d52a1SPoul-Henning Kamp 	.pru_rcvd =		uipc_rcvd,
556756d52a1SPoul-Henning Kamp 	.pru_send =		uipc_send,
557756d52a1SPoul-Henning Kamp 	.pru_sense =		uipc_sense,
558756d52a1SPoul-Henning Kamp 	.pru_shutdown =		uipc_shutdown,
559756d52a1SPoul-Henning Kamp 	.pru_sockaddr =		uipc_sockaddr,
560756d52a1SPoul-Henning Kamp 	.pru_sosend =		sosend,
561756d52a1SPoul-Henning Kamp 	.pru_soreceive =	soreceive,
562756d52a1SPoul-Henning Kamp 	.pru_sopoll =		sopoll,
563a29f300eSGarrett Wollman };
564df8bae1dSRodney W. Grimes 
5650c1bb4fbSDima Dorfman int
566892af6b9SRobert Watson uipc_ctloutput(struct socket *so, struct sockopt *sopt)
5670c1bb4fbSDima Dorfman {
56840f2ac28SRobert Watson 	struct unpcb *unp;
5690d9ce3a1SRobert Watson 	struct xucred xu;
5706a2989fdSMatthew N. Dodd 	int error, optval;
5716a2989fdSMatthew N. Dodd 
57296a041b5SMatthew N. Dodd 	if (sopt->sopt_level != 0)
57396a041b5SMatthew N. Dodd 		return (EINVAL);
57496a041b5SMatthew N. Dodd 
5756a2989fdSMatthew N. Dodd 	unp = sotounpcb(so);
5764d4b555eSRobert Watson 	KASSERT(unp != NULL, ("uipc_ctloutput: unp == NULL"));
5774d4b555eSRobert Watson 	UNP_LOCK();
5786a2989fdSMatthew N. Dodd 	error = 0;
5790c1bb4fbSDima Dorfman 	switch (sopt->sopt_dir) {
5800c1bb4fbSDima Dorfman 	case SOPT_GET:
5810c1bb4fbSDima Dorfman 		switch (sopt->sopt_name) {
5820c1bb4fbSDima Dorfman 		case LOCAL_PEERCRED:
5830c1bb4fbSDima Dorfman 			if (unp->unp_flags & UNP_HAVEPC)
5840d9ce3a1SRobert Watson 				xu = unp->unp_peercred;
5850c1bb4fbSDima Dorfman 			else {
5860c1bb4fbSDima Dorfman 				if (so->so_type == SOCK_STREAM)
5870c1bb4fbSDima Dorfman 					error = ENOTCONN;
5880c1bb4fbSDima Dorfman 				else
5890c1bb4fbSDima Dorfman 					error = EINVAL;
5900c1bb4fbSDima Dorfman 			}
5910d9ce3a1SRobert Watson 			if (error == 0)
5920d9ce3a1SRobert Watson 				error = sooptcopyout(sopt, &xu, sizeof(xu));
5930c1bb4fbSDima Dorfman 			break;
5946a2989fdSMatthew N. Dodd 		case LOCAL_CREDS:
5956a2989fdSMatthew N. Dodd 			optval = unp->unp_flags & UNP_WANTCRED ? 1 : 0;
5966a2989fdSMatthew N. Dodd 			error = sooptcopyout(sopt, &optval, sizeof(optval));
5976a2989fdSMatthew N. Dodd 			break;
5986a2989fdSMatthew N. Dodd 		case LOCAL_CONNWAIT:
5996a2989fdSMatthew N. Dodd 			optval = unp->unp_flags & UNP_CONNWAIT ? 1 : 0;
6006a2989fdSMatthew N. Dodd 			error = sooptcopyout(sopt, &optval, sizeof(optval));
6016a2989fdSMatthew N. Dodd 			break;
6020c1bb4fbSDima Dorfman 		default:
6030c1bb4fbSDima Dorfman 			error = EOPNOTSUPP;
6040c1bb4fbSDima Dorfman 			break;
6050c1bb4fbSDima Dorfman 		}
6060c1bb4fbSDima Dorfman 		break;
6070c1bb4fbSDima Dorfman 	case SOPT_SET:
6086a2989fdSMatthew N. Dodd 		switch (sopt->sopt_name) {
6096a2989fdSMatthew N. Dodd 		case LOCAL_CREDS:
6106a2989fdSMatthew N. Dodd 		case LOCAL_CONNWAIT:
6116a2989fdSMatthew N. Dodd 			error = sooptcopyin(sopt, &optval, sizeof(optval),
6126a2989fdSMatthew N. Dodd 					    sizeof(optval));
6136a2989fdSMatthew N. Dodd 			if (error)
6146a2989fdSMatthew N. Dodd 				break;
6156a2989fdSMatthew N. Dodd 
6166a2989fdSMatthew N. Dodd #define	OPTSET(bit) \
6176a2989fdSMatthew N. Dodd 	if (optval) \
6186a2989fdSMatthew N. Dodd 		unp->unp_flags |= bit; \
6196a2989fdSMatthew N. Dodd 	else \
6206a2989fdSMatthew N. Dodd 		unp->unp_flags &= ~bit;
6216a2989fdSMatthew N. Dodd 
6226a2989fdSMatthew N. Dodd 			switch (sopt->sopt_name) {
6236a2989fdSMatthew N. Dodd 			case LOCAL_CREDS:
6246a2989fdSMatthew N. Dodd 				OPTSET(UNP_WANTCRED);
6256a2989fdSMatthew N. Dodd 				break;
6266a2989fdSMatthew N. Dodd 			case LOCAL_CONNWAIT:
6276a2989fdSMatthew N. Dodd 				OPTSET(UNP_CONNWAIT);
6286a2989fdSMatthew N. Dodd 				break;
6296a2989fdSMatthew N. Dodd 			default:
6306a2989fdSMatthew N. Dodd 				break;
6316a2989fdSMatthew N. Dodd 			}
6326a2989fdSMatthew N. Dodd 			break;
6336a2989fdSMatthew N. Dodd #undef	OPTSET
6346a2989fdSMatthew N. Dodd 		default:
6356a2989fdSMatthew N. Dodd 			error = ENOPROTOOPT;
6366a2989fdSMatthew N. Dodd 			break;
6376a2989fdSMatthew N. Dodd 		}
638abb886faSMatthew N. Dodd 		break;
6390c1bb4fbSDima Dorfman 	default:
6400c1bb4fbSDima Dorfman 		error = EOPNOTSUPP;
6410c1bb4fbSDima Dorfman 		break;
6420c1bb4fbSDima Dorfman 	}
6436a2989fdSMatthew N. Dodd 	UNP_UNLOCK();
6440c1bb4fbSDima Dorfman 	return (error);
6450c1bb4fbSDima Dorfman }
6460c1bb4fbSDima Dorfman 
647df8bae1dSRodney W. Grimes /*
648df8bae1dSRodney W. Grimes  * Both send and receive buffers are allocated PIPSIZ bytes of buffering
649df8bae1dSRodney W. Grimes  * for stream sockets, although the total for sender and receiver is
650df8bae1dSRodney W. Grimes  * actually only PIPSIZ.
651df8bae1dSRodney W. Grimes  * Datagram sockets really use the sendspace as the maximum datagram size,
652df8bae1dSRodney W. Grimes  * and don't really want to reserve the sendspace.  Their recvspace should
653df8bae1dSRodney W. Grimes  * be large enough for at least one max-size datagram plus address.
654df8bae1dSRodney W. Grimes  */
6555dce41c5SJohn Dyson #ifndef PIPSIZ
6565dce41c5SJohn Dyson #define	PIPSIZ	8192
6575dce41c5SJohn Dyson #endif
658f708ef1bSPoul-Henning Kamp static u_long	unpst_sendspace = PIPSIZ;
659f708ef1bSPoul-Henning Kamp static u_long	unpst_recvspace = PIPSIZ;
660f708ef1bSPoul-Henning Kamp static u_long	unpdg_sendspace = 2*1024;	/* really max datagram size */
661f708ef1bSPoul-Henning Kamp static u_long	unpdg_recvspace = 4*1024;
662df8bae1dSRodney W. Grimes 
663f708ef1bSPoul-Henning Kamp static int	unp_rights;			/* file descriptors in flight */
664df8bae1dSRodney W. Grimes 
665ce02431fSDoug Rabson SYSCTL_DECL(_net_local_stream);
666e59898ffSMaxime Henrion SYSCTL_ULONG(_net_local_stream, OID_AUTO, sendspace, CTLFLAG_RW,
667639acc13SGarrett Wollman 	   &unpst_sendspace, 0, "");
668e59898ffSMaxime Henrion SYSCTL_ULONG(_net_local_stream, OID_AUTO, recvspace, CTLFLAG_RW,
669639acc13SGarrett Wollman 	   &unpst_recvspace, 0, "");
670ce02431fSDoug Rabson SYSCTL_DECL(_net_local_dgram);
671e59898ffSMaxime Henrion SYSCTL_ULONG(_net_local_dgram, OID_AUTO, maxdgram, CTLFLAG_RW,
672639acc13SGarrett Wollman 	   &unpdg_sendspace, 0, "");
673e59898ffSMaxime Henrion SYSCTL_ULONG(_net_local_dgram, OID_AUTO, recvspace, CTLFLAG_RW,
674639acc13SGarrett Wollman 	   &unpdg_recvspace, 0, "");
675ce02431fSDoug Rabson SYSCTL_DECL(_net_local);
676639acc13SGarrett Wollman SYSCTL_INT(_net_local, OID_AUTO, inflight, CTLFLAG_RD, &unp_rights, 0, "");
677639acc13SGarrett Wollman 
678f708ef1bSPoul-Henning Kamp static int
679892af6b9SRobert Watson unp_attach(struct socket *so)
680df8bae1dSRodney W. Grimes {
681892af6b9SRobert Watson 	struct unpcb *unp;
682df8bae1dSRodney W. Grimes 	int error;
683df8bae1dSRodney W. Grimes 
6844d4b555eSRobert Watson 	KASSERT(so->so_pcb == NULL, ("unp_attach: so_pcb != NULL"));
685df8bae1dSRodney W. Grimes 	if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
686df8bae1dSRodney W. Grimes 		switch (so->so_type) {
687df8bae1dSRodney W. Grimes 
688df8bae1dSRodney W. Grimes 		case SOCK_STREAM:
689df8bae1dSRodney W. Grimes 			error = soreserve(so, unpst_sendspace, unpst_recvspace);
690df8bae1dSRodney W. Grimes 			break;
691df8bae1dSRodney W. Grimes 
692df8bae1dSRodney W. Grimes 		case SOCK_DGRAM:
693df8bae1dSRodney W. Grimes 			error = soreserve(so, unpdg_sendspace, unpdg_recvspace);
694df8bae1dSRodney W. Grimes 			break;
695df8bae1dSRodney W. Grimes 
696df8bae1dSRodney W. Grimes 		default:
697df8bae1dSRodney W. Grimes 			panic("unp_attach");
698df8bae1dSRodney W. Grimes 		}
699df8bae1dSRodney W. Grimes 		if (error)
700df8bae1dSRodney W. Grimes 			return (error);
701df8bae1dSRodney W. Grimes 	}
702d664e4faSRobert Watson 	unp = uma_zalloc(unp_zone, M_WAITOK | M_ZERO);
70357bf258eSGarrett Wollman 	if (unp == NULL)
704df8bae1dSRodney W. Grimes 		return (ENOBUFS);
70598271db4SGarrett Wollman 	LIST_INIT(&unp->unp_refs);
706df8bae1dSRodney W. Grimes 	unp->unp_socket = so;
7077301cf23SRobert Watson 	so->so_pcb = unp;
7080d9ce3a1SRobert Watson 
7090d9ce3a1SRobert Watson 	UNP_LOCK();
7100d9ce3a1SRobert Watson 	unp->unp_gencnt = ++unp_gencnt;
7110d9ce3a1SRobert Watson 	unp_count++;
71298271db4SGarrett Wollman 	LIST_INSERT_HEAD(so->so_type == SOCK_DGRAM ? &unp_dhead
71398271db4SGarrett Wollman 			 : &unp_shead, unp, unp_link);
7140d9ce3a1SRobert Watson 	UNP_UNLOCK();
7150d9ce3a1SRobert Watson 
716df8bae1dSRodney W. Grimes 	return (0);
717df8bae1dSRodney W. Grimes }
718df8bae1dSRodney W. Grimes 
719f708ef1bSPoul-Henning Kamp static void
720892af6b9SRobert Watson unp_detach(struct unpcb *unp)
721df8bae1dSRodney W. Grimes {
7220d9ce3a1SRobert Watson 	struct vnode *vp;
723a0ec558aSRobert Watson 	int local_unp_rights;
7240d9ce3a1SRobert Watson 
7250d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
7260d9ce3a1SRobert Watson 
72798271db4SGarrett Wollman 	LIST_REMOVE(unp, unp_link);
72898271db4SGarrett Wollman 	unp->unp_gencnt = ++unp_gencnt;
72998271db4SGarrett Wollman 	--unp_count;
7300d9ce3a1SRobert Watson 	if ((vp = unp->unp_vnode) != NULL) {
7310d9ce3a1SRobert Watson 		/*
7320d9ce3a1SRobert Watson 		 * XXXRW: should v_socket be frobbed only while holding
7330d9ce3a1SRobert Watson 		 * Giant?
7340d9ce3a1SRobert Watson 		 */
735fc3fcacfSRobert Watson 		unp->unp_vnode->v_socket = NULL;
736fc3fcacfSRobert Watson 		unp->unp_vnode = NULL;
737df8bae1dSRodney W. Grimes 	}
738fc3fcacfSRobert Watson 	if (unp->unp_conn != NULL)
739df8bae1dSRodney W. Grimes 		unp_disconnect(unp);
7400d9ce3a1SRobert Watson 	while (!LIST_EMPTY(&unp->unp_refs)) {
7410d9ce3a1SRobert Watson 		struct unpcb *ref = LIST_FIRST(&unp->unp_refs);
7420d9ce3a1SRobert Watson 		unp_drop(ref, ECONNRESET);
7430d9ce3a1SRobert Watson 	}
744df8bae1dSRodney W. Grimes 	soisdisconnected(unp->unp_socket);
745fc3fcacfSRobert Watson 	unp->unp_socket->so_pcb = NULL;
746a0ec558aSRobert Watson 	local_unp_rights = unp_rights;
747a5993a97SRobert Watson 	UNP_UNLOCK();
748fc3fcacfSRobert Watson 	if (unp->unp_addr != NULL)
74957bf258eSGarrett Wollman 		FREE(unp->unp_addr, M_SONAME);
7509e9d298aSJeff Roberson 	uma_zfree(unp_zone, unp);
7510d9ce3a1SRobert Watson 	if (vp) {
752033eb86eSJeff Roberson 		int vfslocked;
753033eb86eSJeff Roberson 
754033eb86eSJeff Roberson 		vfslocked = VFS_LOCK_GIANT(vp->v_mount);
7550d9ce3a1SRobert Watson 		vrele(vp);
756033eb86eSJeff Roberson 		VFS_UNLOCK_GIANT(vfslocked);
7570d9ce3a1SRobert Watson 	}
758a0ec558aSRobert Watson 	if (local_unp_rights)
759a0ec558aSRobert Watson 		taskqueue_enqueue(taskqueue_thread, &unp_gc_task);
760df8bae1dSRodney W. Grimes }
761df8bae1dSRodney W. Grimes 
762f708ef1bSPoul-Henning Kamp static int
763892af6b9SRobert Watson unp_bind(struct unpcb *unp, struct sockaddr *nam, struct thread *td)
764df8bae1dSRodney W. Grimes {
76557bf258eSGarrett Wollman 	struct sockaddr_un *soun = (struct sockaddr_un *)nam;
766f2a2857bSKirk McKusick 	struct vnode *vp;
767f2a2857bSKirk McKusick 	struct mount *mp;
768df8bae1dSRodney W. Grimes 	struct vattr vattr;
76957bf258eSGarrett Wollman 	int error, namelen;
770df8bae1dSRodney W. Grimes 	struct nameidata nd;
7718f364875SJulian Elischer 	char *buf;
772df8bae1dSRodney W. Grimes 
77340f2ac28SRobert Watson 	UNP_LOCK_ASSERT();
77440f2ac28SRobert Watson 
7750d9ce3a1SRobert Watson 	/*
7760d9ce3a1SRobert Watson 	 * XXXRW: This test-and-set of unp_vnode is non-atomic; the
7770d9ce3a1SRobert Watson 	 * unlocked read here is fine, but the value of unp_vnode needs
7780d9ce3a1SRobert Watson 	 * to be tested again after we do all the lookups to see if the
7790d9ce3a1SRobert Watson 	 * pcb is still unbound?
7800d9ce3a1SRobert Watson 	 */
781df8bae1dSRodney W. Grimes 	if (unp->unp_vnode != NULL)
782df8bae1dSRodney W. Grimes 		return (EINVAL);
78355c85568SRobert Drehmel 
78457bf258eSGarrett Wollman 	namelen = soun->sun_len - offsetof(struct sockaddr_un, sun_path);
78557bf258eSGarrett Wollman 	if (namelen <= 0)
786e5aeaa0cSDag-Erling Smørgrav 		return (EINVAL);
78755c85568SRobert Drehmel 
78840f2ac28SRobert Watson 	UNP_UNLOCK();
78940f2ac28SRobert Watson 
790a163d034SWarner Losh 	buf = malloc(namelen + 1, M_TEMP, M_WAITOK);
79155c85568SRobert Drehmel 	strlcpy(buf, soun->sun_path, namelen + 1);
79255c85568SRobert Drehmel 
7930d9ce3a1SRobert Watson 	mtx_lock(&Giant);
794f2a2857bSKirk McKusick restart:
7950d9ce3a1SRobert Watson 	mtx_assert(&Giant, MA_OWNED);
796b65f6f6bSRobert Watson 	NDINIT(&nd, CREATE, NOFOLLOW | LOCKPARENT | SAVENAME, UIO_SYSSPACE,
797b40ce416SJulian Elischer 	    buf, td);
798df8bae1dSRodney W. Grimes /* SHOULD BE ABLE TO ADOPT EXISTING AND wakeup() ALA FIFO's */
799797f2d22SPoul-Henning Kamp 	error = namei(&nd);
8000d9ce3a1SRobert Watson 	if (error)
8010d9ce3a1SRobert Watson 		goto done;
802df8bae1dSRodney W. Grimes 	vp = nd.ni_vp;
803f2a2857bSKirk McKusick 	if (vp != NULL || vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
804762e6b85SEivind Eklund 		NDFREE(&nd, NDF_ONLY_PNBUF);
805df8bae1dSRodney W. Grimes 		if (nd.ni_dvp == vp)
806df8bae1dSRodney W. Grimes 			vrele(nd.ni_dvp);
807df8bae1dSRodney W. Grimes 		else
808df8bae1dSRodney W. Grimes 			vput(nd.ni_dvp);
809f2a2857bSKirk McKusick 		if (vp != NULL) {
810df8bae1dSRodney W. Grimes 			vrele(vp);
8110d9ce3a1SRobert Watson 			error = EADDRINUSE;
8120d9ce3a1SRobert Watson 			goto done;
813df8bae1dSRodney W. Grimes 		}
8148f364875SJulian Elischer 		error = vn_start_write(NULL, &mp, V_XSLEEP | PCATCH);
8150d9ce3a1SRobert Watson 		if (error)
8160d9ce3a1SRobert Watson 			goto done;
817f2a2857bSKirk McKusick 		goto restart;
818f2a2857bSKirk McKusick 	}
819df8bae1dSRodney W. Grimes 	VATTR_NULL(&vattr);
820df8bae1dSRodney W. Grimes 	vattr.va_type = VSOCK;
821b40ce416SJulian Elischer 	vattr.va_mode = (ACCESSPERMS & ~td->td_proc->p_fd->fd_cmask);
8226ea48a90SRobert Watson #ifdef MAC
8236ea48a90SRobert Watson 	error = mac_check_vnode_create(td->td_ucred, nd.ni_dvp, &nd.ni_cnd,
8246ea48a90SRobert Watson 	    &vattr);
8256151efaaSRobert Watson #endif
8266ea48a90SRobert Watson 	if (error == 0) {
827a854ed98SJohn Baldwin 		VOP_LEASE(nd.ni_dvp, td, td->td_ucred, LEASE_WRITE);
8287be2d300SMike Smith 		error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
8296ea48a90SRobert Watson 	}
830762e6b85SEivind Eklund 	NDFREE(&nd, NDF_ONLY_PNBUF);
8317be2d300SMike Smith 	vput(nd.ni_dvp);
832c364c823SRobert Watson 	if (error) {
833c364c823SRobert Watson 		vn_finished_write(mp);
8340d9ce3a1SRobert Watson 		goto done;
835c364c823SRobert Watson 	}
836df8bae1dSRodney W. Grimes 	vp = nd.ni_vp;
8370d9ce3a1SRobert Watson 	ASSERT_VOP_LOCKED(vp, "unp_bind");
8380d9ce3a1SRobert Watson 	soun = (struct sockaddr_un *)sodupsockaddr(nam, M_WAITOK);
8390d9ce3a1SRobert Watson 	UNP_LOCK();
840df8bae1dSRodney W. Grimes 	vp->v_socket = unp->unp_socket;
841df8bae1dSRodney W. Grimes 	unp->unp_vnode = vp;
8420d9ce3a1SRobert Watson 	unp->unp_addr = soun;
8430d9ce3a1SRobert Watson 	UNP_UNLOCK();
844b40ce416SJulian Elischer 	VOP_UNLOCK(vp, 0, td);
845f2a2857bSKirk McKusick 	vn_finished_write(mp);
8460d9ce3a1SRobert Watson done:
8470d9ce3a1SRobert Watson 	mtx_unlock(&Giant);
8488f364875SJulian Elischer 	free(buf, M_TEMP);
84940f2ac28SRobert Watson 	UNP_LOCK();
8500d9ce3a1SRobert Watson 	return (error);
851df8bae1dSRodney W. Grimes }
852df8bae1dSRodney W. Grimes 
853f708ef1bSPoul-Henning Kamp static int
854892af6b9SRobert Watson unp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
855df8bae1dSRodney W. Grimes {
856892af6b9SRobert Watson 	struct sockaddr_un *soun = (struct sockaddr_un *)nam;
857892af6b9SRobert Watson 	struct vnode *vp;
858892af6b9SRobert Watson 	struct socket *so2, *so3;
859b295bdcdSRobert Watson 	struct unpcb *unp, *unp2, *unp3;
86057bf258eSGarrett Wollman 	int error, len;
861df8bae1dSRodney W. Grimes 	struct nameidata nd;
86257bf258eSGarrett Wollman 	char buf[SOCK_MAXADDRLEN];
8630d9ce3a1SRobert Watson 	struct sockaddr *sa;
8640d9ce3a1SRobert Watson 
8650d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
866df8bae1dSRodney W. Grimes 
8674d4b555eSRobert Watson 	unp = sotounpcb(so);
8684d4b555eSRobert Watson 	KASSERT(unp != NULL, ("unp_connect: unp == NULL"));
86957bf258eSGarrett Wollman 	len = nam->sa_len - offsetof(struct sockaddr_un, sun_path);
87057bf258eSGarrett Wollman 	if (len <= 0)
871e5aeaa0cSDag-Erling Smørgrav 		return (EINVAL);
87255c85568SRobert Drehmel 	strlcpy(buf, soun->sun_path, len + 1);
8730d9ce3a1SRobert Watson 	UNP_UNLOCK();
8740d9ce3a1SRobert Watson 	sa = malloc(sizeof(struct sockaddr_un), M_SONAME, M_WAITOK);
8750d9ce3a1SRobert Watson 	mtx_lock(&Giant);
876b40ce416SJulian Elischer 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, buf, td);
877797f2d22SPoul-Henning Kamp 	error = namei(&nd);
878797f2d22SPoul-Henning Kamp 	if (error)
8790d9ce3a1SRobert Watson 		vp = NULL;
8800d9ce3a1SRobert Watson 	else
881df8bae1dSRodney W. Grimes 		vp = nd.ni_vp;
8820d9ce3a1SRobert Watson 	ASSERT_VOP_LOCKED(vp, "unp_connect");
883762e6b85SEivind Eklund 	NDFREE(&nd, NDF_ONLY_PNBUF);
8840d9ce3a1SRobert Watson 	if (error)
8850d9ce3a1SRobert Watson 		goto bad;
8860d9ce3a1SRobert Watson 
887df8bae1dSRodney W. Grimes 	if (vp->v_type != VSOCK) {
888df8bae1dSRodney W. Grimes 		error = ENOTSOCK;
889df8bae1dSRodney W. Grimes 		goto bad;
890df8bae1dSRodney W. Grimes 	}
891a854ed98SJohn Baldwin 	error = VOP_ACCESS(vp, VWRITE, td->td_ucred, td);
892797f2d22SPoul-Henning Kamp 	if (error)
893df8bae1dSRodney W. Grimes 		goto bad;
8942260c03dSRobert Watson 	mtx_unlock(&Giant);
8952260c03dSRobert Watson 	UNP_LOCK();
896b295bdcdSRobert Watson 	unp = sotounpcb(so);
8974d4b555eSRobert Watson 	KASSERT(unp != NULL, ("unp_connect: unp == NULL"));
898df8bae1dSRodney W. Grimes 	so2 = vp->v_socket;
899fc3fcacfSRobert Watson 	if (so2 == NULL) {
900df8bae1dSRodney W. Grimes 		error = ECONNREFUSED;
9012260c03dSRobert Watson 		goto bad2;
902df8bae1dSRodney W. Grimes 	}
903df8bae1dSRodney W. Grimes 	if (so->so_type != so2->so_type) {
904df8bae1dSRodney W. Grimes 		error = EPROTOTYPE;
9052260c03dSRobert Watson 		goto bad2;
906df8bae1dSRodney W. Grimes 	}
907df8bae1dSRodney W. Grimes 	if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
9080d9ce3a1SRobert Watson 		if (so2->so_options & SO_ACCEPTCONN) {
9090d9ce3a1SRobert Watson 			/*
9100d9ce3a1SRobert Watson 			 * NB: drop locks here so unp_attach is entered
9110d9ce3a1SRobert Watson 			 *     w/o locks; this avoids a recursive lock
9120d9ce3a1SRobert Watson 			 *     of the head and holding sleep locks across
9130d9ce3a1SRobert Watson 			 *     a (potentially) blocking malloc.
9140d9ce3a1SRobert Watson 			 */
9150d9ce3a1SRobert Watson 			UNP_UNLOCK();
9160d9ce3a1SRobert Watson 			so3 = sonewconn(so2, 0);
9170d9ce3a1SRobert Watson 			UNP_LOCK();
9180d9ce3a1SRobert Watson 		} else
9190d9ce3a1SRobert Watson 			so3 = NULL;
9200d9ce3a1SRobert Watson 		if (so3 == NULL) {
921df8bae1dSRodney W. Grimes 			error = ECONNREFUSED;
9220d9ce3a1SRobert Watson 			goto bad2;
923df8bae1dSRodney W. Grimes 		}
9240c1bb4fbSDima Dorfman 		unp = sotounpcb(so);
925df8bae1dSRodney W. Grimes 		unp2 = sotounpcb(so2);
926df8bae1dSRodney W. Grimes 		unp3 = sotounpcb(so3);
9270d9ce3a1SRobert Watson 		if (unp2->unp_addr != NULL) {
9280d9ce3a1SRobert Watson 			bcopy(unp2->unp_addr, sa, unp2->unp_addr->sun_len);
9290d9ce3a1SRobert Watson 			unp3->unp_addr = (struct sockaddr_un *) sa;
9300d9ce3a1SRobert Watson 			sa = NULL;
9310d9ce3a1SRobert Watson 		}
9320c1bb4fbSDima Dorfman 		/*
9330c1bb4fbSDima Dorfman 		 * unp_peercred management:
9340c1bb4fbSDima Dorfman 		 *
9350c1bb4fbSDima Dorfman 		 * The connecter's (client's) credentials are copied
9360c1bb4fbSDima Dorfman 		 * from its process structure at the time of connect()
9370c1bb4fbSDima Dorfman 		 * (which is now).
9380c1bb4fbSDima Dorfman 		 */
939a854ed98SJohn Baldwin 		cru2x(td->td_ucred, &unp3->unp_peercred);
9400c1bb4fbSDima Dorfman 		unp3->unp_flags |= UNP_HAVEPC;
9410c1bb4fbSDima Dorfman 		/*
9420c1bb4fbSDima Dorfman 		 * The receiver's (server's) credentials are copied
9430c1bb4fbSDima Dorfman 		 * from the unp_peercred member of socket on which the
9440c1bb4fbSDima Dorfman 		 * former called listen(); unp_listen() cached that
9450c1bb4fbSDima Dorfman 		 * process's credentials at that time so we can use
9460c1bb4fbSDima Dorfman 		 * them now.
9470c1bb4fbSDima Dorfman 		 */
9480c1bb4fbSDima Dorfman 		KASSERT(unp2->unp_flags & UNP_HAVEPCCACHED,
9490c1bb4fbSDima Dorfman 		    ("unp_connect: listener without cached peercred"));
9500c1bb4fbSDima Dorfman 		memcpy(&unp->unp_peercred, &unp2->unp_peercred,
9510c1bb4fbSDima Dorfman 		    sizeof(unp->unp_peercred));
9520c1bb4fbSDima Dorfman 		unp->unp_flags |= UNP_HAVEPC;
953335654d7SRobert Watson #ifdef MAC
954310e7cebSRobert Watson 		SOCK_LOCK(so);
955335654d7SRobert Watson 		mac_set_socket_peer_from_socket(so, so3);
956335654d7SRobert Watson 		mac_set_socket_peer_from_socket(so3, so);
957310e7cebSRobert Watson 		SOCK_UNLOCK(so);
958335654d7SRobert Watson #endif
9590c1bb4fbSDima Dorfman 
960df8bae1dSRodney W. Grimes 		so2 = so3;
961df8bae1dSRodney W. Grimes 	}
9626a2989fdSMatthew N. Dodd 	error = unp_connect2(so, so2, PRU_CONNECT);
9630d9ce3a1SRobert Watson bad2:
9640d9ce3a1SRobert Watson 	UNP_UNLOCK();
9650d9ce3a1SRobert Watson 	mtx_lock(&Giant);
966df8bae1dSRodney W. Grimes bad:
9670d9ce3a1SRobert Watson 	mtx_assert(&Giant, MA_OWNED);
9680d9ce3a1SRobert Watson 	if (vp != NULL)
969df8bae1dSRodney W. Grimes 		vput(vp);
9700d9ce3a1SRobert Watson 	mtx_unlock(&Giant);
9710d9ce3a1SRobert Watson 	free(sa, M_SONAME);
9720d9ce3a1SRobert Watson 	UNP_LOCK();
973df8bae1dSRodney W. Grimes 	return (error);
974df8bae1dSRodney W. Grimes }
975df8bae1dSRodney W. Grimes 
976db48c0d2SRobert Watson static int
9776a2989fdSMatthew N. Dodd unp_connect2(struct socket *so, struct socket *so2, int req)
978df8bae1dSRodney W. Grimes {
979892af6b9SRobert Watson 	struct unpcb *unp = sotounpcb(so);
980892af6b9SRobert Watson 	struct unpcb *unp2;
981df8bae1dSRodney W. Grimes 
9820d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
9830d9ce3a1SRobert Watson 
984df8bae1dSRodney W. Grimes 	if (so2->so_type != so->so_type)
985df8bae1dSRodney W. Grimes 		return (EPROTOTYPE);
986df8bae1dSRodney W. Grimes 	unp2 = sotounpcb(so2);
9874d4b555eSRobert Watson 	KASSERT(unp2 != NULL, ("unp_connect2: unp2 == NULL"));
988df8bae1dSRodney W. Grimes 	unp->unp_conn = unp2;
989df8bae1dSRodney W. Grimes 	switch (so->so_type) {
990df8bae1dSRodney W. Grimes 
991df8bae1dSRodney W. Grimes 	case SOCK_DGRAM:
99298271db4SGarrett Wollman 		LIST_INSERT_HEAD(&unp2->unp_refs, unp, unp_reflink);
993df8bae1dSRodney W. Grimes 		soisconnected(so);
994df8bae1dSRodney W. Grimes 		break;
995df8bae1dSRodney W. Grimes 
996df8bae1dSRodney W. Grimes 	case SOCK_STREAM:
997df8bae1dSRodney W. Grimes 		unp2->unp_conn = unp;
9986a2989fdSMatthew N. Dodd 		if (req == PRU_CONNECT &&
9996a2989fdSMatthew N. Dodd 		    ((unp->unp_flags | unp2->unp_flags) & UNP_CONNWAIT))
10006a2989fdSMatthew N. Dodd 			soisconnecting(so);
10016a2989fdSMatthew N. Dodd 		else
1002df8bae1dSRodney W. Grimes 			soisconnected(so);
1003df8bae1dSRodney W. Grimes 		soisconnected(so2);
1004df8bae1dSRodney W. Grimes 		break;
1005df8bae1dSRodney W. Grimes 
1006df8bae1dSRodney W. Grimes 	default:
1007df8bae1dSRodney W. Grimes 		panic("unp_connect2");
1008df8bae1dSRodney W. Grimes 	}
1009df8bae1dSRodney W. Grimes 	return (0);
1010df8bae1dSRodney W. Grimes }
1011df8bae1dSRodney W. Grimes 
1012f708ef1bSPoul-Henning Kamp static void
1013892af6b9SRobert Watson unp_disconnect(struct unpcb *unp)
1014df8bae1dSRodney W. Grimes {
1015892af6b9SRobert Watson 	struct unpcb *unp2 = unp->unp_conn;
10161b2e3b4bSRobert Watson 	struct socket *so;
1017df8bae1dSRodney W. Grimes 
10180d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
10190d9ce3a1SRobert Watson 
1020fc3fcacfSRobert Watson 	if (unp2 == NULL)
1021df8bae1dSRodney W. Grimes 		return;
1022fc3fcacfSRobert Watson 	unp->unp_conn = NULL;
1023df8bae1dSRodney W. Grimes 	switch (unp->unp_socket->so_type) {
1024df8bae1dSRodney W. Grimes 	case SOCK_DGRAM:
102598271db4SGarrett Wollman 		LIST_REMOVE(unp, unp_reflink);
10261b2e3b4bSRobert Watson 		so = unp->unp_socket;
10271b2e3b4bSRobert Watson 		SOCK_LOCK(so);
10281b2e3b4bSRobert Watson 		so->so_state &= ~SS_ISCONNECTED;
10291b2e3b4bSRobert Watson 		SOCK_UNLOCK(so);
1030df8bae1dSRodney W. Grimes 		break;
1031df8bae1dSRodney W. Grimes 
1032df8bae1dSRodney W. Grimes 	case SOCK_STREAM:
1033df8bae1dSRodney W. Grimes 		soisdisconnected(unp->unp_socket);
1034fc3fcacfSRobert Watson 		unp2->unp_conn = NULL;
1035df8bae1dSRodney W. Grimes 		soisdisconnected(unp2->unp_socket);
1036df8bae1dSRodney W. Grimes 		break;
1037df8bae1dSRodney W. Grimes 	}
1038df8bae1dSRodney W. Grimes }
1039df8bae1dSRodney W. Grimes 
1040df8bae1dSRodney W. Grimes #ifdef notdef
104126f9a767SRodney W. Grimes void
1042892af6b9SRobert Watson unp_abort(struct unpcb *unp)
1043df8bae1dSRodney W. Grimes {
1044df8bae1dSRodney W. Grimes 
1045df8bae1dSRodney W. Grimes 	unp_detach(unp);
10464c5bc1caSRobert Watson 	UNP_UNLOCK_ASSERT();
1047df8bae1dSRodney W. Grimes }
1048df8bae1dSRodney W. Grimes #endif
1049df8bae1dSRodney W. Grimes 
10500d9ce3a1SRobert Watson /*
10510d9ce3a1SRobert Watson  * unp_pcblist() assumes that UNIX domain socket memory is never reclaimed
10520d9ce3a1SRobert Watson  * by the zone (UMA_ZONE_NOFREE), and as such potentially stale pointers
10530d9ce3a1SRobert Watson  * are safe to reference.  It first scans the list of struct unpcb's to
10540d9ce3a1SRobert Watson  * generate a pointer list, then it rescans its list one entry at a time to
10550d9ce3a1SRobert Watson  * externalize and copyout.  It checks the generation number to see if a
10560d9ce3a1SRobert Watson  * struct unpcb has been reused, and will skip it if so.
10570d9ce3a1SRobert Watson  */
105898271db4SGarrett Wollman static int
105982d9ae4eSPoul-Henning Kamp unp_pcblist(SYSCTL_HANDLER_ARGS)
106098271db4SGarrett Wollman {
1061f5ef029eSPoul-Henning Kamp 	int error, i, n;
106298271db4SGarrett Wollman 	struct unpcb *unp, **unp_list;
106398271db4SGarrett Wollman 	unp_gen_t gencnt;
10648f364875SJulian Elischer 	struct xunpgen *xug;
106598271db4SGarrett Wollman 	struct unp_head *head;
10668f364875SJulian Elischer 	struct xunpcb *xu;
106798271db4SGarrett Wollman 
1068a23d65bfSBruce Evans 	head = ((intptr_t)arg1 == SOCK_DGRAM ? &unp_dhead : &unp_shead);
106998271db4SGarrett Wollman 
107098271db4SGarrett Wollman 	/*
107198271db4SGarrett Wollman 	 * The process of preparing the PCB list is too time-consuming and
107298271db4SGarrett Wollman 	 * resource-intensive to repeat twice on every request.
107398271db4SGarrett Wollman 	 */
1074fc3fcacfSRobert Watson 	if (req->oldptr == NULL) {
107598271db4SGarrett Wollman 		n = unp_count;
10768f364875SJulian Elischer 		req->oldidx = 2 * (sizeof *xug)
107798271db4SGarrett Wollman 			+ (n + n/8) * sizeof(struct xunpcb);
1078e5aeaa0cSDag-Erling Smørgrav 		return (0);
107998271db4SGarrett Wollman 	}
108098271db4SGarrett Wollman 
1081fc3fcacfSRobert Watson 	if (req->newptr != NULL)
1082e5aeaa0cSDag-Erling Smørgrav 		return (EPERM);
108398271db4SGarrett Wollman 
108498271db4SGarrett Wollman 	/*
108598271db4SGarrett Wollman 	 * OK, now we're committed to doing something.
108698271db4SGarrett Wollman 	 */
1087a163d034SWarner Losh 	xug = malloc(sizeof(*xug), M_TEMP, M_WAITOK);
10880d9ce3a1SRobert Watson 	UNP_LOCK();
108998271db4SGarrett Wollman 	gencnt = unp_gencnt;
109098271db4SGarrett Wollman 	n = unp_count;
10910d9ce3a1SRobert Watson 	UNP_UNLOCK();
109298271db4SGarrett Wollman 
10938f364875SJulian Elischer 	xug->xug_len = sizeof *xug;
10948f364875SJulian Elischer 	xug->xug_count = n;
10958f364875SJulian Elischer 	xug->xug_gen = gencnt;
10968f364875SJulian Elischer 	xug->xug_sogen = so_gencnt;
10978f364875SJulian Elischer 	error = SYSCTL_OUT(req, xug, sizeof *xug);
10988f364875SJulian Elischer 	if (error) {
10998f364875SJulian Elischer 		free(xug, M_TEMP);
1100e5aeaa0cSDag-Erling Smørgrav 		return (error);
11018f364875SJulian Elischer 	}
110298271db4SGarrett Wollman 
1103a163d034SWarner Losh 	unp_list = malloc(n * sizeof *unp_list, M_TEMP, M_WAITOK);
110498271db4SGarrett Wollman 
11050d9ce3a1SRobert Watson 	UNP_LOCK();
11062e3c8fcbSPoul-Henning Kamp 	for (unp = LIST_FIRST(head), i = 0; unp && i < n;
11072e3c8fcbSPoul-Henning Kamp 	     unp = LIST_NEXT(unp, unp_link)) {
11088a7d8cc6SRobert Watson 		if (unp->unp_gencnt <= gencnt) {
1109a854ed98SJohn Baldwin 			if (cr_cansee(req->td->td_ucred,
11108a7d8cc6SRobert Watson 			    unp->unp_socket->so_cred))
11114787fd37SPaul Saab 				continue;
111298271db4SGarrett Wollman 			unp_list[i++] = unp;
111398271db4SGarrett Wollman 		}
11144787fd37SPaul Saab 	}
11150d9ce3a1SRobert Watson 	UNP_UNLOCK();
111698271db4SGarrett Wollman 	n = i;			/* in case we lost some during malloc */
111798271db4SGarrett Wollman 
111898271db4SGarrett Wollman 	error = 0;
1119fe2eee82SColin Percival 	xu = malloc(sizeof(*xu), M_TEMP, M_WAITOK | M_ZERO);
112098271db4SGarrett Wollman 	for (i = 0; i < n; i++) {
112198271db4SGarrett Wollman 		unp = unp_list[i];
112298271db4SGarrett Wollman 		if (unp->unp_gencnt <= gencnt) {
11238f364875SJulian Elischer 			xu->xu_len = sizeof *xu;
11248f364875SJulian Elischer 			xu->xu_unpp = unp;
112598271db4SGarrett Wollman 			/*
112698271db4SGarrett Wollman 			 * XXX - need more locking here to protect against
112798271db4SGarrett Wollman 			 * connect/disconnect races for SMP.
112898271db4SGarrett Wollman 			 */
1129fc3fcacfSRobert Watson 			if (unp->unp_addr != NULL)
11308f364875SJulian Elischer 				bcopy(unp->unp_addr, &xu->xu_addr,
113198271db4SGarrett Wollman 				      unp->unp_addr->sun_len);
1132fc3fcacfSRobert Watson 			if (unp->unp_conn != NULL &&
1133fc3fcacfSRobert Watson 			    unp->unp_conn->unp_addr != NULL)
113498271db4SGarrett Wollman 				bcopy(unp->unp_conn->unp_addr,
11358f364875SJulian Elischer 				      &xu->xu_caddr,
113698271db4SGarrett Wollman 				      unp->unp_conn->unp_addr->sun_len);
11378f364875SJulian Elischer 			bcopy(unp, &xu->xu_unp, sizeof *unp);
11388f364875SJulian Elischer 			sotoxsocket(unp->unp_socket, &xu->xu_socket);
11398f364875SJulian Elischer 			error = SYSCTL_OUT(req, xu, sizeof *xu);
114098271db4SGarrett Wollman 		}
114198271db4SGarrett Wollman 	}
11428f364875SJulian Elischer 	free(xu, M_TEMP);
114398271db4SGarrett Wollman 	if (!error) {
114498271db4SGarrett Wollman 		/*
114598271db4SGarrett Wollman 		 * Give the user an updated idea of our state.
114698271db4SGarrett Wollman 		 * If the generation differs from what we told
114798271db4SGarrett Wollman 		 * her before, she knows that something happened
114898271db4SGarrett Wollman 		 * while we were processing this request, and it
114998271db4SGarrett Wollman 		 * might be necessary to retry.
115098271db4SGarrett Wollman 		 */
11518f364875SJulian Elischer 		xug->xug_gen = unp_gencnt;
11528f364875SJulian Elischer 		xug->xug_sogen = so_gencnt;
11538f364875SJulian Elischer 		xug->xug_count = unp_count;
11548f364875SJulian Elischer 		error = SYSCTL_OUT(req, xug, sizeof *xug);
115598271db4SGarrett Wollman 	}
115698271db4SGarrett Wollman 	free(unp_list, M_TEMP);
11578f364875SJulian Elischer 	free(xug, M_TEMP);
1158e5aeaa0cSDag-Erling Smørgrav 	return (error);
115998271db4SGarrett Wollman }
116098271db4SGarrett Wollman 
116198271db4SGarrett Wollman SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLFLAG_RD,
116298271db4SGarrett Wollman 	    (caddr_t)(long)SOCK_DGRAM, 0, unp_pcblist, "S,xunpcb",
116398271db4SGarrett Wollman 	    "List of active local datagram sockets");
116498271db4SGarrett Wollman SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLFLAG_RD,
116598271db4SGarrett Wollman 	    (caddr_t)(long)SOCK_STREAM, 0, unp_pcblist, "S,xunpcb",
116698271db4SGarrett Wollman 	    "List of active local stream sockets");
116798271db4SGarrett Wollman 
1168f708ef1bSPoul-Henning Kamp static void
1169892af6b9SRobert Watson unp_shutdown(struct unpcb *unp)
1170df8bae1dSRodney W. Grimes {
1171df8bae1dSRodney W. Grimes 	struct socket *so;
1172df8bae1dSRodney W. Grimes 
11730d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
11740d9ce3a1SRobert Watson 
1175df8bae1dSRodney W. Grimes 	if (unp->unp_socket->so_type == SOCK_STREAM && unp->unp_conn &&
1176df8bae1dSRodney W. Grimes 	    (so = unp->unp_conn->unp_socket))
1177df8bae1dSRodney W. Grimes 		socantrcvmore(so);
1178df8bae1dSRodney W. Grimes }
1179df8bae1dSRodney W. Grimes 
1180f708ef1bSPoul-Henning Kamp static void
1181892af6b9SRobert Watson unp_drop(struct unpcb *unp, int errno)
1182df8bae1dSRodney W. Grimes {
1183df8bae1dSRodney W. Grimes 	struct socket *so = unp->unp_socket;
1184df8bae1dSRodney W. Grimes 
11850d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
11860d9ce3a1SRobert Watson 
1187df8bae1dSRodney W. Grimes 	so->so_error = errno;
1188df8bae1dSRodney W. Grimes 	unp_disconnect(unp);
1189df8bae1dSRodney W. Grimes }
1190df8bae1dSRodney W. Grimes 
1191df8bae1dSRodney W. Grimes #ifdef notdef
119226f9a767SRodney W. Grimes void
1193892af6b9SRobert Watson unp_drain(void)
1194df8bae1dSRodney W. Grimes {
1195df8bae1dSRodney W. Grimes 
1196df8bae1dSRodney W. Grimes }
1197df8bae1dSRodney W. Grimes #endif
1198df8bae1dSRodney W. Grimes 
11992bc21ed9SDavid Malone static void
1200892af6b9SRobert Watson unp_freerights(struct file **rp, int fdcount)
1201df8bae1dSRodney W. Grimes {
12022bc21ed9SDavid Malone 	int i;
12032bc21ed9SDavid Malone 	struct file *fp;
1204df8bae1dSRodney W. Grimes 
12052bc21ed9SDavid Malone 	for (i = 0; i < fdcount; i++) {
1206df8bae1dSRodney W. Grimes 		fp = *rp;
12078692c025SYoshinobu Inoue 		/*
12082bc21ed9SDavid Malone 		 * zero the pointer before calling
12092bc21ed9SDavid Malone 		 * unp_discard since it may end up
12102bc21ed9SDavid Malone 		 * in unp_gc()..
1211d7dca903SRobert Watson 		 *
1212d7dca903SRobert Watson 		 * XXXRW: This is less true than it used to be.
12138692c025SYoshinobu Inoue 		 */
1214df8bae1dSRodney W. Grimes 		*rp++ = 0;
12158692c025SYoshinobu Inoue 		unp_discard(fp);
1216df8bae1dSRodney W. Grimes 	}
12172bc21ed9SDavid Malone }
12182bc21ed9SDavid Malone 
12192bc21ed9SDavid Malone int
1220892af6b9SRobert Watson unp_externalize(struct mbuf *control, struct mbuf **controlp)
12212bc21ed9SDavid Malone {
12222bc21ed9SDavid Malone 	struct thread *td = curthread;		/* XXX */
12232bc21ed9SDavid Malone 	struct cmsghdr *cm = mtod(control, struct cmsghdr *);
12242bc21ed9SDavid Malone 	int i;
12252bc21ed9SDavid Malone 	int *fdp;
12262bc21ed9SDavid Malone 	struct file **rp;
12272bc21ed9SDavid Malone 	struct file *fp;
12282bc21ed9SDavid Malone 	void *data;
12292bc21ed9SDavid Malone 	socklen_t clen = control->m_len, datalen;
12302bc21ed9SDavid Malone 	int error, newfds;
12312bc21ed9SDavid Malone 	int f;
12322bc21ed9SDavid Malone 	u_int newlen;
12332bc21ed9SDavid Malone 
12344c5bc1caSRobert Watson 	UNP_UNLOCK_ASSERT();
12354c5bc1caSRobert Watson 
12362bc21ed9SDavid Malone 	error = 0;
12372bc21ed9SDavid Malone 	if (controlp != NULL) /* controlp == NULL => free control messages */
12382bc21ed9SDavid Malone 		*controlp = NULL;
12392bc21ed9SDavid Malone 
12402bc21ed9SDavid Malone 	while (cm != NULL) {
12412bc21ed9SDavid Malone 		if (sizeof(*cm) > clen || cm->cmsg_len > clen) {
12422bc21ed9SDavid Malone 			error = EINVAL;
12432bc21ed9SDavid Malone 			break;
12442bc21ed9SDavid Malone 		}
12452bc21ed9SDavid Malone 
12462bc21ed9SDavid Malone 		data = CMSG_DATA(cm);
12472bc21ed9SDavid Malone 		datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
12482bc21ed9SDavid Malone 
12492bc21ed9SDavid Malone 		if (cm->cmsg_level == SOL_SOCKET
12502bc21ed9SDavid Malone 		    && cm->cmsg_type == SCM_RIGHTS) {
12512bc21ed9SDavid Malone 			newfds = datalen / sizeof(struct file *);
12522bc21ed9SDavid Malone 			rp = data;
12532bc21ed9SDavid Malone 
1254e2f9a08bSOlivier Houchard 			/* If we're not outputting the descriptors free them. */
12552bc21ed9SDavid Malone 			if (error || controlp == NULL) {
12562bc21ed9SDavid Malone 				unp_freerights(rp, newfds);
12572bc21ed9SDavid Malone 				goto next;
12582bc21ed9SDavid Malone 			}
1259426da3bcSAlfred Perlstein 			FILEDESC_LOCK(td->td_proc->p_fd);
12602bc21ed9SDavid Malone 			/* if the new FD's will not fit free them.  */
12612bc21ed9SDavid Malone 			if (!fdavail(td, newfds)) {
1262426da3bcSAlfred Perlstein 				FILEDESC_UNLOCK(td->td_proc->p_fd);
12632bc21ed9SDavid Malone 				error = EMSGSIZE;
12642bc21ed9SDavid Malone 				unp_freerights(rp, newfds);
12652bc21ed9SDavid Malone 				goto next;
1266df8bae1dSRodney W. Grimes 			}
1267ed5b7817SJulian Elischer 			/*
12682bc21ed9SDavid Malone 			 * now change each pointer to an fd in the global
12692bc21ed9SDavid Malone 			 * table to an integer that is the index to the
12702bc21ed9SDavid Malone 			 * local fd table entry that we set up to point
12712bc21ed9SDavid Malone 			 * to the global one we are transferring.
1272ed5b7817SJulian Elischer 			 */
12732bc21ed9SDavid Malone 			newlen = newfds * sizeof(int);
12742bc21ed9SDavid Malone 			*controlp = sbcreatecontrol(NULL, newlen,
12752bc21ed9SDavid Malone 			    SCM_RIGHTS, SOL_SOCKET);
12762bc21ed9SDavid Malone 			if (*controlp == NULL) {
1277426da3bcSAlfred Perlstein 				FILEDESC_UNLOCK(td->td_proc->p_fd);
12782bc21ed9SDavid Malone 				error = E2BIG;
12792bc21ed9SDavid Malone 				unp_freerights(rp, newfds);
12802bc21ed9SDavid Malone 				goto next;
12812bc21ed9SDavid Malone 			}
12822bc21ed9SDavid Malone 
12832bc21ed9SDavid Malone 			fdp = (int *)
12842bc21ed9SDavid Malone 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
1285df8bae1dSRodney W. Grimes 			for (i = 0; i < newfds; i++) {
1286a6d4491cSDag-Erling Smørgrav 				if (fdalloc(td, 0, &f))
12872bc21ed9SDavid Malone 					panic("unp_externalize fdalloc failed");
12888692c025SYoshinobu Inoue 				fp = *rp++;
1289b40ce416SJulian Elischer 				td->td_proc->p_fd->fd_ofiles[f] = fp;
1290426da3bcSAlfred Perlstein 				FILE_LOCK(fp);
1291df8bae1dSRodney W. Grimes 				fp->f_msgcount--;
1292426da3bcSAlfred Perlstein 				FILE_UNLOCK(fp);
1293df8bae1dSRodney W. Grimes 				unp_rights--;
12948692c025SYoshinobu Inoue 				*fdp++ = f;
1295df8bae1dSRodney W. Grimes 			}
1296426da3bcSAlfred Perlstein 			FILEDESC_UNLOCK(td->td_proc->p_fd);
12972bc21ed9SDavid Malone 		} else { /* We can just copy anything else across */
12982bc21ed9SDavid Malone 			if (error || controlp == NULL)
12992bc21ed9SDavid Malone 				goto next;
13002bc21ed9SDavid Malone 			*controlp = sbcreatecontrol(NULL, datalen,
13012bc21ed9SDavid Malone 			    cm->cmsg_type, cm->cmsg_level);
13022bc21ed9SDavid Malone 			if (*controlp == NULL) {
13032bc21ed9SDavid Malone 				error = ENOBUFS;
13042bc21ed9SDavid Malone 				goto next;
13052bc21ed9SDavid Malone 			}
13062bc21ed9SDavid Malone 			bcopy(data,
13072bc21ed9SDavid Malone 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *)),
13082bc21ed9SDavid Malone 			    datalen);
13092bc21ed9SDavid Malone 		}
13102bc21ed9SDavid Malone 
13112bc21ed9SDavid Malone 		controlp = &(*controlp)->m_next;
13122bc21ed9SDavid Malone 
13132bc21ed9SDavid Malone next:
13142bc21ed9SDavid Malone 		if (CMSG_SPACE(datalen) < clen) {
13152bc21ed9SDavid Malone 			clen -= CMSG_SPACE(datalen);
13162bc21ed9SDavid Malone 			cm = (struct cmsghdr *)
13172bc21ed9SDavid Malone 			    ((caddr_t)cm + CMSG_SPACE(datalen));
13188692c025SYoshinobu Inoue 		} else {
13192bc21ed9SDavid Malone 			clen = 0;
13202bc21ed9SDavid Malone 			cm = NULL;
13218692c025SYoshinobu Inoue 		}
13228692c025SYoshinobu Inoue 	}
13238692c025SYoshinobu Inoue 
13242bc21ed9SDavid Malone 	m_freem(control);
13252bc21ed9SDavid Malone 
13262bc21ed9SDavid Malone 	return (error);
1327df8bae1dSRodney W. Grimes }
1328df8bae1dSRodney W. Grimes 
13294f590175SPaul Saab static void
13304f590175SPaul Saab unp_zone_change(void *tag)
13314f590175SPaul Saab {
13324f590175SPaul Saab 
13334f590175SPaul Saab 	uma_zone_set_max(unp_zone, maxsockets);
13344f590175SPaul Saab }
13354f590175SPaul Saab 
133698271db4SGarrett Wollman void
133798271db4SGarrett Wollman unp_init(void)
133898271db4SGarrett Wollman {
13399e9d298aSJeff Roberson 	unp_zone = uma_zcreate("unpcb", sizeof(struct unpcb), NULL, NULL,
13409e9d298aSJeff Roberson 	    NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
1341fc3fcacfSRobert Watson 	if (unp_zone == NULL)
134298271db4SGarrett Wollman 		panic("unp_init");
13434f590175SPaul Saab 	uma_zone_set_max(unp_zone, maxsockets);
13444f590175SPaul Saab 	EVENTHANDLER_REGISTER(maxsockets_change, unp_zone_change,
13454f590175SPaul Saab 	    NULL, EVENTHANDLER_PRI_ANY);
134698271db4SGarrett Wollman 	LIST_INIT(&unp_dhead);
134798271db4SGarrett Wollman 	LIST_INIT(&unp_shead);
1348a0ec558aSRobert Watson 	TASK_INIT(&unp_gc_task, 0, unp_gc, NULL);
13490d9ce3a1SRobert Watson 	UNP_LOCK_INIT();
135098271db4SGarrett Wollman }
135198271db4SGarrett Wollman 
1352f708ef1bSPoul-Henning Kamp static int
1353892af6b9SRobert Watson unp_internalize(struct mbuf **controlp, struct thread *td)
1354df8bae1dSRodney W. Grimes {
13552bc21ed9SDavid Malone 	struct mbuf *control = *controlp;
1356b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
13578692c025SYoshinobu Inoue 	struct filedesc *fdescp = p->p_fd;
13582bc21ed9SDavid Malone 	struct cmsghdr *cm = mtod(control, struct cmsghdr *);
13592bc21ed9SDavid Malone 	struct cmsgcred *cmcred;
13602bc21ed9SDavid Malone 	struct file **rp;
13612bc21ed9SDavid Malone 	struct file *fp;
13622bc21ed9SDavid Malone 	struct timeval *tv;
13632bc21ed9SDavid Malone 	int i, fd, *fdp;
13642bc21ed9SDavid Malone 	void *data;
13652bc21ed9SDavid Malone 	socklen_t clen = control->m_len, datalen;
13662bc21ed9SDavid Malone 	int error, oldfds;
13678692c025SYoshinobu Inoue 	u_int newlen;
1368df8bae1dSRodney W. Grimes 
13694c5bc1caSRobert Watson 	UNP_UNLOCK_ASSERT();
13704c5bc1caSRobert Watson 
13712bc21ed9SDavid Malone 	error = 0;
13722bc21ed9SDavid Malone 	*controlp = NULL;
13730b788fa1SBill Paul 
13742bc21ed9SDavid Malone 	while (cm != NULL) {
13752bc21ed9SDavid Malone 		if (sizeof(*cm) > clen || cm->cmsg_level != SOL_SOCKET
13762bc21ed9SDavid Malone 		    || cm->cmsg_len > clen) {
13772bc21ed9SDavid Malone 			error = EINVAL;
13782bc21ed9SDavid Malone 			goto out;
13792bc21ed9SDavid Malone 		}
13802bc21ed9SDavid Malone 
13812bc21ed9SDavid Malone 		data = CMSG_DATA(cm);
13822bc21ed9SDavid Malone 		datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
13832bc21ed9SDavid Malone 
13842bc21ed9SDavid Malone 		switch (cm->cmsg_type) {
13850b788fa1SBill Paul 		/*
13860b788fa1SBill Paul 		 * Fill in credential information.
13870b788fa1SBill Paul 		 */
13882bc21ed9SDavid Malone 		case SCM_CREDS:
13892bc21ed9SDavid Malone 			*controlp = sbcreatecontrol(NULL, sizeof(*cmcred),
13902bc21ed9SDavid Malone 			    SCM_CREDS, SOL_SOCKET);
13912bc21ed9SDavid Malone 			if (*controlp == NULL) {
13922bc21ed9SDavid Malone 				error = ENOBUFS;
13932bc21ed9SDavid Malone 				goto out;
13942bc21ed9SDavid Malone 			}
13952bc21ed9SDavid Malone 
13962bc21ed9SDavid Malone 			cmcred = (struct cmsgcred *)
13972bc21ed9SDavid Malone 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
13980b788fa1SBill Paul 			cmcred->cmcred_pid = p->p_pid;
1399a854ed98SJohn Baldwin 			cmcred->cmcred_uid = td->td_ucred->cr_ruid;
1400a854ed98SJohn Baldwin 			cmcred->cmcred_gid = td->td_ucred->cr_rgid;
1401a854ed98SJohn Baldwin 			cmcred->cmcred_euid = td->td_ucred->cr_uid;
1402a854ed98SJohn Baldwin 			cmcred->cmcred_ngroups = MIN(td->td_ucred->cr_ngroups,
14030b788fa1SBill Paul 							CMGROUP_MAX);
14040b788fa1SBill Paul 			for (i = 0; i < cmcred->cmcred_ngroups; i++)
14052bc21ed9SDavid Malone 				cmcred->cmcred_groups[i] =
1406a854ed98SJohn Baldwin 				    td->td_ucred->cr_groups[i];
14072bc21ed9SDavid Malone 			break;
14080b788fa1SBill Paul 
14092bc21ed9SDavid Malone 		case SCM_RIGHTS:
14102bc21ed9SDavid Malone 			oldfds = datalen / sizeof (int);
1411ed5b7817SJulian Elischer 			/*
14122bc21ed9SDavid Malone 			 * check that all the FDs passed in refer to legal files
1413ed5b7817SJulian Elischer 			 * If not, reject the entire operation.
1414ed5b7817SJulian Elischer 			 */
14152bc21ed9SDavid Malone 			fdp = data;
1416426da3bcSAlfred Perlstein 			FILEDESC_LOCK(fdescp);
1417df8bae1dSRodney W. Grimes 			for (i = 0; i < oldfds; i++) {
14188692c025SYoshinobu Inoue 				fd = *fdp++;
14198692c025SYoshinobu Inoue 				if ((unsigned)fd >= fdescp->fd_nfiles ||
14202bc21ed9SDavid Malone 				    fdescp->fd_ofiles[fd] == NULL) {
1421426da3bcSAlfred Perlstein 					FILEDESC_UNLOCK(fdescp);
14222bc21ed9SDavid Malone 					error = EBADF;
14232bc21ed9SDavid Malone 					goto out;
14242bc21ed9SDavid Malone 				}
1425e7d6662fSAlfred Perlstein 				fp = fdescp->fd_ofiles[fd];
1426e7d6662fSAlfred Perlstein 				if (!(fp->f_ops->fo_flags & DFLAG_PASSABLE)) {
1427e7d6662fSAlfred Perlstein 					FILEDESC_UNLOCK(fdescp);
1428e7d6662fSAlfred Perlstein 					error = EOPNOTSUPP;
1429e7d6662fSAlfred Perlstein 					goto out;
1430e7d6662fSAlfred Perlstein 				}
1431e7d6662fSAlfred Perlstein 
1432df8bae1dSRodney W. Grimes 			}
1433ed5b7817SJulian Elischer 			/*
1434ed5b7817SJulian Elischer 			 * Now replace the integer FDs with pointers to
1435ed5b7817SJulian Elischer 			 * the associated global file table entry..
1436ed5b7817SJulian Elischer 			 */
14372bc21ed9SDavid Malone 			newlen = oldfds * sizeof(struct file *);
14382bc21ed9SDavid Malone 			*controlp = sbcreatecontrol(NULL, newlen,
14392bc21ed9SDavid Malone 			    SCM_RIGHTS, SOL_SOCKET);
14402bc21ed9SDavid Malone 			if (*controlp == NULL) {
1441426da3bcSAlfred Perlstein 				FILEDESC_UNLOCK(fdescp);
14422bc21ed9SDavid Malone 				error = E2BIG;
14432bc21ed9SDavid Malone 				goto out;
14448692c025SYoshinobu Inoue 			}
14458692c025SYoshinobu Inoue 
14462bc21ed9SDavid Malone 			fdp = data;
14472bc21ed9SDavid Malone 			rp = (struct file **)
14482bc21ed9SDavid Malone 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
14498692c025SYoshinobu Inoue 			for (i = 0; i < oldfds; i++) {
14508692c025SYoshinobu Inoue 				fp = fdescp->fd_ofiles[*fdp++];
1451df8bae1dSRodney W. Grimes 				*rp++ = fp;
1452426da3bcSAlfred Perlstein 				FILE_LOCK(fp);
1453df8bae1dSRodney W. Grimes 				fp->f_count++;
1454df8bae1dSRodney W. Grimes 				fp->f_msgcount++;
1455426da3bcSAlfred Perlstein 				FILE_UNLOCK(fp);
1456df8bae1dSRodney W. Grimes 				unp_rights++;
1457df8bae1dSRodney W. Grimes 			}
1458426da3bcSAlfred Perlstein 			FILEDESC_UNLOCK(fdescp);
14592bc21ed9SDavid Malone 			break;
14602bc21ed9SDavid Malone 
14612bc21ed9SDavid Malone 		case SCM_TIMESTAMP:
14622bc21ed9SDavid Malone 			*controlp = sbcreatecontrol(NULL, sizeof(*tv),
14632bc21ed9SDavid Malone 			    SCM_TIMESTAMP, SOL_SOCKET);
14642bc21ed9SDavid Malone 			if (*controlp == NULL) {
14652bc21ed9SDavid Malone 				error = ENOBUFS;
14662bc21ed9SDavid Malone 				goto out;
14678692c025SYoshinobu Inoue 			}
14682bc21ed9SDavid Malone 			tv = (struct timeval *)
14692bc21ed9SDavid Malone 			    CMSG_DATA(mtod(*controlp, struct cmsghdr *));
14702bc21ed9SDavid Malone 			microtime(tv);
14712bc21ed9SDavid Malone 			break;
14722bc21ed9SDavid Malone 
14732bc21ed9SDavid Malone 		default:
14742bc21ed9SDavid Malone 			error = EINVAL;
14752bc21ed9SDavid Malone 			goto out;
14762bc21ed9SDavid Malone 		}
14772bc21ed9SDavid Malone 
14782bc21ed9SDavid Malone 		controlp = &(*controlp)->m_next;
14792bc21ed9SDavid Malone 
14802bc21ed9SDavid Malone 		if (CMSG_SPACE(datalen) < clen) {
14812bc21ed9SDavid Malone 			clen -= CMSG_SPACE(datalen);
14822bc21ed9SDavid Malone 			cm = (struct cmsghdr *)
14832bc21ed9SDavid Malone 			    ((caddr_t)cm + CMSG_SPACE(datalen));
14842bc21ed9SDavid Malone 		} else {
14852bc21ed9SDavid Malone 			clen = 0;
14862bc21ed9SDavid Malone 			cm = NULL;
14872bc21ed9SDavid Malone 		}
14882bc21ed9SDavid Malone 	}
14892bc21ed9SDavid Malone 
14902bc21ed9SDavid Malone out:
14912bc21ed9SDavid Malone 	m_freem(control);
14922bc21ed9SDavid Malone 
14932bc21ed9SDavid Malone 	return (error);
1494df8bae1dSRodney W. Grimes }
1495df8bae1dSRodney W. Grimes 
14966a2989fdSMatthew N. Dodd struct mbuf *
14976a2989fdSMatthew N. Dodd unp_addsockcred(struct thread *td, struct mbuf *control)
14986a2989fdSMatthew N. Dodd {
14996a2989fdSMatthew N. Dodd 	struct mbuf *m, *n;
15006a2989fdSMatthew N. Dodd 	struct sockcred *sc;
15016a2989fdSMatthew N. Dodd 	int ngroups;
15026a2989fdSMatthew N. Dodd 	int i;
15036a2989fdSMatthew N. Dodd 
15046a2989fdSMatthew N. Dodd 	ngroups = MIN(td->td_ucred->cr_ngroups, CMGROUP_MAX);
15056a2989fdSMatthew N. Dodd 
15066a2989fdSMatthew N. Dodd 	m = sbcreatecontrol(NULL, SOCKCREDSIZE(ngroups), SCM_CREDS, SOL_SOCKET);
15076a2989fdSMatthew N. Dodd 	if (m == NULL)
15086a2989fdSMatthew N. Dodd 		return (control);
15096a2989fdSMatthew N. Dodd 	m->m_next = NULL;
15106a2989fdSMatthew N. Dodd 
15116a2989fdSMatthew N. Dodd 	sc = (struct sockcred *) CMSG_DATA(mtod(m, struct cmsghdr *));
15126a2989fdSMatthew N. Dodd 	sc->sc_uid = td->td_ucred->cr_ruid;
15136a2989fdSMatthew N. Dodd 	sc->sc_euid = td->td_ucred->cr_uid;
15146a2989fdSMatthew N. Dodd 	sc->sc_gid = td->td_ucred->cr_rgid;
15156a2989fdSMatthew N. Dodd 	sc->sc_egid = td->td_ucred->cr_gid;
15166a2989fdSMatthew N. Dodd 	sc->sc_ngroups = ngroups;
15176a2989fdSMatthew N. Dodd 	for (i = 0; i < sc->sc_ngroups; i++)
15186a2989fdSMatthew N. Dodd 		sc->sc_groups[i] = td->td_ucred->cr_groups[i];
15196a2989fdSMatthew N. Dodd 
15206a2989fdSMatthew N. Dodd 	/*
15216a2989fdSMatthew N. Dodd 	 * If a control message already exists, append us to the end.
15226a2989fdSMatthew N. Dodd 	 */
15236a2989fdSMatthew N. Dodd 	if (control != NULL) {
15246a2989fdSMatthew N. Dodd 		for (n = control; n->m_next != NULL; n = n->m_next)
15256a2989fdSMatthew N. Dodd 			;
15266a2989fdSMatthew N. Dodd 		n->m_next = m;
15276a2989fdSMatthew N. Dodd 	} else
15286a2989fdSMatthew N. Dodd 		control = m;
15296a2989fdSMatthew N. Dodd 
15306a2989fdSMatthew N. Dodd 	return (control);
15316a2989fdSMatthew N. Dodd }
15326a2989fdSMatthew N. Dodd 
1533161a0c7cSRobert Watson /*
1534a0ec558aSRobert Watson  * unp_defer indicates whether additional work has been defered for a future
1535a0ec558aSRobert Watson  * pass through unp_gc().  It is thread local and does not require explicit
1536a0ec558aSRobert Watson  * synchronization.
1537161a0c7cSRobert Watson  */
1538a0ec558aSRobert Watson static int	unp_defer;
1539a0ec558aSRobert Watson 
1540a0ec558aSRobert Watson static int unp_taskcount;
1541a0ec558aSRobert Watson SYSCTL_INT(_net_local, OID_AUTO, taskcount, CTLFLAG_RD, &unp_taskcount, 0, "");
1542a0ec558aSRobert Watson 
1543a0ec558aSRobert Watson static int unp_recycled;
1544a0ec558aSRobert Watson SYSCTL_INT(_net_local, OID_AUTO, recycled, CTLFLAG_RD, &unp_recycled, 0, "");
1545df8bae1dSRodney W. Grimes 
1546f708ef1bSPoul-Henning Kamp static void
1547a0ec558aSRobert Watson unp_gc(__unused void *arg, int pending)
1548df8bae1dSRodney W. Grimes {
1549892af6b9SRobert Watson 	struct file *fp, *nextfp;
1550892af6b9SRobert Watson 	struct socket *so;
1551df8bae1dSRodney W. Grimes 	struct file **extra_ref, **fpp;
1552df8bae1dSRodney W. Grimes 	int nunref, i;
155395f004dcSAlfred Perlstein 	int nfiles_snap;
155495f004dcSAlfred Perlstein 	int nfiles_slack = 20;
1555df8bae1dSRodney W. Grimes 
1556a0ec558aSRobert Watson 	unp_taskcount++;
1557df8bae1dSRodney W. Grimes 	unp_defer = 0;
1558ed5b7817SJulian Elischer 	/*
1559ed5b7817SJulian Elischer 	 * before going through all this, set all FDs to
1560ed5b7817SJulian Elischer 	 * be NOT defered and NOT externally accessible
1561ed5b7817SJulian Elischer 	 */
1562426da3bcSAlfred Perlstein 	sx_slock(&filelist_lock);
15632e3c8fcbSPoul-Henning Kamp 	LIST_FOREACH(fp, &filehead, f_list)
1564426da3bcSAlfred Perlstein 		fp->f_gcflag &= ~(FMARK|FDEFER);
1565df8bae1dSRodney W. Grimes 	do {
15665bb84bc8SRobert Watson 		KASSERT(unp_defer >= 0, ("unp_gc: unp_defer %d", unp_defer));
15672e3c8fcbSPoul-Henning Kamp 		LIST_FOREACH(fp, &filehead, f_list) {
1568426da3bcSAlfred Perlstein 			FILE_LOCK(fp);
1569ed5b7817SJulian Elischer 			/*
1570a0ec558aSRobert Watson 			 * If the file is not open, skip it -- could be a
1571a0ec558aSRobert Watson 			 * file in the process of being opened, or in the
1572a0ec558aSRobert Watson 			 * process of being closed.  If the file is
1573a0ec558aSRobert Watson 			 * "closing", it may have been marked for deferred
1574a0ec558aSRobert Watson 			 * consideration.  Clear the flag now if so.
1575ed5b7817SJulian Elischer 			 */
1576426da3bcSAlfred Perlstein 			if (fp->f_count == 0) {
1577a0ec558aSRobert Watson 				if (fp->f_gcflag & FDEFER)
1578a0ec558aSRobert Watson 					unp_defer--;
1579a0ec558aSRobert Watson 				fp->f_gcflag &= ~(FMARK|FDEFER);
1580426da3bcSAlfred Perlstein 				FILE_UNLOCK(fp);
1581df8bae1dSRodney W. Grimes 				continue;
1582426da3bcSAlfred Perlstein 			}
1583ed5b7817SJulian Elischer 			/*
1584ed5b7817SJulian Elischer 			 * If we already marked it as 'defer'  in a
1585ed5b7817SJulian Elischer 			 * previous pass, then try process it this time
1586ed5b7817SJulian Elischer 			 * and un-mark it
1587ed5b7817SJulian Elischer 			 */
1588426da3bcSAlfred Perlstein 			if (fp->f_gcflag & FDEFER) {
1589426da3bcSAlfred Perlstein 				fp->f_gcflag &= ~FDEFER;
1590df8bae1dSRodney W. Grimes 				unp_defer--;
1591df8bae1dSRodney W. Grimes 			} else {
1592ed5b7817SJulian Elischer 				/*
1593ed5b7817SJulian Elischer 				 * if it's not defered, then check if it's
1594ed5b7817SJulian Elischer 				 * already marked.. if so skip it
1595ed5b7817SJulian Elischer 				 */
1596426da3bcSAlfred Perlstein 				if (fp->f_gcflag & FMARK) {
1597426da3bcSAlfred Perlstein 					FILE_UNLOCK(fp);
1598df8bae1dSRodney W. Grimes 					continue;
1599426da3bcSAlfred Perlstein 				}
1600ed5b7817SJulian Elischer 				/*
1601ed5b7817SJulian Elischer 				 * If all references are from messages
1602ed5b7817SJulian Elischer 				 * in transit, then skip it. it's not
1603ed5b7817SJulian Elischer 				 * externally accessible.
1604ed5b7817SJulian Elischer 				 */
1605426da3bcSAlfred Perlstein 				if (fp->f_count == fp->f_msgcount) {
1606426da3bcSAlfred Perlstein 					FILE_UNLOCK(fp);
1607df8bae1dSRodney W. Grimes 					continue;
1608426da3bcSAlfred Perlstein 				}
1609ed5b7817SJulian Elischer 				/*
1610ed5b7817SJulian Elischer 				 * If it got this far then it must be
1611ed5b7817SJulian Elischer 				 * externally accessible.
1612ed5b7817SJulian Elischer 				 */
1613426da3bcSAlfred Perlstein 				fp->f_gcflag |= FMARK;
1614df8bae1dSRodney W. Grimes 			}
1615ed5b7817SJulian Elischer 			/*
1616ed5b7817SJulian Elischer 			 * either it was defered, or it is externally
1617ed5b7817SJulian Elischer 			 * accessible and not already marked so.
1618ed5b7817SJulian Elischer 			 * Now check if it is possibly one of OUR sockets.
1619ed5b7817SJulian Elischer 			 */
1620df8bae1dSRodney W. Grimes 			if (fp->f_type != DTYPE_SOCKET ||
162148e3128bSMatthew Dillon 			    (so = fp->f_data) == NULL) {
1622426da3bcSAlfred Perlstein 				FILE_UNLOCK(fp);
1623df8bae1dSRodney W. Grimes 				continue;
1624426da3bcSAlfred Perlstein 			}
1625426da3bcSAlfred Perlstein 			FILE_UNLOCK(fp);
1626748e0b0aSGarrett Wollman 			if (so->so_proto->pr_domain != &localdomain ||
1627df8bae1dSRodney W. Grimes 			    (so->so_proto->pr_flags&PR_RIGHTS) == 0)
1628df8bae1dSRodney W. Grimes 				continue;
1629ed5b7817SJulian Elischer 			/*
1630ed5b7817SJulian Elischer 			 * So, Ok, it's one of our sockets and it IS externally
1631ed5b7817SJulian Elischer 			 * accessible (or was defered). Now we look
1632dc733423SDag-Erling Smørgrav 			 * to see if we hold any file descriptors in its
1633ed5b7817SJulian Elischer 			 * message buffers. Follow those links and mark them
1634ed5b7817SJulian Elischer 			 * as accessible too.
1635ed5b7817SJulian Elischer 			 */
16367717cf07SRobert Watson 			SOCKBUF_LOCK(&so->so_rcv);
1637df8bae1dSRodney W. Grimes 			unp_scan(so->so_rcv.sb_mb, unp_mark);
16387717cf07SRobert Watson 			SOCKBUF_UNLOCK(&so->so_rcv);
1639df8bae1dSRodney W. Grimes 		}
1640df8bae1dSRodney W. Grimes 	} while (unp_defer);
1641426da3bcSAlfred Perlstein 	sx_sunlock(&filelist_lock);
1642df8bae1dSRodney W. Grimes 	/*
1643a0ec558aSRobert Watson 	 * XXXRW: The following comments need updating for a post-SMPng and
1644a0ec558aSRobert Watson 	 * deferred unp_gc() world, but are still generally accurate.
1645a0ec558aSRobert Watson 	 *
1646df8bae1dSRodney W. Grimes 	 * We grab an extra reference to each of the file table entries
1647df8bae1dSRodney W. Grimes 	 * that are not otherwise accessible and then free the rights
1648df8bae1dSRodney W. Grimes 	 * that are stored in messages on them.
1649df8bae1dSRodney W. Grimes 	 *
1650df8bae1dSRodney W. Grimes 	 * The bug in the orginal code is a little tricky, so I'll describe
1651df8bae1dSRodney W. Grimes 	 * what's wrong with it here.
1652df8bae1dSRodney W. Grimes 	 *
1653df8bae1dSRodney W. Grimes 	 * It is incorrect to simply unp_discard each entry for f_msgcount
1654df8bae1dSRodney W. Grimes 	 * times -- consider the case of sockets A and B that contain
1655df8bae1dSRodney W. Grimes 	 * references to each other.  On a last close of some other socket,
1656df8bae1dSRodney W. Grimes 	 * we trigger a gc since the number of outstanding rights (unp_rights)
1657a0ec558aSRobert Watson 	 * is non-zero.  If during the sweep phase the gc code unp_discards,
1658df8bae1dSRodney W. Grimes 	 * we end up doing a (full) closef on the descriptor.  A closef on A
1659df8bae1dSRodney W. Grimes 	 * results in the following chain.  Closef calls soo_close, which
1660df8bae1dSRodney W. Grimes 	 * calls soclose.   Soclose calls first (through the switch
1661df8bae1dSRodney W. Grimes 	 * uipc_usrreq) unp_detach, which re-invokes unp_gc.  Unp_gc simply
1662df8bae1dSRodney W. Grimes 	 * returns because the previous instance had set unp_gcing, and
1663df8bae1dSRodney W. Grimes 	 * we return all the way back to soclose, which marks the socket
1664df8bae1dSRodney W. Grimes 	 * with SS_NOFDREF, and then calls sofree.  Sofree calls sorflush
1665df8bae1dSRodney W. Grimes 	 * to free up the rights that are queued in messages on the socket A,
1666df8bae1dSRodney W. Grimes 	 * i.e., the reference on B.  The sorflush calls via the dom_dispose
1667df8bae1dSRodney W. Grimes 	 * switch unp_dispose, which unp_scans with unp_discard.  This second
1668df8bae1dSRodney W. Grimes 	 * instance of unp_discard just calls closef on B.
1669df8bae1dSRodney W. Grimes 	 *
1670df8bae1dSRodney W. Grimes 	 * Well, a similar chain occurs on B, resulting in a sorflush on B,
1671df8bae1dSRodney W. Grimes 	 * which results in another closef on A.  Unfortunately, A is already
1672df8bae1dSRodney W. Grimes 	 * being closed, and the descriptor has already been marked with
1673df8bae1dSRodney W. Grimes 	 * SS_NOFDREF, and soclose panics at this point.
1674df8bae1dSRodney W. Grimes 	 *
1675df8bae1dSRodney W. Grimes 	 * Here, we first take an extra reference to each inaccessible
1676df8bae1dSRodney W. Grimes 	 * descriptor.  Then, we call sorflush ourself, since we know
1677df8bae1dSRodney W. Grimes 	 * it is a Unix domain socket anyhow.  After we destroy all the
1678df8bae1dSRodney W. Grimes 	 * rights carried in messages, we do a last closef to get rid
1679df8bae1dSRodney W. Grimes 	 * of our extra reference.  This is the last close, and the
1680df8bae1dSRodney W. Grimes 	 * unp_detach etc will shut down the socket.
1681df8bae1dSRodney W. Grimes 	 *
1682df8bae1dSRodney W. Grimes 	 * 91/09/19, bsy@cs.cmu.edu
1683df8bae1dSRodney W. Grimes 	 */
168495f004dcSAlfred Perlstein again:
1685e4643c73SPoul-Henning Kamp 	nfiles_snap = openfiles + nfiles_slack;	/* some slack */
168695f004dcSAlfred Perlstein 	extra_ref = malloc(nfiles_snap * sizeof(struct file *), M_TEMP,
168795f004dcSAlfred Perlstein 	    M_WAITOK);
1688426da3bcSAlfred Perlstein 	sx_slock(&filelist_lock);
1689e4643c73SPoul-Henning Kamp 	if (nfiles_snap < openfiles) {
169095f004dcSAlfred Perlstein 		sx_sunlock(&filelist_lock);
169195f004dcSAlfred Perlstein 		free(extra_ref, M_TEMP);
169295f004dcSAlfred Perlstein 		nfiles_slack += 20;
169395f004dcSAlfred Perlstein 		goto again;
169495f004dcSAlfred Perlstein 	}
1695fc3fcacfSRobert Watson 	for (nunref = 0, fp = LIST_FIRST(&filehead), fpp = extra_ref;
1696fc3fcacfSRobert Watson 	    fp != NULL; fp = nextfp) {
16972e3c8fcbSPoul-Henning Kamp 		nextfp = LIST_NEXT(fp, f_list);
1698426da3bcSAlfred Perlstein 		FILE_LOCK(fp);
1699ed5b7817SJulian Elischer 		/*
1700ed5b7817SJulian Elischer 		 * If it's not open, skip it
1701ed5b7817SJulian Elischer 		 */
1702426da3bcSAlfred Perlstein 		if (fp->f_count == 0) {
1703426da3bcSAlfred Perlstein 			FILE_UNLOCK(fp);
1704df8bae1dSRodney W. Grimes 			continue;
1705426da3bcSAlfred Perlstein 		}
1706ed5b7817SJulian Elischer 		/*
1707ed5b7817SJulian Elischer 		 * If all refs are from msgs, and it's not marked accessible
1708ed5b7817SJulian Elischer 		 * then it must be referenced from some unreachable cycle
1709ed5b7817SJulian Elischer 		 * of (shut-down) FDs, so include it in our
1710ed5b7817SJulian Elischer 		 * list of FDs to remove
1711ed5b7817SJulian Elischer 		 */
1712426da3bcSAlfred Perlstein 		if (fp->f_count == fp->f_msgcount && !(fp->f_gcflag & FMARK)) {
1713df8bae1dSRodney W. Grimes 			*fpp++ = fp;
1714df8bae1dSRodney W. Grimes 			nunref++;
1715df8bae1dSRodney W. Grimes 			fp->f_count++;
1716df8bae1dSRodney W. Grimes 		}
1717426da3bcSAlfred Perlstein 		FILE_UNLOCK(fp);
1718df8bae1dSRodney W. Grimes 	}
1719426da3bcSAlfred Perlstein 	sx_sunlock(&filelist_lock);
1720ed5b7817SJulian Elischer 	/*
1721ed5b7817SJulian Elischer 	 * for each FD on our hit list, do the following two things
1722ed5b7817SJulian Elischer 	 */
17231c7c3c6aSMatthew Dillon 	for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp) {
17241c7c3c6aSMatthew Dillon 		struct file *tfp = *fpp;
1725426da3bcSAlfred Perlstein 		FILE_LOCK(tfp);
1726cd72f218SMatthew Dillon 		if (tfp->f_type == DTYPE_SOCKET &&
172748e3128bSMatthew Dillon 		    tfp->f_data != NULL) {
1728426da3bcSAlfred Perlstein 			FILE_UNLOCK(tfp);
172948e3128bSMatthew Dillon 			sorflush(tfp->f_data);
1730e5aeaa0cSDag-Erling Smørgrav 		} else {
1731426da3bcSAlfred Perlstein 			FILE_UNLOCK(tfp);
17321c7c3c6aSMatthew Dillon 		}
1733e5aeaa0cSDag-Erling Smørgrav 	}
1734a0ec558aSRobert Watson 	for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp) {
1735b40ce416SJulian Elischer 		closef(*fpp, (struct thread *) NULL);
1736a0ec558aSRobert Watson 		unp_recycled++;
1737a0ec558aSRobert Watson 	}
1738210a5a71SAlfred Perlstein 	free(extra_ref, M_TEMP);
1739df8bae1dSRodney W. Grimes }
1740df8bae1dSRodney W. Grimes 
174126f9a767SRodney W. Grimes void
1742892af6b9SRobert Watson unp_dispose(struct mbuf *m)
1743df8bae1dSRodney W. Grimes {
1744996c772fSJohn Dyson 
1745df8bae1dSRodney W. Grimes 	if (m)
1746df8bae1dSRodney W. Grimes 		unp_scan(m, unp_discard);
1747df8bae1dSRodney W. Grimes }
1748df8bae1dSRodney W. Grimes 
17490c1bb4fbSDima Dorfman static int
1750d374e81eSRobert Watson unp_listen(struct socket *so, struct unpcb *unp, int backlog,
1751d374e81eSRobert Watson     struct thread *td)
17520c1bb4fbSDima Dorfman {
17530daccb9cSRobert Watson 	int error;
17540daccb9cSRobert Watson 
17550d9ce3a1SRobert Watson 	UNP_LOCK_ASSERT();
17560c1bb4fbSDima Dorfman 
17570daccb9cSRobert Watson 	SOCK_LOCK(so);
17580daccb9cSRobert Watson 	error = solisten_proto_check(so);
17590daccb9cSRobert Watson 	if (error == 0) {
17606f105b34SJohn Baldwin 		cru2x(td->td_ucred, &unp->unp_peercred);
17610c1bb4fbSDima Dorfman 		unp->unp_flags |= UNP_HAVEPCCACHED;
1762d374e81eSRobert Watson 		solisten_proto(so, backlog);
17630daccb9cSRobert Watson 	}
17640daccb9cSRobert Watson 	SOCK_UNLOCK(so);
17650daccb9cSRobert Watson 	return (error);
17660c1bb4fbSDima Dorfman }
17670c1bb4fbSDima Dorfman 
1768f708ef1bSPoul-Henning Kamp static void
1769892af6b9SRobert Watson unp_scan(struct mbuf *m0, void (*op)(struct file *))
1770df8bae1dSRodney W. Grimes {
17712bc21ed9SDavid Malone 	struct mbuf *m;
17722bc21ed9SDavid Malone 	struct file **rp;
17732bc21ed9SDavid Malone 	struct cmsghdr *cm;
17742bc21ed9SDavid Malone 	void *data;
17752bc21ed9SDavid Malone 	int i;
17762bc21ed9SDavid Malone 	socklen_t clen, datalen;
1777df8bae1dSRodney W. Grimes 	int qfds;
1778df8bae1dSRodney W. Grimes 
1779fc3fcacfSRobert Watson 	while (m0 != NULL) {
17802bc21ed9SDavid Malone 		for (m = m0; m; m = m->m_next) {
178112396bdcSDavid Malone 			if (m->m_type != MT_CONTROL)
1782df8bae1dSRodney W. Grimes 				continue;
17832bc21ed9SDavid Malone 
17842bc21ed9SDavid Malone 			cm = mtod(m, struct cmsghdr *);
17852bc21ed9SDavid Malone 			clen = m->m_len;
17862bc21ed9SDavid Malone 
17872bc21ed9SDavid Malone 			while (cm != NULL) {
17882bc21ed9SDavid Malone 				if (sizeof(*cm) > clen || cm->cmsg_len > clen)
17892bc21ed9SDavid Malone 					break;
17902bc21ed9SDavid Malone 
17912bc21ed9SDavid Malone 				data = CMSG_DATA(cm);
17922bc21ed9SDavid Malone 				datalen = (caddr_t)cm + cm->cmsg_len
17932bc21ed9SDavid Malone 				    - (caddr_t)data;
17942bc21ed9SDavid Malone 
17952bc21ed9SDavid Malone 				if (cm->cmsg_level == SOL_SOCKET &&
17962bc21ed9SDavid Malone 				    cm->cmsg_type == SCM_RIGHTS) {
17972bc21ed9SDavid Malone 					qfds = datalen / sizeof (struct file *);
17982bc21ed9SDavid Malone 					rp = data;
1799df8bae1dSRodney W. Grimes 					for (i = 0; i < qfds; i++)
1800df8bae1dSRodney W. Grimes 						(*op)(*rp++);
18012bc21ed9SDavid Malone 				}
18022bc21ed9SDavid Malone 
18032bc21ed9SDavid Malone 				if (CMSG_SPACE(datalen) < clen) {
18042bc21ed9SDavid Malone 					clen -= CMSG_SPACE(datalen);
18052bc21ed9SDavid Malone 					cm = (struct cmsghdr *)
18062bc21ed9SDavid Malone 					    ((caddr_t)cm + CMSG_SPACE(datalen));
18072bc21ed9SDavid Malone 				} else {
18082bc21ed9SDavid Malone 					clen = 0;
18092bc21ed9SDavid Malone 					cm = NULL;
18102bc21ed9SDavid Malone 				}
18112bc21ed9SDavid Malone 			}
1812df8bae1dSRodney W. Grimes 		}
1813df8bae1dSRodney W. Grimes 		m0 = m0->m_act;
1814df8bae1dSRodney W. Grimes 	}
1815df8bae1dSRodney W. Grimes }
1816df8bae1dSRodney W. Grimes 
1817f708ef1bSPoul-Henning Kamp static void
1818892af6b9SRobert Watson unp_mark(struct file *fp)
1819df8bae1dSRodney W. Grimes {
1820426da3bcSAlfred Perlstein 	if (fp->f_gcflag & FMARK)
1821df8bae1dSRodney W. Grimes 		return;
1822df8bae1dSRodney W. Grimes 	unp_defer++;
1823426da3bcSAlfred Perlstein 	fp->f_gcflag |= (FMARK|FDEFER);
1824df8bae1dSRodney W. Grimes }
1825df8bae1dSRodney W. Grimes 
1826f708ef1bSPoul-Henning Kamp static void
1827892af6b9SRobert Watson unp_discard(struct file *fp)
1828df8bae1dSRodney W. Grimes {
1829a0ec558aSRobert Watson 	UNP_LOCK();
1830426da3bcSAlfred Perlstein 	FILE_LOCK(fp);
1831df8bae1dSRodney W. Grimes 	fp->f_msgcount--;
1832df8bae1dSRodney W. Grimes 	unp_rights--;
1833426da3bcSAlfred Perlstein 	FILE_UNLOCK(fp);
1834a0ec558aSRobert Watson 	UNP_UNLOCK();
1835b40ce416SJulian Elischer 	(void) closef(fp, (struct thread *)NULL);
1836df8bae1dSRodney W. Grimes }
1837