uipc_usrreq.c revision 1.70 1 1.70 hannken /* $NetBSD: uipc_usrreq.c,v 1.70 2003/10/15 11:29:01 hannken Exp $ */
2 1.30 thorpej
3 1.30 thorpej /*-
4 1.47 thorpej * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc.
5 1.30 thorpej * All rights reserved.
6 1.30 thorpej *
7 1.30 thorpej * This code is derived from software contributed to The NetBSD Foundation
8 1.30 thorpej * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 1.30 thorpej * NASA Ames Research Center.
10 1.30 thorpej *
11 1.30 thorpej * Redistribution and use in source and binary forms, with or without
12 1.30 thorpej * modification, are permitted provided that the following conditions
13 1.30 thorpej * are met:
14 1.30 thorpej * 1. Redistributions of source code must retain the above copyright
15 1.30 thorpej * notice, this list of conditions and the following disclaimer.
16 1.30 thorpej * 2. Redistributions in binary form must reproduce the above copyright
17 1.30 thorpej * notice, this list of conditions and the following disclaimer in the
18 1.30 thorpej * documentation and/or other materials provided with the distribution.
19 1.30 thorpej * 3. All advertising materials mentioning features or use of this software
20 1.30 thorpej * must display the following acknowledgement:
21 1.30 thorpej * This product includes software developed by the NetBSD
22 1.30 thorpej * Foundation, Inc. and its contributors.
23 1.30 thorpej * 4. Neither the name of The NetBSD Foundation nor the names of its
24 1.30 thorpej * contributors may be used to endorse or promote products derived
25 1.30 thorpej * from this software without specific prior written permission.
26 1.30 thorpej *
27 1.30 thorpej * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 1.30 thorpej * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 1.30 thorpej * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 1.30 thorpej * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 1.30 thorpej * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 1.30 thorpej * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 1.30 thorpej * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 1.30 thorpej * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 1.30 thorpej * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 1.30 thorpej * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 1.30 thorpej * POSSIBILITY OF SUCH DAMAGE.
38 1.30 thorpej */
39 1.10 cgd
40 1.1 cgd /*
41 1.8 mycroft * Copyright (c) 1982, 1986, 1989, 1991, 1993
42 1.8 mycroft * The Regents of the University of California. All rights reserved.
43 1.1 cgd *
44 1.1 cgd * Redistribution and use in source and binary forms, with or without
45 1.1 cgd * modification, are permitted provided that the following conditions
46 1.1 cgd * are met:
47 1.1 cgd * 1. Redistributions of source code must retain the above copyright
48 1.1 cgd * notice, this list of conditions and the following disclaimer.
49 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
50 1.1 cgd * notice, this list of conditions and the following disclaimer in the
51 1.1 cgd * documentation and/or other materials provided with the distribution.
52 1.67 agc * 3. Neither the name of the University nor the names of its contributors
53 1.67 agc * may be used to endorse or promote products derived from this software
54 1.67 agc * without specific prior written permission.
55 1.67 agc *
56 1.67 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
57 1.67 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
58 1.67 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
59 1.67 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
60 1.67 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
61 1.67 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
62 1.67 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63 1.67 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
64 1.67 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
65 1.67 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
66 1.67 agc * SUCH DAMAGE.
67 1.67 agc *
68 1.67 agc * @(#)uipc_usrreq.c 8.9 (Berkeley) 5/14/95
69 1.67 agc */
70 1.67 agc
71 1.67 agc /*
72 1.67 agc * Copyright (c) 1997 Christopher G. Demetriou. All rights reserved.
73 1.67 agc *
74 1.67 agc * Redistribution and use in source and binary forms, with or without
75 1.67 agc * modification, are permitted provided that the following conditions
76 1.67 agc * are met:
77 1.67 agc * 1. Redistributions of source code must retain the above copyright
78 1.67 agc * notice, this list of conditions and the following disclaimer.
79 1.67 agc * 2. Redistributions in binary form must reproduce the above copyright
80 1.67 agc * notice, this list of conditions and the following disclaimer in the
81 1.67 agc * documentation and/or other materials provided with the distribution.
82 1.1 cgd * 3. All advertising materials mentioning features or use of this software
83 1.1 cgd * must display the following acknowledgement:
84 1.1 cgd * This product includes software developed by the University of
85 1.1 cgd * California, Berkeley and its contributors.
86 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
87 1.1 cgd * may be used to endorse or promote products derived from this software
88 1.1 cgd * without specific prior written permission.
89 1.1 cgd *
90 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
91 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
92 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
93 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
94 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
95 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
96 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
97 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
98 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
99 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
100 1.1 cgd * SUCH DAMAGE.
101 1.1 cgd *
102 1.31 fvdl * @(#)uipc_usrreq.c 8.9 (Berkeley) 5/14/95
103 1.1 cgd */
104 1.53 lukem
105 1.53 lukem #include <sys/cdefs.h>
106 1.70 hannken __KERNEL_RCSID(0, "$NetBSD: uipc_usrreq.c,v 1.70 2003/10/15 11:29:01 hannken Exp $");
107 1.1 cgd
108 1.7 mycroft #include <sys/param.h>
109 1.8 mycroft #include <sys/systm.h>
110 1.7 mycroft #include <sys/proc.h>
111 1.7 mycroft #include <sys/filedesc.h>
112 1.7 mycroft #include <sys/domain.h>
113 1.7 mycroft #include <sys/protosw.h>
114 1.7 mycroft #include <sys/socket.h>
115 1.7 mycroft #include <sys/socketvar.h>
116 1.7 mycroft #include <sys/unpcb.h>
117 1.7 mycroft #include <sys/un.h>
118 1.7 mycroft #include <sys/namei.h>
119 1.7 mycroft #include <sys/vnode.h>
120 1.7 mycroft #include <sys/file.h>
121 1.7 mycroft #include <sys/stat.h>
122 1.7 mycroft #include <sys/mbuf.h>
123 1.1 cgd
124 1.1 cgd /*
125 1.1 cgd * Unix communications domain.
126 1.1 cgd *
127 1.1 cgd * TODO:
128 1.1 cgd * SEQPACKET, RDM
129 1.1 cgd * rethink name space problems
130 1.1 cgd * need a proper out-of-band
131 1.1 cgd */
132 1.34 lukem struct sockaddr_un sun_noname = { sizeof(sun_noname), AF_LOCAL };
133 1.1 cgd ino_t unp_ino; /* prototype for fake inode numbers */
134 1.1 cgd
135 1.30 thorpej struct mbuf *unp_addsockcred __P((struct proc *, struct mbuf *));
136 1.30 thorpej
137 1.20 mycroft int
138 1.30 thorpej unp_output(m, control, unp, p)
139 1.20 mycroft struct mbuf *m, *control;
140 1.20 mycroft struct unpcb *unp;
141 1.30 thorpej struct proc *p;
142 1.20 mycroft {
143 1.20 mycroft struct socket *so2;
144 1.20 mycroft struct sockaddr_un *sun;
145 1.20 mycroft
146 1.20 mycroft so2 = unp->unp_conn->unp_socket;
147 1.20 mycroft if (unp->unp_addr)
148 1.20 mycroft sun = unp->unp_addr;
149 1.20 mycroft else
150 1.20 mycroft sun = &sun_noname;
151 1.30 thorpej if (unp->unp_conn->unp_flags & UNP_WANTCRED)
152 1.30 thorpej control = unp_addsockcred(p, control);
153 1.20 mycroft if (sbappendaddr(&so2->so_rcv, (struct sockaddr *)sun, m,
154 1.20 mycroft control) == 0) {
155 1.20 mycroft m_freem(control);
156 1.20 mycroft m_freem(m);
157 1.60 christos return (ENOBUFS);
158 1.20 mycroft } else {
159 1.20 mycroft sorwakeup(so2);
160 1.20 mycroft return (0);
161 1.20 mycroft }
162 1.20 mycroft }
163 1.20 mycroft
164 1.20 mycroft void
165 1.20 mycroft unp_setsockaddr(unp, nam)
166 1.46 augustss struct unpcb *unp;
167 1.20 mycroft struct mbuf *nam;
168 1.20 mycroft {
169 1.20 mycroft struct sockaddr_un *sun;
170 1.20 mycroft
171 1.20 mycroft if (unp->unp_addr)
172 1.20 mycroft sun = unp->unp_addr;
173 1.20 mycroft else
174 1.20 mycroft sun = &sun_noname;
175 1.20 mycroft nam->m_len = sun->sun_len;
176 1.56 itojun if (nam->m_len > MLEN)
177 1.27 thorpej MEXTMALLOC(nam, nam->m_len, M_WAITOK);
178 1.36 perry memcpy(mtod(nam, caddr_t), sun, (size_t)nam->m_len);
179 1.20 mycroft }
180 1.20 mycroft
181 1.20 mycroft void
182 1.20 mycroft unp_setpeeraddr(unp, nam)
183 1.46 augustss struct unpcb *unp;
184 1.20 mycroft struct mbuf *nam;
185 1.20 mycroft {
186 1.20 mycroft struct sockaddr_un *sun;
187 1.20 mycroft
188 1.20 mycroft if (unp->unp_conn && unp->unp_conn->unp_addr)
189 1.20 mycroft sun = unp->unp_conn->unp_addr;
190 1.20 mycroft else
191 1.20 mycroft sun = &sun_noname;
192 1.20 mycroft nam->m_len = sun->sun_len;
193 1.56 itojun if (nam->m_len > MLEN)
194 1.27 thorpej MEXTMALLOC(nam, nam->m_len, M_WAITOK);
195 1.36 perry memcpy(mtod(nam, caddr_t), sun, (size_t)nam->m_len);
196 1.20 mycroft }
197 1.20 mycroft
198 1.1 cgd /*ARGSUSED*/
199 1.5 andrew int
200 1.62 fvdl uipc_usrreq(so, req, m, nam, control, p)
201 1.1 cgd struct socket *so;
202 1.1 cgd int req;
203 1.1 cgd struct mbuf *m, *nam, *control;
204 1.62 fvdl struct proc *p;
205 1.1 cgd {
206 1.1 cgd struct unpcb *unp = sotounpcb(so);
207 1.46 augustss struct socket *so2;
208 1.46 augustss int error = 0;
209 1.1 cgd
210 1.1 cgd if (req == PRU_CONTROL)
211 1.1 cgd return (EOPNOTSUPP);
212 1.20 mycroft
213 1.22 mycroft #ifdef DIAGNOSTIC
214 1.22 mycroft if (req != PRU_SEND && req != PRU_SENDOOB && control)
215 1.22 mycroft panic("uipc_usrreq: unexpected control mbuf");
216 1.22 mycroft #endif
217 1.1 cgd if (unp == 0 && req != PRU_ATTACH) {
218 1.1 cgd error = EINVAL;
219 1.1 cgd goto release;
220 1.1 cgd }
221 1.20 mycroft
222 1.1 cgd switch (req) {
223 1.1 cgd
224 1.1 cgd case PRU_ATTACH:
225 1.20 mycroft if (unp != 0) {
226 1.1 cgd error = EISCONN;
227 1.1 cgd break;
228 1.1 cgd }
229 1.1 cgd error = unp_attach(so);
230 1.1 cgd break;
231 1.1 cgd
232 1.1 cgd case PRU_DETACH:
233 1.1 cgd unp_detach(unp);
234 1.1 cgd break;
235 1.1 cgd
236 1.1 cgd case PRU_BIND:
237 1.62 fvdl error = unp_bind(unp, nam, p);
238 1.1 cgd break;
239 1.1 cgd
240 1.1 cgd case PRU_LISTEN:
241 1.1 cgd if (unp->unp_vnode == 0)
242 1.1 cgd error = EINVAL;
243 1.1 cgd break;
244 1.1 cgd
245 1.1 cgd case PRU_CONNECT:
246 1.62 fvdl error = unp_connect(so, nam, p);
247 1.1 cgd break;
248 1.1 cgd
249 1.1 cgd case PRU_CONNECT2:
250 1.68 matt error = unp_connect2(so, (struct socket *)nam, PRU_CONNECT2);
251 1.1 cgd break;
252 1.1 cgd
253 1.1 cgd case PRU_DISCONNECT:
254 1.1 cgd unp_disconnect(unp);
255 1.1 cgd break;
256 1.1 cgd
257 1.1 cgd case PRU_ACCEPT:
258 1.20 mycroft unp_setpeeraddr(unp, nam);
259 1.68 matt /*
260 1.68 matt * Mark the initiating STREAM socket as connected *ONLY*
261 1.68 matt * after it's been accepted. This prevents a client from
262 1.68 matt * overrunning a server and receiving ECONNREFUSED.
263 1.68 matt */
264 1.68 matt if (unp->unp_conn != NULL &&
265 1.68 matt (unp->unp_conn->unp_socket->so_state & SS_ISCONNECTING))
266 1.68 matt soisconnected(unp->unp_conn->unp_socket);
267 1.1 cgd break;
268 1.1 cgd
269 1.1 cgd case PRU_SHUTDOWN:
270 1.1 cgd socantsendmore(so);
271 1.1 cgd unp_shutdown(unp);
272 1.1 cgd break;
273 1.1 cgd
274 1.1 cgd case PRU_RCVD:
275 1.1 cgd switch (so->so_type) {
276 1.1 cgd
277 1.1 cgd case SOCK_DGRAM:
278 1.1 cgd panic("uipc 1");
279 1.1 cgd /*NOTREACHED*/
280 1.1 cgd
281 1.1 cgd case SOCK_STREAM:
282 1.1 cgd #define rcv (&so->so_rcv)
283 1.1 cgd #define snd (&so2->so_snd)
284 1.1 cgd if (unp->unp_conn == 0)
285 1.1 cgd break;
286 1.1 cgd so2 = unp->unp_conn->unp_socket;
287 1.1 cgd /*
288 1.1 cgd * Adjust backpressure on sender
289 1.1 cgd * and wakeup any waiting to write.
290 1.1 cgd */
291 1.1 cgd snd->sb_mbmax += unp->unp_mbcnt - rcv->sb_mbcnt;
292 1.1 cgd unp->unp_mbcnt = rcv->sb_mbcnt;
293 1.1 cgd snd->sb_hiwat += unp->unp_cc - rcv->sb_cc;
294 1.1 cgd unp->unp_cc = rcv->sb_cc;
295 1.1 cgd sowwakeup(so2);
296 1.1 cgd #undef snd
297 1.1 cgd #undef rcv
298 1.1 cgd break;
299 1.1 cgd
300 1.1 cgd default:
301 1.1 cgd panic("uipc 2");
302 1.1 cgd }
303 1.1 cgd break;
304 1.1 cgd
305 1.1 cgd case PRU_SEND:
306 1.30 thorpej /*
307 1.30 thorpej * Note: unp_internalize() rejects any control message
308 1.30 thorpej * other than SCM_RIGHTS, and only allows one. This
309 1.30 thorpej * has the side-effect of preventing a caller from
310 1.30 thorpej * forging SCM_CREDS.
311 1.30 thorpej */
312 1.1 cgd if (control && (error = unp_internalize(control, p)))
313 1.1 cgd break;
314 1.1 cgd switch (so->so_type) {
315 1.1 cgd
316 1.1 cgd case SOCK_DGRAM: {
317 1.1 cgd if (nam) {
318 1.20 mycroft if ((so->so_state & SS_ISCONNECTED) != 0) {
319 1.1 cgd error = EISCONN;
320 1.21 mycroft goto die;
321 1.1 cgd }
322 1.62 fvdl error = unp_connect(so, nam, p);
323 1.20 mycroft if (error) {
324 1.23 mycroft die:
325 1.21 mycroft m_freem(control);
326 1.20 mycroft m_freem(m);
327 1.1 cgd break;
328 1.20 mycroft }
329 1.1 cgd } else {
330 1.20 mycroft if ((so->so_state & SS_ISCONNECTED) == 0) {
331 1.1 cgd error = ENOTCONN;
332 1.21 mycroft goto die;
333 1.1 cgd }
334 1.1 cgd }
335 1.30 thorpej error = unp_output(m, control, unp, p);
336 1.1 cgd if (nam)
337 1.1 cgd unp_disconnect(unp);
338 1.1 cgd break;
339 1.1 cgd }
340 1.1 cgd
341 1.1 cgd case SOCK_STREAM:
342 1.1 cgd #define rcv (&so2->so_rcv)
343 1.1 cgd #define snd (&so->so_snd)
344 1.1 cgd if (unp->unp_conn == 0)
345 1.1 cgd panic("uipc 3");
346 1.1 cgd so2 = unp->unp_conn->unp_socket;
347 1.30 thorpej if (unp->unp_conn->unp_flags & UNP_WANTCRED) {
348 1.30 thorpej /*
349 1.30 thorpej * Credentials are passed only once on
350 1.30 thorpej * SOCK_STREAM.
351 1.30 thorpej */
352 1.30 thorpej unp->unp_conn->unp_flags &= ~UNP_WANTCRED;
353 1.30 thorpej control = unp_addsockcred(p, control);
354 1.30 thorpej }
355 1.1 cgd /*
356 1.1 cgd * Send to paired receive port, and then reduce
357 1.1 cgd * send buffer hiwater marks to maintain backpressure.
358 1.1 cgd * Wake up readers.
359 1.1 cgd */
360 1.1 cgd if (control) {
361 1.21 mycroft if (sbappendcontrol(rcv, m, control) == 0)
362 1.21 mycroft m_freem(control);
363 1.1 cgd } else
364 1.1 cgd sbappend(rcv, m);
365 1.1 cgd snd->sb_mbmax -=
366 1.1 cgd rcv->sb_mbcnt - unp->unp_conn->unp_mbcnt;
367 1.1 cgd unp->unp_conn->unp_mbcnt = rcv->sb_mbcnt;
368 1.1 cgd snd->sb_hiwat -= rcv->sb_cc - unp->unp_conn->unp_cc;
369 1.1 cgd unp->unp_conn->unp_cc = rcv->sb_cc;
370 1.1 cgd sorwakeup(so2);
371 1.1 cgd #undef snd
372 1.1 cgd #undef rcv
373 1.1 cgd break;
374 1.1 cgd
375 1.1 cgd default:
376 1.1 cgd panic("uipc 4");
377 1.1 cgd }
378 1.1 cgd break;
379 1.1 cgd
380 1.1 cgd case PRU_ABORT:
381 1.1 cgd unp_drop(unp, ECONNABORTED);
382 1.39 sommerfe
383 1.39 sommerfe #ifdef DIAGNOSTIC
384 1.39 sommerfe if (so->so_pcb == 0)
385 1.39 sommerfe panic("uipc 5: drop killed pcb");
386 1.39 sommerfe #endif
387 1.39 sommerfe unp_detach(unp);
388 1.1 cgd break;
389 1.1 cgd
390 1.1 cgd case PRU_SENSE:
391 1.1 cgd ((struct stat *) m)->st_blksize = so->so_snd.sb_hiwat;
392 1.1 cgd if (so->so_type == SOCK_STREAM && unp->unp_conn != 0) {
393 1.1 cgd so2 = unp->unp_conn->unp_socket;
394 1.1 cgd ((struct stat *) m)->st_blksize += so2->so_rcv.sb_cc;
395 1.1 cgd }
396 1.1 cgd ((struct stat *) m)->st_dev = NODEV;
397 1.1 cgd if (unp->unp_ino == 0)
398 1.1 cgd unp->unp_ino = unp_ino++;
399 1.25 kleink ((struct stat *) m)->st_atimespec =
400 1.25 kleink ((struct stat *) m)->st_mtimespec =
401 1.25 kleink ((struct stat *) m)->st_ctimespec = unp->unp_ctime;
402 1.1 cgd ((struct stat *) m)->st_ino = unp->unp_ino;
403 1.1 cgd return (0);
404 1.1 cgd
405 1.1 cgd case PRU_RCVOOB:
406 1.20 mycroft error = EOPNOTSUPP;
407 1.20 mycroft break;
408 1.1 cgd
409 1.1 cgd case PRU_SENDOOB:
410 1.22 mycroft m_freem(control);
411 1.20 mycroft m_freem(m);
412 1.1 cgd error = EOPNOTSUPP;
413 1.1 cgd break;
414 1.1 cgd
415 1.1 cgd case PRU_SOCKADDR:
416 1.20 mycroft unp_setsockaddr(unp, nam);
417 1.1 cgd break;
418 1.1 cgd
419 1.1 cgd case PRU_PEERADDR:
420 1.20 mycroft unp_setpeeraddr(unp, nam);
421 1.1 cgd break;
422 1.1 cgd
423 1.1 cgd default:
424 1.1 cgd panic("piusrreq");
425 1.1 cgd }
426 1.20 mycroft
427 1.1 cgd release:
428 1.1 cgd return (error);
429 1.1 cgd }
430 1.1 cgd
431 1.1 cgd /*
432 1.30 thorpej * Unix domain socket option processing.
433 1.30 thorpej */
434 1.30 thorpej int
435 1.30 thorpej uipc_ctloutput(op, so, level, optname, mp)
436 1.30 thorpej int op;
437 1.30 thorpej struct socket *so;
438 1.30 thorpej int level, optname;
439 1.30 thorpej struct mbuf **mp;
440 1.30 thorpej {
441 1.30 thorpej struct unpcb *unp = sotounpcb(so);
442 1.30 thorpej struct mbuf *m = *mp;
443 1.30 thorpej int optval = 0, error = 0;
444 1.30 thorpej
445 1.30 thorpej if (level != 0) {
446 1.30 thorpej error = EINVAL;
447 1.30 thorpej if (op == PRCO_SETOPT && m)
448 1.30 thorpej (void) m_free(m);
449 1.30 thorpej } else switch (op) {
450 1.30 thorpej
451 1.30 thorpej case PRCO_SETOPT:
452 1.30 thorpej switch (optname) {
453 1.30 thorpej case LOCAL_CREDS:
454 1.30 thorpej if (m == NULL || m->m_len != sizeof(int))
455 1.30 thorpej error = EINVAL;
456 1.30 thorpej else {
457 1.30 thorpej optval = *mtod(m, int *);
458 1.30 thorpej switch (optname) {
459 1.30 thorpej #define OPTSET(bit) \
460 1.30 thorpej if (optval) \
461 1.30 thorpej unp->unp_flags |= (bit); \
462 1.30 thorpej else \
463 1.30 thorpej unp->unp_flags &= ~(bit);
464 1.30 thorpej
465 1.30 thorpej case LOCAL_CREDS:
466 1.30 thorpej OPTSET(UNP_WANTCRED);
467 1.30 thorpej break;
468 1.30 thorpej }
469 1.30 thorpej }
470 1.30 thorpej break;
471 1.30 thorpej #undef OPTSET
472 1.30 thorpej
473 1.30 thorpej default:
474 1.30 thorpej error = ENOPROTOOPT;
475 1.30 thorpej break;
476 1.30 thorpej }
477 1.30 thorpej if (m)
478 1.30 thorpej (void) m_free(m);
479 1.30 thorpej break;
480 1.30 thorpej
481 1.30 thorpej case PRCO_GETOPT:
482 1.30 thorpej switch (optname) {
483 1.30 thorpej case LOCAL_CREDS:
484 1.30 thorpej *mp = m = m_get(M_WAIT, MT_SOOPTS);
485 1.30 thorpej m->m_len = sizeof(int);
486 1.30 thorpej switch (optname) {
487 1.30 thorpej
488 1.30 thorpej #define OPTBIT(bit) (unp->unp_flags & (bit) ? 1 : 0)
489 1.30 thorpej
490 1.30 thorpej case LOCAL_CREDS:
491 1.30 thorpej optval = OPTBIT(UNP_WANTCRED);
492 1.30 thorpej break;
493 1.30 thorpej }
494 1.30 thorpej *mtod(m, int *) = optval;
495 1.30 thorpej break;
496 1.30 thorpej #undef OPTBIT
497 1.30 thorpej
498 1.30 thorpej default:
499 1.30 thorpej error = ENOPROTOOPT;
500 1.30 thorpej break;
501 1.30 thorpej }
502 1.30 thorpej break;
503 1.30 thorpej }
504 1.30 thorpej return (error);
505 1.30 thorpej }
506 1.30 thorpej
507 1.30 thorpej /*
508 1.1 cgd * Both send and receive buffers are allocated PIPSIZ bytes of buffering
509 1.1 cgd * for stream sockets, although the total for sender and receiver is
510 1.1 cgd * actually only PIPSIZ.
511 1.1 cgd * Datagram sockets really use the sendspace as the maximum datagram size,
512 1.1 cgd * and don't really want to reserve the sendspace. Their recvspace should
513 1.1 cgd * be large enough for at least one max-size datagram plus address.
514 1.1 cgd */
515 1.1 cgd #define PIPSIZ 4096
516 1.1 cgd u_long unpst_sendspace = PIPSIZ;
517 1.1 cgd u_long unpst_recvspace = PIPSIZ;
518 1.1 cgd u_long unpdg_sendspace = 2*1024; /* really max datagram size */
519 1.1 cgd u_long unpdg_recvspace = 4*1024;
520 1.1 cgd
521 1.1 cgd int unp_rights; /* file descriptors in flight */
522 1.1 cgd
523 1.5 andrew int
524 1.1 cgd unp_attach(so)
525 1.1 cgd struct socket *so;
526 1.1 cgd {
527 1.46 augustss struct unpcb *unp;
528 1.25 kleink struct timeval tv;
529 1.1 cgd int error;
530 1.1 cgd
531 1.1 cgd if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
532 1.1 cgd switch (so->so_type) {
533 1.1 cgd
534 1.1 cgd case SOCK_STREAM:
535 1.1 cgd error = soreserve(so, unpst_sendspace, unpst_recvspace);
536 1.1 cgd break;
537 1.1 cgd
538 1.1 cgd case SOCK_DGRAM:
539 1.1 cgd error = soreserve(so, unpdg_sendspace, unpdg_recvspace);
540 1.1 cgd break;
541 1.8 mycroft
542 1.8 mycroft default:
543 1.8 mycroft panic("unp_attach");
544 1.1 cgd }
545 1.1 cgd if (error)
546 1.1 cgd return (error);
547 1.1 cgd }
548 1.14 mycroft unp = malloc(sizeof(*unp), M_PCB, M_NOWAIT);
549 1.14 mycroft if (unp == NULL)
550 1.1 cgd return (ENOBUFS);
551 1.36 perry memset((caddr_t)unp, 0, sizeof(*unp));
552 1.14 mycroft unp->unp_socket = so;
553 1.15 mycroft so->so_pcb = unp;
554 1.25 kleink microtime(&tv);
555 1.25 kleink TIMEVAL_TO_TIMESPEC(&tv, &unp->unp_ctime);
556 1.1 cgd return (0);
557 1.1 cgd }
558 1.1 cgd
559 1.17 pk void
560 1.1 cgd unp_detach(unp)
561 1.46 augustss struct unpcb *unp;
562 1.1 cgd {
563 1.1 cgd
564 1.1 cgd if (unp->unp_vnode) {
565 1.1 cgd unp->unp_vnode->v_socket = 0;
566 1.1 cgd vrele(unp->unp_vnode);
567 1.1 cgd unp->unp_vnode = 0;
568 1.1 cgd }
569 1.1 cgd if (unp->unp_conn)
570 1.1 cgd unp_disconnect(unp);
571 1.1 cgd while (unp->unp_refs)
572 1.1 cgd unp_drop(unp->unp_refs, ECONNRESET);
573 1.1 cgd soisdisconnected(unp->unp_socket);
574 1.1 cgd unp->unp_socket->so_pcb = 0;
575 1.20 mycroft if (unp->unp_addr)
576 1.26 thorpej free(unp->unp_addr, M_SONAME);
577 1.8 mycroft if (unp_rights) {
578 1.8 mycroft /*
579 1.8 mycroft * Normally the receive buffer is flushed later,
580 1.8 mycroft * in sofree, but if our receive buffer holds references
581 1.8 mycroft * to descriptors that are now garbage, we will dispose
582 1.8 mycroft * of those descriptor references after the garbage collector
583 1.8 mycroft * gets them (resulting in a "panic: closef: count < 0").
584 1.8 mycroft */
585 1.8 mycroft sorflush(unp->unp_socket);
586 1.14 mycroft free(unp, M_PCB);
587 1.1 cgd unp_gc();
588 1.14 mycroft } else
589 1.14 mycroft free(unp, M_PCB);
590 1.1 cgd }
591 1.1 cgd
592 1.5 andrew int
593 1.62 fvdl unp_bind(unp, nam, p)
594 1.1 cgd struct unpcb *unp;
595 1.1 cgd struct mbuf *nam;
596 1.62 fvdl struct proc *p;
597 1.1 cgd {
598 1.27 thorpej struct sockaddr_un *sun;
599 1.46 augustss struct vnode *vp;
600 1.70 hannken struct mount *mp;
601 1.1 cgd struct vattr vattr;
602 1.27 thorpej size_t addrlen;
603 1.1 cgd int error;
604 1.1 cgd struct nameidata nd;
605 1.1 cgd
606 1.20 mycroft if (unp->unp_vnode != 0)
607 1.20 mycroft return (EINVAL);
608 1.27 thorpej
609 1.27 thorpej /*
610 1.27 thorpej * Allocate the new sockaddr. We have to allocate one
611 1.27 thorpej * extra byte so that we can ensure that the pathname
612 1.27 thorpej * is nul-terminated.
613 1.27 thorpej */
614 1.27 thorpej addrlen = nam->m_len + 1;
615 1.27 thorpej sun = malloc(addrlen, M_SONAME, M_WAITOK);
616 1.27 thorpej m_copydata(nam, 0, nam->m_len, (caddr_t)sun);
617 1.27 thorpej *(((char *)sun) + nam->m_len) = '\0';
618 1.27 thorpej
619 1.70 hannken restart:
620 1.9 mycroft NDINIT(&nd, CREATE, FOLLOW | LOCKPARENT, UIO_SYSSPACE,
621 1.62 fvdl sun->sun_path, p);
622 1.27 thorpej
623 1.1 cgd /* SHOULD BE ABLE TO ADOPT EXISTING AND wakeup() ALA FIFO's */
624 1.16 christos if ((error = namei(&nd)) != 0)
625 1.27 thorpej goto bad;
626 1.9 mycroft vp = nd.ni_vp;
627 1.70 hannken if (vp != NULL || vn_start_write(nd.ni_dvp, &mp, V_NOWAIT) != 0) {
628 1.9 mycroft VOP_ABORTOP(nd.ni_dvp, &nd.ni_cnd);
629 1.9 mycroft if (nd.ni_dvp == vp)
630 1.9 mycroft vrele(nd.ni_dvp);
631 1.1 cgd else
632 1.9 mycroft vput(nd.ni_dvp);
633 1.1 cgd vrele(vp);
634 1.70 hannken if (vp != NULL) {
635 1.70 hannken error = EADDRINUSE;
636 1.70 hannken goto bad;
637 1.70 hannken }
638 1.70 hannken error = vn_start_write(NULL, &mp,
639 1.70 hannken V_WAIT | V_SLEEPONLY | V_PCATCH);
640 1.70 hannken if (error)
641 1.70 hannken goto bad;
642 1.70 hannken goto restart;
643 1.1 cgd }
644 1.1 cgd VATTR_NULL(&vattr);
645 1.1 cgd vattr.va_type = VSOCK;
646 1.9 mycroft vattr.va_mode = ACCESSPERMS;
647 1.62 fvdl VOP_LEASE(nd.ni_dvp, p, p->p_ucred, LEASE_WRITE);
648 1.16 christos error = VOP_CREATE(nd.ni_dvp, &nd.ni_vp, &nd.ni_cnd, &vattr);
649 1.70 hannken vn_finished_write(mp, 0);
650 1.16 christos if (error)
651 1.27 thorpej goto bad;
652 1.9 mycroft vp = nd.ni_vp;
653 1.1 cgd vp->v_socket = unp->unp_socket;
654 1.1 cgd unp->unp_vnode = vp;
655 1.27 thorpej unp->unp_addrlen = addrlen;
656 1.27 thorpej unp->unp_addr = sun;
657 1.31 fvdl VOP_UNLOCK(vp, 0);
658 1.1 cgd return (0);
659 1.27 thorpej
660 1.27 thorpej bad:
661 1.27 thorpej free(sun, M_SONAME);
662 1.27 thorpej return (error);
663 1.1 cgd }
664 1.1 cgd
665 1.5 andrew int
666 1.62 fvdl unp_connect(so, nam, p)
667 1.1 cgd struct socket *so;
668 1.1 cgd struct mbuf *nam;
669 1.62 fvdl struct proc *p;
670 1.1 cgd {
671 1.46 augustss struct sockaddr_un *sun;
672 1.46 augustss struct vnode *vp;
673 1.46 augustss struct socket *so2, *so3;
674 1.1 cgd struct unpcb *unp2, *unp3;
675 1.27 thorpej size_t addrlen;
676 1.1 cgd int error;
677 1.1 cgd struct nameidata nd;
678 1.1 cgd
679 1.27 thorpej /*
680 1.27 thorpej * Allocate a temporary sockaddr. We have to allocate one extra
681 1.27 thorpej * byte so that we can ensure that the pathname is nul-terminated.
682 1.27 thorpej * When we establish the connection, we copy the other PCB's
683 1.27 thorpej * sockaddr to our own.
684 1.27 thorpej */
685 1.27 thorpej addrlen = nam->m_len + 1;
686 1.27 thorpej sun = malloc(addrlen, M_SONAME, M_WAITOK);
687 1.27 thorpej m_copydata(nam, 0, nam->m_len, (caddr_t)sun);
688 1.27 thorpej *(((char *)sun) + nam->m_len) = '\0';
689 1.27 thorpej
690 1.62 fvdl NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE, sun->sun_path, p);
691 1.27 thorpej
692 1.16 christos if ((error = namei(&nd)) != 0)
693 1.27 thorpej goto bad2;
694 1.9 mycroft vp = nd.ni_vp;
695 1.1 cgd if (vp->v_type != VSOCK) {
696 1.1 cgd error = ENOTSOCK;
697 1.1 cgd goto bad;
698 1.1 cgd }
699 1.62 fvdl if ((error = VOP_ACCESS(vp, VWRITE, p->p_ucred, p)) != 0)
700 1.1 cgd goto bad;
701 1.1 cgd so2 = vp->v_socket;
702 1.1 cgd if (so2 == 0) {
703 1.1 cgd error = ECONNREFUSED;
704 1.1 cgd goto bad;
705 1.1 cgd }
706 1.1 cgd if (so->so_type != so2->so_type) {
707 1.1 cgd error = EPROTOTYPE;
708 1.1 cgd goto bad;
709 1.1 cgd }
710 1.1 cgd if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
711 1.1 cgd if ((so2->so_options & SO_ACCEPTCONN) == 0 ||
712 1.1 cgd (so3 = sonewconn(so2, 0)) == 0) {
713 1.1 cgd error = ECONNREFUSED;
714 1.1 cgd goto bad;
715 1.1 cgd }
716 1.1 cgd unp2 = sotounpcb(so2);
717 1.1 cgd unp3 = sotounpcb(so3);
718 1.26 thorpej if (unp2->unp_addr) {
719 1.26 thorpej unp3->unp_addr = malloc(unp2->unp_addrlen,
720 1.26 thorpej M_SONAME, M_WAITOK);
721 1.36 perry memcpy(unp3->unp_addr, unp2->unp_addr,
722 1.26 thorpej unp2->unp_addrlen);
723 1.26 thorpej unp3->unp_addrlen = unp2->unp_addrlen;
724 1.26 thorpej }
725 1.30 thorpej unp3->unp_flags = unp2->unp_flags;
726 1.33 thorpej so2 = so3;
727 1.33 thorpej }
728 1.69 matt error = unp_connect2(so, so2, PRU_CONNECT);
729 1.27 thorpej bad:
730 1.1 cgd vput(vp);
731 1.27 thorpej bad2:
732 1.27 thorpej free(sun, M_SONAME);
733 1.1 cgd return (error);
734 1.1 cgd }
735 1.1 cgd
736 1.5 andrew int
737 1.68 matt unp_connect2(so, so2, req)
738 1.46 augustss struct socket *so;
739 1.46 augustss struct socket *so2;
740 1.68 matt int req;
741 1.1 cgd {
742 1.46 augustss struct unpcb *unp = sotounpcb(so);
743 1.46 augustss struct unpcb *unp2;
744 1.1 cgd
745 1.1 cgd if (so2->so_type != so->so_type)
746 1.1 cgd return (EPROTOTYPE);
747 1.1 cgd unp2 = sotounpcb(so2);
748 1.1 cgd unp->unp_conn = unp2;
749 1.1 cgd switch (so->so_type) {
750 1.1 cgd
751 1.1 cgd case SOCK_DGRAM:
752 1.1 cgd unp->unp_nextref = unp2->unp_refs;
753 1.1 cgd unp2->unp_refs = unp;
754 1.1 cgd soisconnected(so);
755 1.1 cgd break;
756 1.1 cgd
757 1.1 cgd case SOCK_STREAM:
758 1.1 cgd unp2->unp_conn = unp;
759 1.68 matt if (req == PRU_CONNECT)
760 1.68 matt soisconnecting(so);
761 1.68 matt else
762 1.68 matt soisconnected(so);
763 1.1 cgd soisconnected(so2);
764 1.1 cgd break;
765 1.1 cgd
766 1.1 cgd default:
767 1.1 cgd panic("unp_connect2");
768 1.1 cgd }
769 1.1 cgd return (0);
770 1.1 cgd }
771 1.1 cgd
772 1.5 andrew void
773 1.1 cgd unp_disconnect(unp)
774 1.1 cgd struct unpcb *unp;
775 1.1 cgd {
776 1.46 augustss struct unpcb *unp2 = unp->unp_conn;
777 1.1 cgd
778 1.1 cgd if (unp2 == 0)
779 1.1 cgd return;
780 1.1 cgd unp->unp_conn = 0;
781 1.1 cgd switch (unp->unp_socket->so_type) {
782 1.1 cgd
783 1.1 cgd case SOCK_DGRAM:
784 1.1 cgd if (unp2->unp_refs == unp)
785 1.1 cgd unp2->unp_refs = unp->unp_nextref;
786 1.1 cgd else {
787 1.1 cgd unp2 = unp2->unp_refs;
788 1.1 cgd for (;;) {
789 1.1 cgd if (unp2 == 0)
790 1.1 cgd panic("unp_disconnect");
791 1.1 cgd if (unp2->unp_nextref == unp)
792 1.1 cgd break;
793 1.1 cgd unp2 = unp2->unp_nextref;
794 1.1 cgd }
795 1.1 cgd unp2->unp_nextref = unp->unp_nextref;
796 1.1 cgd }
797 1.1 cgd unp->unp_nextref = 0;
798 1.1 cgd unp->unp_socket->so_state &= ~SS_ISCONNECTED;
799 1.1 cgd break;
800 1.1 cgd
801 1.1 cgd case SOCK_STREAM:
802 1.1 cgd soisdisconnected(unp->unp_socket);
803 1.1 cgd unp2->unp_conn = 0;
804 1.1 cgd soisdisconnected(unp2->unp_socket);
805 1.1 cgd break;
806 1.1 cgd }
807 1.1 cgd }
808 1.1 cgd
809 1.1 cgd #ifdef notdef
810 1.1 cgd unp_abort(unp)
811 1.1 cgd struct unpcb *unp;
812 1.1 cgd {
813 1.1 cgd
814 1.1 cgd unp_detach(unp);
815 1.1 cgd }
816 1.1 cgd #endif
817 1.1 cgd
818 1.5 andrew void
819 1.1 cgd unp_shutdown(unp)
820 1.1 cgd struct unpcb *unp;
821 1.1 cgd {
822 1.1 cgd struct socket *so;
823 1.1 cgd
824 1.1 cgd if (unp->unp_socket->so_type == SOCK_STREAM && unp->unp_conn &&
825 1.1 cgd (so = unp->unp_conn->unp_socket))
826 1.1 cgd socantrcvmore(so);
827 1.1 cgd }
828 1.1 cgd
829 1.5 andrew void
830 1.1 cgd unp_drop(unp, errno)
831 1.1 cgd struct unpcb *unp;
832 1.1 cgd int errno;
833 1.1 cgd {
834 1.1 cgd struct socket *so = unp->unp_socket;
835 1.1 cgd
836 1.1 cgd so->so_error = errno;
837 1.1 cgd unp_disconnect(unp);
838 1.1 cgd if (so->so_head) {
839 1.15 mycroft so->so_pcb = 0;
840 1.14 mycroft sofree(so);
841 1.20 mycroft if (unp->unp_addr)
842 1.26 thorpej free(unp->unp_addr, M_SONAME);
843 1.14 mycroft free(unp, M_PCB);
844 1.1 cgd }
845 1.1 cgd }
846 1.1 cgd
847 1.1 cgd #ifdef notdef
848 1.1 cgd unp_drain()
849 1.1 cgd {
850 1.1 cgd
851 1.1 cgd }
852 1.1 cgd #endif
853 1.1 cgd
854 1.5 andrew int
855 1.1 cgd unp_externalize(rights)
856 1.1 cgd struct mbuf *rights;
857 1.1 cgd {
858 1.62 fvdl struct proc *p = curproc; /* XXX */
859 1.46 augustss struct cmsghdr *cm = mtod(rights, struct cmsghdr *);
860 1.47 thorpej int i, *fdp;
861 1.46 augustss struct file **rp;
862 1.46 augustss struct file *fp;
863 1.50 thorpej int nfds, error = 0;
864 1.47 thorpej
865 1.47 thorpej nfds = (cm->cmsg_len - CMSG_ALIGN(sizeof(*cm))) /
866 1.47 thorpej sizeof(struct file *);
867 1.47 thorpej rp = (struct file **)CMSG_DATA(cm);
868 1.1 cgd
869 1.50 thorpej fdp = malloc(nfds * sizeof(int), M_TEMP, M_WAITOK);
870 1.50 thorpej
871 1.39 sommerfe /* Make sure the recipient should be able to see the descriptors.. */
872 1.42 thorpej if (p->p_cwdi->cwdi_rdir != NULL) {
873 1.48 thorpej rp = (struct file **)CMSG_DATA(cm);
874 1.39 sommerfe for (i = 0; i < nfds; i++) {
875 1.39 sommerfe fp = *rp++;
876 1.39 sommerfe /*
877 1.39 sommerfe * If we are in a chroot'ed directory, and
878 1.39 sommerfe * someone wants to pass us a directory, make
879 1.39 sommerfe * sure it's inside the subtree we're allowed
880 1.39 sommerfe * to access.
881 1.39 sommerfe */
882 1.39 sommerfe if (fp->f_type == DTYPE_VNODE) {
883 1.39 sommerfe struct vnode *vp = (struct vnode *)fp->f_data;
884 1.39 sommerfe if ((vp->v_type == VDIR) &&
885 1.62 fvdl !vn_isunder(vp, p->p_cwdi->cwdi_rdir, p)) {
886 1.39 sommerfe error = EPERM;
887 1.39 sommerfe break;
888 1.39 sommerfe }
889 1.39 sommerfe }
890 1.39 sommerfe }
891 1.39 sommerfe }
892 1.50 thorpej
893 1.50 thorpej restart:
894 1.47 thorpej rp = (struct file **)CMSG_DATA(cm);
895 1.50 thorpej if (error != 0) {
896 1.24 cgd for (i = 0; i < nfds; i++) {
897 1.1 cgd fp = *rp;
898 1.39 sommerfe /*
899 1.39 sommerfe * zero the pointer before calling unp_discard,
900 1.39 sommerfe * since it may end up in unp_gc()..
901 1.39 sommerfe */
902 1.39 sommerfe *rp++ = 0;
903 1.1 cgd unp_discard(fp);
904 1.1 cgd }
905 1.50 thorpej goto out;
906 1.1 cgd }
907 1.50 thorpej
908 1.24 cgd /*
909 1.50 thorpej * First loop -- allocate file descriptor table slots for the
910 1.50 thorpej * new descriptors.
911 1.24 cgd */
912 1.24 cgd for (i = 0; i < nfds; i++) {
913 1.39 sommerfe fp = *rp++;
914 1.50 thorpej if ((error = fdalloc(p, 0, &fdp[i])) != 0) {
915 1.49 thorpej /*
916 1.50 thorpej * Back out what we've done so far.
917 1.49 thorpej */
918 1.50 thorpej for (--i; i >= 0; i--)
919 1.50 thorpej fdremove(p->p_fd, fdp[i]);
920 1.50 thorpej
921 1.50 thorpej if (error == ENOSPC) {
922 1.50 thorpej fdexpand(p);
923 1.50 thorpej error = 0;
924 1.50 thorpej } else {
925 1.50 thorpej /*
926 1.50 thorpej * This is the error that has historically
927 1.50 thorpej * been returned, and some callers may
928 1.50 thorpej * expect it.
929 1.50 thorpej */
930 1.50 thorpej error = EMSGSIZE;
931 1.50 thorpej }
932 1.50 thorpej goto restart;
933 1.49 thorpej }
934 1.50 thorpej
935 1.50 thorpej /*
936 1.50 thorpej * Make the slot reference the descriptor so that
937 1.50 thorpej * fdalloc() works properly.. We finalize it all
938 1.50 thorpej * in the loop below.
939 1.50 thorpej */
940 1.50 thorpej p->p_fd->fd_ofiles[fdp[i]] = fp;
941 1.1 cgd }
942 1.24 cgd
943 1.24 cgd /*
944 1.50 thorpej * Now that adding them has succeeded, update all of the
945 1.50 thorpej * descriptor passing state.
946 1.24 cgd */
947 1.50 thorpej rp = (struct file **)CMSG_DATA(cm);
948 1.50 thorpej for (i = 0; i < nfds; i++) {
949 1.50 thorpej fp = *rp++;
950 1.50 thorpej fp->f_msgcount--;
951 1.50 thorpej unp_rights--;
952 1.50 thorpej }
953 1.50 thorpej
954 1.50 thorpej /*
955 1.50 thorpej * Copy temporary array to message and adjust length, in case of
956 1.50 thorpej * transition from large struct file pointers to ints.
957 1.50 thorpej */
958 1.50 thorpej memcpy(CMSG_DATA(cm), fdp, nfds * sizeof(int));
959 1.47 thorpej cm->cmsg_len = CMSG_LEN(nfds * sizeof(int));
960 1.47 thorpej rights->m_len = CMSG_SPACE(nfds * sizeof(int));
961 1.50 thorpej out:
962 1.50 thorpej free(fdp, M_TEMP);
963 1.50 thorpej return (error);
964 1.1 cgd }
965 1.1 cgd
966 1.5 andrew int
967 1.1 cgd unp_internalize(control, p)
968 1.1 cgd struct mbuf *control;
969 1.1 cgd struct proc *p;
970 1.1 cgd {
971 1.24 cgd struct filedesc *fdescp = p->p_fd;
972 1.46 augustss struct cmsghdr *cm = mtod(control, struct cmsghdr *);
973 1.46 augustss struct file **rp;
974 1.46 augustss struct file *fp;
975 1.46 augustss int i, fd, *fdp;
976 1.24 cgd int nfds;
977 1.24 cgd u_int neededspace;
978 1.38 thorpej
979 1.24 cgd /* Sanity check the control message header */
980 1.66 jdolecek if (cm->cmsg_type != SCM_RIGHTS || cm->cmsg_level != SOL_SOCKET ||
981 1.1 cgd cm->cmsg_len != control->m_len)
982 1.1 cgd return (EINVAL);
983 1.24 cgd
984 1.24 cgd /* Verify that the file descriptors are valid */
985 1.47 thorpej nfds = (cm->cmsg_len - CMSG_ALIGN(sizeof(*cm))) / sizeof(int);
986 1.47 thorpej fdp = (int *)CMSG_DATA(cm);
987 1.24 cgd for (i = 0; i < nfds; i++) {
988 1.24 cgd fd = *fdp++;
989 1.58 pk if ((fp = fd_getfile(fdescp, fd)) == NULL)
990 1.1 cgd return (EBADF);
991 1.58 pk simple_unlock(&fp->f_slock);
992 1.1 cgd }
993 1.24 cgd
994 1.24 cgd /* Make sure we have room for the struct file pointers */
995 1.47 thorpej morespace:
996 1.47 thorpej neededspace = CMSG_SPACE(nfds * sizeof(struct file *)) -
997 1.47 thorpej control->m_len;
998 1.24 cgd if (neededspace > M_TRAILINGSPACE(control)) {
999 1.24 cgd
1000 1.24 cgd /* if we already have a cluster, the message is just too big */
1001 1.24 cgd if (control->m_flags & M_EXT)
1002 1.24 cgd return (E2BIG);
1003 1.24 cgd
1004 1.24 cgd /* allocate a cluster and try again */
1005 1.59 matt m_clget(control, M_WAIT);
1006 1.24 cgd if ((control->m_flags & M_EXT) == 0)
1007 1.24 cgd return (ENOBUFS); /* allocation failed */
1008 1.24 cgd
1009 1.24 cgd /* copy the data to the cluster */
1010 1.36 perry memcpy(mtod(control, char *), cm, cm->cmsg_len);
1011 1.24 cgd cm = mtod(control, struct cmsghdr *);
1012 1.24 cgd goto morespace;
1013 1.24 cgd }
1014 1.24 cgd
1015 1.24 cgd /* adjust message & mbuf to note amount of space actually used. */
1016 1.47 thorpej cm->cmsg_len = CMSG_LEN(nfds * sizeof(struct file *));
1017 1.47 thorpej control->m_len = CMSG_SPACE(nfds * sizeof(struct file *));
1018 1.24 cgd
1019 1.24 cgd /*
1020 1.24 cgd * Transform the file descriptors into struct file pointers, in
1021 1.24 cgd * reverse order so that if pointers are bigger than ints, the
1022 1.24 cgd * int won't get until we're done.
1023 1.24 cgd */
1024 1.47 thorpej fdp = ((int *)CMSG_DATA(cm)) + nfds - 1;
1025 1.47 thorpej rp = ((struct file **)CMSG_DATA(cm)) + nfds - 1;
1026 1.24 cgd for (i = 0; i < nfds; i++) {
1027 1.28 christos fp = fdescp->fd_ofiles[*fdp--];
1028 1.57 pk simple_lock(&fp->f_slock);
1029 1.57 pk #ifdef DIAGNOSTIC
1030 1.57 pk if (fp->f_iflags & FIF_WANTCLOSE)
1031 1.57 pk panic("unp_internalize: file already closed");
1032 1.57 pk #endif
1033 1.24 cgd *rp-- = fp;
1034 1.1 cgd fp->f_count++;
1035 1.1 cgd fp->f_msgcount++;
1036 1.57 pk simple_unlock(&fp->f_slock);
1037 1.1 cgd unp_rights++;
1038 1.1 cgd }
1039 1.1 cgd return (0);
1040 1.30 thorpej }
1041 1.30 thorpej
1042 1.30 thorpej struct mbuf *
1043 1.30 thorpej unp_addsockcred(p, control)
1044 1.30 thorpej struct proc *p;
1045 1.30 thorpej struct mbuf *control;
1046 1.30 thorpej {
1047 1.30 thorpej struct cmsghdr *cmp;
1048 1.30 thorpej struct sockcred *sc;
1049 1.30 thorpej struct mbuf *m, *n;
1050 1.47 thorpej int len, space, i;
1051 1.30 thorpej
1052 1.47 thorpej len = CMSG_LEN(SOCKCREDSIZE(p->p_ucred->cr_ngroups));
1053 1.47 thorpej space = CMSG_SPACE(SOCKCREDSIZE(p->p_ucred->cr_ngroups));
1054 1.30 thorpej
1055 1.30 thorpej m = m_get(M_WAIT, MT_CONTROL);
1056 1.47 thorpej if (space > MLEN) {
1057 1.47 thorpej if (space > MCLBYTES)
1058 1.47 thorpej MEXTMALLOC(m, space, M_WAITOK);
1059 1.30 thorpej else
1060 1.59 matt m_clget(m, M_WAIT);
1061 1.30 thorpej if ((m->m_flags & M_EXT) == 0) {
1062 1.30 thorpej m_free(m);
1063 1.30 thorpej return (control);
1064 1.30 thorpej }
1065 1.30 thorpej }
1066 1.30 thorpej
1067 1.47 thorpej m->m_len = space;
1068 1.30 thorpej m->m_next = NULL;
1069 1.30 thorpej cmp = mtod(m, struct cmsghdr *);
1070 1.30 thorpej sc = (struct sockcred *)CMSG_DATA(cmp);
1071 1.30 thorpej cmp->cmsg_len = len;
1072 1.30 thorpej cmp->cmsg_level = SOL_SOCKET;
1073 1.30 thorpej cmp->cmsg_type = SCM_CREDS;
1074 1.30 thorpej sc->sc_uid = p->p_cred->p_ruid;
1075 1.30 thorpej sc->sc_euid = p->p_ucred->cr_uid;
1076 1.30 thorpej sc->sc_gid = p->p_cred->p_rgid;
1077 1.30 thorpej sc->sc_egid = p->p_ucred->cr_gid;
1078 1.30 thorpej sc->sc_ngroups = p->p_ucred->cr_ngroups;
1079 1.30 thorpej for (i = 0; i < sc->sc_ngroups; i++)
1080 1.30 thorpej sc->sc_groups[i] = p->p_ucred->cr_groups[i];
1081 1.30 thorpej
1082 1.30 thorpej /*
1083 1.30 thorpej * If a control message already exists, append us to the end.
1084 1.30 thorpej */
1085 1.30 thorpej if (control != NULL) {
1086 1.30 thorpej for (n = control; n->m_next != NULL; n = n->m_next)
1087 1.30 thorpej ;
1088 1.30 thorpej n->m_next = m;
1089 1.30 thorpej } else
1090 1.30 thorpej control = m;
1091 1.30 thorpej
1092 1.30 thorpej return (control);
1093 1.1 cgd }
1094 1.1 cgd
1095 1.1 cgd int unp_defer, unp_gcing;
1096 1.1 cgd extern struct domain unixdomain;
1097 1.1 cgd
1098 1.39 sommerfe /*
1099 1.39 sommerfe * Comment added long after the fact explaining what's going on here.
1100 1.39 sommerfe * Do a mark-sweep GC of file descriptors on the system, to free up
1101 1.39 sommerfe * any which are caught in flight to an about-to-be-closed socket.
1102 1.39 sommerfe *
1103 1.39 sommerfe * Traditional mark-sweep gc's start at the "root", and mark
1104 1.39 sommerfe * everything reachable from the root (which, in our case would be the
1105 1.39 sommerfe * process table). The mark bits are cleared during the sweep.
1106 1.39 sommerfe *
1107 1.39 sommerfe * XXX For some inexplicable reason (perhaps because the file
1108 1.39 sommerfe * descriptor tables used to live in the u area which could be swapped
1109 1.39 sommerfe * out and thus hard to reach), we do multiple scans over the set of
1110 1.39 sommerfe * descriptors, using use *two* mark bits per object (DEFER and MARK).
1111 1.39 sommerfe * Whenever we find a descriptor which references other descriptors,
1112 1.39 sommerfe * the ones it references are marked with both bits, and we iterate
1113 1.39 sommerfe * over the whole file table until there are no more DEFER bits set.
1114 1.39 sommerfe * We also make an extra pass *before* the GC to clear the mark bits,
1115 1.39 sommerfe * which could have been cleared at almost no cost during the previous
1116 1.39 sommerfe * sweep.
1117 1.39 sommerfe *
1118 1.39 sommerfe * XXX MP: this needs to run with locks such that no other thread of
1119 1.39 sommerfe * control can create or destroy references to file descriptors. it
1120 1.39 sommerfe * may be necessary to defer the GC until later (when the locking
1121 1.39 sommerfe * situation is more hospitable); it may be necessary to push this
1122 1.39 sommerfe * into a separate thread.
1123 1.39 sommerfe */
1124 1.5 andrew void
1125 1.1 cgd unp_gc()
1126 1.1 cgd {
1127 1.46 augustss struct file *fp, *nextfp;
1128 1.46 augustss struct socket *so, *so1;
1129 1.8 mycroft struct file **extra_ref, **fpp;
1130 1.8 mycroft int nunref, i;
1131 1.1 cgd
1132 1.1 cgd if (unp_gcing)
1133 1.1 cgd return;
1134 1.1 cgd unp_gcing = 1;
1135 1.1 cgd unp_defer = 0;
1136 1.39 sommerfe
1137 1.39 sommerfe /* Clear mark bits */
1138 1.54 matt LIST_FOREACH(fp, &filehead, f_list)
1139 1.1 cgd fp->f_flag &= ~(FMARK|FDEFER);
1140 1.39 sommerfe
1141 1.39 sommerfe /*
1142 1.39 sommerfe * Iterate over the set of descriptors, marking ones believed
1143 1.39 sommerfe * (based on refcount) to be referenced from a process, and
1144 1.39 sommerfe * marking for rescan descriptors which are queued on a socket.
1145 1.39 sommerfe */
1146 1.1 cgd do {
1147 1.54 matt LIST_FOREACH(fp, &filehead, f_list) {
1148 1.1 cgd if (fp->f_flag & FDEFER) {
1149 1.1 cgd fp->f_flag &= ~FDEFER;
1150 1.1 cgd unp_defer--;
1151 1.39 sommerfe #ifdef DIAGNOSTIC
1152 1.39 sommerfe if (fp->f_count == 0)
1153 1.39 sommerfe panic("unp_gc: deferred unreferenced socket");
1154 1.39 sommerfe #endif
1155 1.1 cgd } else {
1156 1.39 sommerfe if (fp->f_count == 0)
1157 1.39 sommerfe continue;
1158 1.1 cgd if (fp->f_flag & FMARK)
1159 1.1 cgd continue;
1160 1.1 cgd if (fp->f_count == fp->f_msgcount)
1161 1.1 cgd continue;
1162 1.1 cgd }
1163 1.39 sommerfe fp->f_flag |= FMARK;
1164 1.39 sommerfe
1165 1.1 cgd if (fp->f_type != DTYPE_SOCKET ||
1166 1.1 cgd (so = (struct socket *)fp->f_data) == 0)
1167 1.1 cgd continue;
1168 1.1 cgd if (so->so_proto->pr_domain != &unixdomain ||
1169 1.1 cgd (so->so_proto->pr_flags&PR_RIGHTS) == 0)
1170 1.1 cgd continue;
1171 1.1 cgd #ifdef notdef
1172 1.1 cgd if (so->so_rcv.sb_flags & SB_LOCK) {
1173 1.1 cgd /*
1174 1.1 cgd * This is problematical; it's not clear
1175 1.1 cgd * we need to wait for the sockbuf to be
1176 1.1 cgd * unlocked (on a uniprocessor, at least),
1177 1.1 cgd * and it's also not clear what to do
1178 1.1 cgd * if sbwait returns an error due to receipt
1179 1.1 cgd * of a signal. If sbwait does return
1180 1.1 cgd * an error, we'll go into an infinite
1181 1.1 cgd * loop. Delete all of this for now.
1182 1.1 cgd */
1183 1.1 cgd (void) sbwait(&so->so_rcv);
1184 1.1 cgd goto restart;
1185 1.1 cgd }
1186 1.1 cgd #endif
1187 1.39 sommerfe unp_scan(so->so_rcv.sb_mb, unp_mark, 0);
1188 1.39 sommerfe /*
1189 1.39 sommerfe * mark descriptors referenced from sockets queued on the accept queue as well.
1190 1.39 sommerfe */
1191 1.39 sommerfe if (so->so_options & SO_ACCEPTCONN) {
1192 1.54 matt TAILQ_FOREACH(so1, &so->so_q0, so_qe) {
1193 1.39 sommerfe unp_scan(so1->so_rcv.sb_mb, unp_mark, 0);
1194 1.39 sommerfe }
1195 1.54 matt TAILQ_FOREACH(so1, &so->so_q, so_qe) {
1196 1.39 sommerfe unp_scan(so1->so_rcv.sb_mb, unp_mark, 0);
1197 1.39 sommerfe }
1198 1.39 sommerfe }
1199 1.39 sommerfe
1200 1.1 cgd }
1201 1.1 cgd } while (unp_defer);
1202 1.8 mycroft /*
1203 1.39 sommerfe * Sweep pass. Find unmarked descriptors, and free them.
1204 1.39 sommerfe *
1205 1.8 mycroft * We grab an extra reference to each of the file table entries
1206 1.8 mycroft * that are not otherwise accessible and then free the rights
1207 1.8 mycroft * that are stored in messages on them.
1208 1.8 mycroft *
1209 1.57 pk * The bug in the original code is a little tricky, so I'll describe
1210 1.8 mycroft * what's wrong with it here.
1211 1.8 mycroft *
1212 1.8 mycroft * It is incorrect to simply unp_discard each entry for f_msgcount
1213 1.8 mycroft * times -- consider the case of sockets A and B that contain
1214 1.8 mycroft * references to each other. On a last close of some other socket,
1215 1.8 mycroft * we trigger a gc since the number of outstanding rights (unp_rights)
1216 1.8 mycroft * is non-zero. If during the sweep phase the gc code un_discards,
1217 1.8 mycroft * we end up doing a (full) closef on the descriptor. A closef on A
1218 1.8 mycroft * results in the following chain. Closef calls soo_close, which
1219 1.8 mycroft * calls soclose. Soclose calls first (through the switch
1220 1.8 mycroft * uipc_usrreq) unp_detach, which re-invokes unp_gc. Unp_gc simply
1221 1.8 mycroft * returns because the previous instance had set unp_gcing, and
1222 1.8 mycroft * we return all the way back to soclose, which marks the socket
1223 1.8 mycroft * with SS_NOFDREF, and then calls sofree. Sofree calls sorflush
1224 1.8 mycroft * to free up the rights that are queued in messages on the socket A,
1225 1.8 mycroft * i.e., the reference on B. The sorflush calls via the dom_dispose
1226 1.8 mycroft * switch unp_dispose, which unp_scans with unp_discard. This second
1227 1.8 mycroft * instance of unp_discard just calls closef on B.
1228 1.8 mycroft *
1229 1.8 mycroft * Well, a similar chain occurs on B, resulting in a sorflush on B,
1230 1.8 mycroft * which results in another closef on A. Unfortunately, A is already
1231 1.8 mycroft * being closed, and the descriptor has already been marked with
1232 1.8 mycroft * SS_NOFDREF, and soclose panics at this point.
1233 1.8 mycroft *
1234 1.8 mycroft * Here, we first take an extra reference to each inaccessible
1235 1.39 sommerfe * descriptor. Then, if the inaccessible descriptor is a
1236 1.39 sommerfe * socket, we call sorflush in case it is a Unix domain
1237 1.39 sommerfe * socket. After we destroy all the rights carried in
1238 1.39 sommerfe * messages, we do a last closef to get rid of our extra
1239 1.39 sommerfe * reference. This is the last close, and the unp_detach etc
1240 1.39 sommerfe * will shut down the socket.
1241 1.8 mycroft *
1242 1.8 mycroft * 91/09/19, bsy (at) cs.cmu.edu
1243 1.8 mycroft */
1244 1.8 mycroft extra_ref = malloc(nfiles * sizeof(struct file *), M_FILE, M_WAITOK);
1245 1.54 matt for (nunref = 0, fp = LIST_FIRST(&filehead), fpp = extra_ref; fp != 0;
1246 1.11 mycroft fp = nextfp) {
1247 1.54 matt nextfp = LIST_NEXT(fp, f_list);
1248 1.57 pk simple_lock(&fp->f_slock);
1249 1.57 pk if (fp->f_count != 0 &&
1250 1.57 pk fp->f_count == fp->f_msgcount && !(fp->f_flag & FMARK)) {
1251 1.8 mycroft *fpp++ = fp;
1252 1.8 mycroft nunref++;
1253 1.8 mycroft fp->f_count++;
1254 1.8 mycroft }
1255 1.57 pk simple_unlock(&fp->f_slock);
1256 1.1 cgd }
1257 1.39 sommerfe for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp) {
1258 1.45 thorpej fp = *fpp;
1259 1.57 pk simple_lock(&fp->f_slock);
1260 1.44 thorpej FILE_USE(fp);
1261 1.39 sommerfe if (fp->f_type == DTYPE_SOCKET)
1262 1.39 sommerfe sorflush((struct socket *)fp->f_data);
1263 1.44 thorpej FILE_UNUSE(fp, NULL);
1264 1.39 sommerfe }
1265 1.44 thorpej for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp) {
1266 1.45 thorpej fp = *fpp;
1267 1.57 pk simple_lock(&fp->f_slock);
1268 1.44 thorpej FILE_USE(fp);
1269 1.62 fvdl (void) closef(fp, (struct proc *)0);
1270 1.44 thorpej }
1271 1.8 mycroft free((caddr_t)extra_ref, M_FILE);
1272 1.1 cgd unp_gcing = 0;
1273 1.1 cgd }
1274 1.1 cgd
1275 1.5 andrew void
1276 1.1 cgd unp_dispose(m)
1277 1.1 cgd struct mbuf *m;
1278 1.1 cgd {
1279 1.8 mycroft
1280 1.1 cgd if (m)
1281 1.39 sommerfe unp_scan(m, unp_discard, 1);
1282 1.1 cgd }
1283 1.1 cgd
1284 1.5 andrew void
1285 1.39 sommerfe unp_scan(m0, op, discard)
1286 1.46 augustss struct mbuf *m0;
1287 1.5 andrew void (*op) __P((struct file *));
1288 1.39 sommerfe int discard;
1289 1.1 cgd {
1290 1.46 augustss struct mbuf *m;
1291 1.46 augustss struct file **rp;
1292 1.46 augustss struct cmsghdr *cm;
1293 1.46 augustss int i;
1294 1.1 cgd int qfds;
1295 1.1 cgd
1296 1.1 cgd while (m0) {
1297 1.48 thorpej for (m = m0; m; m = m->m_next) {
1298 1.1 cgd if (m->m_type == MT_CONTROL &&
1299 1.1 cgd m->m_len >= sizeof(*cm)) {
1300 1.1 cgd cm = mtod(m, struct cmsghdr *);
1301 1.1 cgd if (cm->cmsg_level != SOL_SOCKET ||
1302 1.1 cgd cm->cmsg_type != SCM_RIGHTS)
1303 1.1 cgd continue;
1304 1.48 thorpej qfds = (cm->cmsg_len - CMSG_ALIGN(sizeof(*cm)))
1305 1.48 thorpej / sizeof(struct file *);
1306 1.48 thorpej rp = (struct file **)CMSG_DATA(cm);
1307 1.39 sommerfe for (i = 0; i < qfds; i++) {
1308 1.39 sommerfe struct file *fp = *rp;
1309 1.39 sommerfe if (discard)
1310 1.39 sommerfe *rp = 0;
1311 1.39 sommerfe (*op)(fp);
1312 1.39 sommerfe rp++;
1313 1.39 sommerfe }
1314 1.1 cgd break; /* XXX, but saves time */
1315 1.1 cgd }
1316 1.48 thorpej }
1317 1.52 thorpej m0 = m0->m_nextpkt;
1318 1.1 cgd }
1319 1.1 cgd }
1320 1.1 cgd
1321 1.5 andrew void
1322 1.1 cgd unp_mark(fp)
1323 1.1 cgd struct file *fp;
1324 1.1 cgd {
1325 1.39 sommerfe if (fp == NULL)
1326 1.39 sommerfe return;
1327 1.39 sommerfe
1328 1.39 sommerfe if (fp->f_flag & FMARK)
1329 1.39 sommerfe return;
1330 1.1 cgd
1331 1.39 sommerfe /* If we're already deferred, don't screw up the defer count */
1332 1.39 sommerfe if (fp->f_flag & FDEFER)
1333 1.1 cgd return;
1334 1.39 sommerfe
1335 1.39 sommerfe /*
1336 1.39 sommerfe * Minimize the number of deferrals... Sockets are the only
1337 1.39 sommerfe * type of descriptor which can hold references to another
1338 1.39 sommerfe * descriptor, so just mark other descriptors, and defer
1339 1.39 sommerfe * unmarked sockets for the next pass.
1340 1.39 sommerfe */
1341 1.39 sommerfe if (fp->f_type == DTYPE_SOCKET) {
1342 1.39 sommerfe unp_defer++;
1343 1.39 sommerfe if (fp->f_count == 0)
1344 1.39 sommerfe panic("unp_mark: queued unref");
1345 1.39 sommerfe fp->f_flag |= FDEFER;
1346 1.39 sommerfe } else {
1347 1.39 sommerfe fp->f_flag |= FMARK;
1348 1.39 sommerfe }
1349 1.39 sommerfe return;
1350 1.1 cgd }
1351 1.1 cgd
1352 1.5 andrew void
1353 1.1 cgd unp_discard(fp)
1354 1.1 cgd struct file *fp;
1355 1.1 cgd {
1356 1.39 sommerfe if (fp == NULL)
1357 1.39 sommerfe return;
1358 1.57 pk simple_lock(&fp->f_slock);
1359 1.57 pk fp->f_usecount++; /* i.e. FILE_USE(fp) sans locking */
1360 1.1 cgd fp->f_msgcount--;
1361 1.57 pk simple_unlock(&fp->f_slock);
1362 1.1 cgd unp_rights--;
1363 1.62 fvdl (void) closef(fp, (struct proc *)0);
1364 1.1 cgd }
1365