Fix a HAMMER assertion which turned out to be a bug in VOP_N*(). Sometimes
[dragonfly.git] / sys / kern / uipc_usrreq.c
1 /*
2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      From: @(#)uipc_usrreq.c 8.3 (Berkeley) 1/4/94
34  * $FreeBSD: src/sys/kern/uipc_usrreq.c,v 1.54.2.10 2003/03/04 17:28:09 nectar Exp $
35  * $DragonFly: src/sys/kern/uipc_usrreq.c,v 1.39 2008/05/09 17:52:17 dillon Exp $
36  */
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/domain.h>
42 #include <sys/fcntl.h>
43 #include <sys/malloc.h>         /* XXX must be before <sys/file.h> */
44 #include <sys/proc.h>
45 #include <sys/file.h>
46 #include <sys/filedesc.h>
47 #include <sys/mbuf.h>
48 #include <sys/nlookup.h>
49 #include <sys/protosw.h>
50 #include <sys/socket.h>
51 #include <sys/socketvar.h>
52 #include <sys/resourcevar.h>
53 #include <sys/stat.h>
54 #include <sys/mount.h>
55 #include <sys/sysctl.h>
56 #include <sys/un.h>
57 #include <sys/unpcb.h>
58 #include <sys/vnode.h>
59 #include <sys/file2.h>
60 #include <sys/spinlock2.h>
61
62 #include <vm/vm_zone.h>
63
64 static  struct vm_zone *unp_zone;
65 static  unp_gen_t unp_gencnt;
66 static  u_int unp_count;
67
68 static  struct unp_head unp_shead, unp_dhead;
69
70 /*
71  * Unix communications domain.
72  *
73  * TODO:
74  *      SEQPACKET, RDM
75  *      rethink name space problems
76  *      need a proper out-of-band
77  *      lock pushdown
78  */
79 static struct   sockaddr sun_noname = { sizeof(sun_noname), AF_LOCAL };
80 static ino_t    unp_ino;                /* prototype for fake inode numbers */
81
82 static int     unp_attach (struct socket *, struct pru_attach_info *);
83 static void    unp_detach (struct unpcb *);
84 static int     unp_bind (struct unpcb *,struct sockaddr *, struct thread *);
85 static int     unp_connect (struct socket *,struct sockaddr *,
86                                 struct thread *);
87 static void    unp_disconnect (struct unpcb *);
88 static void    unp_shutdown (struct unpcb *);
89 static void    unp_drop (struct unpcb *, int);
90 static void    unp_gc (void);
91 static int     unp_gc_clearmarks(struct file *, void *);
92 static int     unp_gc_checkmarks(struct file *, void *);
93 static int     unp_gc_checkrefs(struct file *, void *);
94 static void    unp_scan (struct mbuf *, void (*)(struct file *, void *),
95                                 void *data);
96 static void    unp_mark (struct file *, void *data);
97 static void    unp_discard (struct file *, void *);
98 static int     unp_internalize (struct mbuf *, struct thread *);
99 static int     unp_listen (struct unpcb *, struct thread *);
100
101 static int
102 uipc_abort(struct socket *so)
103 {
104         struct unpcb *unp = so->so_pcb;
105
106         if (unp == NULL)
107                 return EINVAL;
108         unp_drop(unp, ECONNABORTED);
109         unp_detach(unp);
110         sofree(so);
111         return 0;
112 }
113
114 static int
115 uipc_accept(struct socket *so, struct sockaddr **nam)
116 {
117         struct unpcb *unp = so->so_pcb;
118
119         if (unp == NULL)
120                 return EINVAL;
121
122         /*
123          * Pass back name of connected socket,
124          * if it was bound and we are still connected
125          * (our peer may have closed already!).
126          */
127         if (unp->unp_conn && unp->unp_conn->unp_addr) {
128                 *nam = dup_sockaddr((struct sockaddr *)unp->unp_conn->unp_addr);
129         } else {
130                 *nam = dup_sockaddr((struct sockaddr *)&sun_noname);
131         }
132         return 0;
133 }
134
135 static int
136 uipc_attach(struct socket *so, int proto, struct pru_attach_info *ai)
137 {
138         struct unpcb *unp = so->so_pcb;
139
140         if (unp != NULL)
141                 return EISCONN;
142         return unp_attach(so, ai);
143 }
144
145 static int
146 uipc_bind(struct socket *so, struct sockaddr *nam, struct thread *td)
147 {
148         struct unpcb *unp = so->so_pcb;
149
150         if (unp == NULL)
151                 return EINVAL;
152         return unp_bind(unp, nam, td);
153 }
154
155 static int
156 uipc_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
157 {
158         struct unpcb *unp = so->so_pcb;
159
160         if (unp == NULL)
161                 return EINVAL;
162         return unp_connect(so, nam, td);
163 }
164
165 static int
166 uipc_connect2(struct socket *so1, struct socket *so2)
167 {
168         struct unpcb *unp = so1->so_pcb;
169
170         if (unp == NULL)
171                 return EINVAL;
172
173         return unp_connect2(so1, so2);
174 }
175
176 /* control is EOPNOTSUPP */
177
178 static int
179 uipc_detach(struct socket *so)
180 {
181         struct unpcb *unp = so->so_pcb;
182
183         if (unp == NULL)
184                 return EINVAL;
185
186         unp_detach(unp);
187         return 0;
188 }
189
190 static int
191 uipc_disconnect(struct socket *so)
192 {
193         struct unpcb *unp = so->so_pcb;
194
195         if (unp == NULL)
196                 return EINVAL;
197         unp_disconnect(unp);
198         return 0;
199 }
200
201 static int
202 uipc_listen(struct socket *so, struct thread *td)
203 {
204         struct unpcb *unp = so->so_pcb;
205
206         if (unp == NULL || unp->unp_vnode == NULL)
207                 return EINVAL;
208         return unp_listen(unp, td);
209 }
210
211 static int
212 uipc_peeraddr(struct socket *so, struct sockaddr **nam)
213 {
214         struct unpcb *unp = so->so_pcb;
215
216         if (unp == NULL)
217                 return EINVAL;
218         if (unp->unp_conn && unp->unp_conn->unp_addr)
219                 *nam = dup_sockaddr((struct sockaddr *)unp->unp_conn->unp_addr);
220         else {
221                 /*
222                  * XXX: It seems that this test always fails even when
223                  * connection is established.  So, this else clause is
224                  * added as workaround to return PF_LOCAL sockaddr.
225                  */
226                 *nam = dup_sockaddr((struct sockaddr *)&sun_noname);
227         }
228         return 0;
229 }
230
231 static int
232 uipc_rcvd(struct socket *so, int flags)
233 {
234         struct unpcb *unp = so->so_pcb;
235         struct socket *so2;
236         u_long newhiwat;
237
238         if (unp == NULL)
239                 return EINVAL;
240         switch (so->so_type) {
241         case SOCK_DGRAM:
242                 panic("uipc_rcvd DGRAM?");
243                 /*NOTREACHED*/
244
245         case SOCK_STREAM:
246                 if (unp->unp_conn == NULL)
247                         break;
248                 so2 = unp->unp_conn->unp_socket;
249                 /*
250                  * Adjust backpressure on sender
251                  * and wakeup any waiting to write.
252                  */
253                 so2->so_snd.ssb_mbmax += unp->unp_mbcnt - so->so_rcv.ssb_mbcnt;
254                 unp->unp_mbcnt = so->so_rcv.ssb_mbcnt;
255                 newhiwat =
256                     so2->so_snd.ssb_hiwat + unp->unp_cc - so->so_rcv.ssb_cc;
257                 chgsbsize(so2->so_cred->cr_uidinfo, &so2->so_snd.ssb_hiwat,
258                     newhiwat, RLIM_INFINITY);
259                 unp->unp_cc = so->so_rcv.ssb_cc;
260                 sowwakeup(so2);
261                 break;
262
263         default:
264                 panic("uipc_rcvd unknown socktype");
265         }
266         return 0;
267 }
268
269 /* pru_rcvoob is EOPNOTSUPP */
270
271 static int
272 uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
273           struct mbuf *control, struct thread *td)
274 {
275         int error = 0;
276         struct unpcb *unp = so->so_pcb;
277         struct socket *so2;
278         u_long newhiwat;
279
280         if (unp == NULL) {
281                 error = EINVAL;
282                 goto release;
283         }
284         if (flags & PRUS_OOB) {
285                 error = EOPNOTSUPP;
286                 goto release;
287         }
288
289         if (control && (error = unp_internalize(control, td)))
290                 goto release;
291
292         switch (so->so_type) {
293         case SOCK_DGRAM: 
294         {
295                 struct sockaddr *from;
296
297                 if (nam) {
298                         if (unp->unp_conn) {
299                                 error = EISCONN;
300                                 break;
301                         }
302                         error = unp_connect(so, nam, td);
303                         if (error)
304                                 break;
305                 } else {
306                         if (unp->unp_conn == NULL) {
307                                 error = ENOTCONN;
308                                 break;
309                         }
310                 }
311                 so2 = unp->unp_conn->unp_socket;
312                 if (unp->unp_addr)
313                         from = (struct sockaddr *)unp->unp_addr;
314                 else
315                         from = &sun_noname;
316                 if (ssb_appendaddr(&so2->so_rcv, from, m, control)) {
317                         sorwakeup(so2);
318                         m = NULL;
319                         control = NULL;
320                 } else {
321                         error = ENOBUFS;
322                 }
323                 if (nam)
324                         unp_disconnect(unp);
325                 break;
326         }
327
328         case SOCK_STREAM:
329                 /* Connect if not connected yet. */
330                 /*
331                  * Note: A better implementation would complain
332                  * if not equal to the peer's address.
333                  */
334                 if (!(so->so_state & SS_ISCONNECTED)) {
335                         if (nam) {
336                                 error = unp_connect(so, nam, td);
337                                 if (error)
338                                         break;  /* XXX */
339                         } else {
340                                 error = ENOTCONN;
341                                 break;
342                         }
343                 }
344
345                 if (so->so_state & SS_CANTSENDMORE) {
346                         error = EPIPE;
347                         break;
348                 }
349                 if (unp->unp_conn == NULL)
350                         panic("uipc_send connected but no connection?");
351                 so2 = unp->unp_conn->unp_socket;
352                 /*
353                  * Send to paired receive port, and then reduce
354                  * send buffer hiwater marks to maintain backpressure.
355                  * Wake up readers.
356                  */
357                 if (control) {
358                         if (ssb_appendcontrol(&so2->so_rcv, m, control)) {
359                                 control = NULL;
360                                 m = NULL;
361                         }
362                 } else {
363                         sbappend(&so2->so_rcv.sb, m);
364                         m = NULL;
365                 }
366                 so->so_snd.ssb_mbmax -=
367                         so2->so_rcv.ssb_mbcnt - unp->unp_conn->unp_mbcnt;
368                 unp->unp_conn->unp_mbcnt = so2->so_rcv.ssb_mbcnt;
369                 newhiwat = so->so_snd.ssb_hiwat -
370                     (so2->so_rcv.ssb_cc - unp->unp_conn->unp_cc);
371                 chgsbsize(so->so_cred->cr_uidinfo, &so->so_snd.ssb_hiwat,
372                     newhiwat, RLIM_INFINITY);
373                 unp->unp_conn->unp_cc = so2->so_rcv.ssb_cc;
374                 sorwakeup(so2);
375                 break;
376
377         default:
378                 panic("uipc_send unknown socktype");
379         }
380
381         /*
382          * SEND_EOF is equivalent to a SEND followed by a SHUTDOWN.
383          */
384         if (flags & PRUS_EOF) {
385                 socantsendmore(so);
386                 unp_shutdown(unp);
387         }
388
389         if (control && error != 0)
390                 unp_dispose(control);
391
392 release:
393         if (control)
394                 m_freem(control);
395         if (m)
396                 m_freem(m);
397         return error;
398 }
399
400 static int
401 uipc_sense(struct socket *so, struct stat *sb)
402 {
403         struct unpcb *unp = so->so_pcb;
404         struct socket *so2;
405
406         if (unp == NULL)
407                 return EINVAL;
408         sb->st_blksize = so->so_snd.ssb_hiwat;
409         if (so->so_type == SOCK_STREAM && unp->unp_conn != NULL) {
410                 so2 = unp->unp_conn->unp_socket;
411                 sb->st_blksize += so2->so_rcv.ssb_cc;
412         }
413         sb->st_dev = NOUDEV;
414         if (unp->unp_ino == 0)          /* make up a non-zero inode number */
415                 unp->unp_ino = (++unp_ino == 0) ? ++unp_ino : unp_ino;
416         sb->st_ino = unp->unp_ino;
417         return (0);
418 }
419
420 static int
421 uipc_shutdown(struct socket *so)
422 {
423         struct unpcb *unp = so->so_pcb;
424
425         if (unp == NULL)
426                 return EINVAL;
427         socantsendmore(so);
428         unp_shutdown(unp);
429         return 0;
430 }
431
432 static int
433 uipc_sockaddr(struct socket *so, struct sockaddr **nam)
434 {
435         struct unpcb *unp = so->so_pcb;
436
437         if (unp == NULL)
438                 return EINVAL;
439         if (unp->unp_addr)
440                 *nam = dup_sockaddr((struct sockaddr *)unp->unp_addr);
441         return 0;
442 }
443
444 struct pr_usrreqs uipc_usrreqs = {
445         .pru_abort = uipc_abort,
446         .pru_accept = uipc_accept,
447         .pru_attach = uipc_attach,
448         .pru_bind = uipc_bind,
449         .pru_connect = uipc_connect,
450         .pru_connect2 = uipc_connect2,
451         .pru_control = pru_control_notsupp,
452         .pru_detach = uipc_detach,
453         .pru_disconnect = uipc_disconnect,
454         .pru_listen = uipc_listen,
455         .pru_peeraddr = uipc_peeraddr,
456         .pru_rcvd = uipc_rcvd,
457         .pru_rcvoob = pru_rcvoob_notsupp,
458         .pru_send = uipc_send,
459         .pru_sense = uipc_sense,
460         .pru_shutdown = uipc_shutdown,
461         .pru_sockaddr = uipc_sockaddr,
462         .pru_sosend = sosend,
463         .pru_soreceive = soreceive,
464         .pru_sopoll = sopoll
465 };
466
467 int
468 uipc_ctloutput(struct socket *so, struct sockopt *sopt)
469 {
470         struct unpcb *unp = so->so_pcb;
471         int error;
472
473         switch (sopt->sopt_dir) {
474         case SOPT_GET:
475                 switch (sopt->sopt_name) {
476                 case LOCAL_PEERCRED:
477                         if (unp->unp_flags & UNP_HAVEPC)
478                                 error = sooptcopyout(sopt, &unp->unp_peercred,
479                                     sizeof(unp->unp_peercred));
480                         else {
481                                 if (so->so_type == SOCK_STREAM)
482                                         error = ENOTCONN;
483                                 else
484                                         error = EINVAL;
485                         }
486                         break;
487                 default:
488                         error = EOPNOTSUPP;
489                         break;
490                 }
491                 break;
492         case SOPT_SET:
493         default:
494                 error = EOPNOTSUPP;
495                 break;
496         }
497         return (error);
498 }
499         
500 /*
501  * Both send and receive buffers are allocated PIPSIZ bytes of buffering
502  * for stream sockets, although the total for sender and receiver is
503  * actually only PIPSIZ.
504  * Datagram sockets really use the sendspace as the maximum datagram size,
505  * and don't really want to reserve the sendspace.  Their recvspace should
506  * be large enough for at least one max-size datagram plus address.
507  */
508 #ifndef PIPSIZ
509 #define PIPSIZ  8192
510 #endif
511 static u_long   unpst_sendspace = PIPSIZ;
512 static u_long   unpst_recvspace = PIPSIZ;
513 static u_long   unpdg_sendspace = 2*1024;       /* really max datagram size */
514 static u_long   unpdg_recvspace = 4*1024;
515
516 static int      unp_rights;                     /* file descriptors in flight */
517 static struct spinlock unp_spin = SPINLOCK_INITIALIZER(&unp_spin);
518
519 SYSCTL_DECL(_net_local_stream);
520 SYSCTL_INT(_net_local_stream, OID_AUTO, sendspace, CTLFLAG_RW, 
521            &unpst_sendspace, 0, "");
522 SYSCTL_INT(_net_local_stream, OID_AUTO, recvspace, CTLFLAG_RW,
523            &unpst_recvspace, 0, "");
524
525 SYSCTL_DECL(_net_local_dgram);
526 SYSCTL_INT(_net_local_dgram, OID_AUTO, maxdgram, CTLFLAG_RW,
527            &unpdg_sendspace, 0, "");
528 SYSCTL_INT(_net_local_dgram, OID_AUTO, recvspace, CTLFLAG_RW,
529            &unpdg_recvspace, 0, "");
530
531 SYSCTL_DECL(_net_local);
532 SYSCTL_INT(_net_local, OID_AUTO, inflight, CTLFLAG_RD, &unp_rights, 0, "");
533
534 static int
535 unp_attach(struct socket *so, struct pru_attach_info *ai)
536 {
537         struct unpcb *unp;
538         int error;
539
540         if (so->so_snd.ssb_hiwat == 0 || so->so_rcv.ssb_hiwat == 0) {
541                 switch (so->so_type) {
542
543                 case SOCK_STREAM:
544                         error = soreserve(so, unpst_sendspace, unpst_recvspace,
545                                           ai->sb_rlimit);
546                         break;
547
548                 case SOCK_DGRAM:
549                         error = soreserve(so, unpdg_sendspace, unpdg_recvspace,
550                                           ai->sb_rlimit);
551                         break;
552
553                 default:
554                         panic("unp_attach");
555                 }
556                 if (error)
557                         return (error);
558         }
559         unp = zalloc(unp_zone);
560         if (unp == NULL)
561                 return (ENOBUFS);
562         bzero(unp, sizeof *unp);
563         unp->unp_gencnt = ++unp_gencnt;
564         unp_count++;
565         LIST_INIT(&unp->unp_refs);
566         unp->unp_socket = so;
567         unp->unp_rvnode = ai->fd_rdir;          /* jail cruft XXX JH */
568         LIST_INSERT_HEAD(so->so_type == SOCK_DGRAM ? &unp_dhead
569                          : &unp_shead, unp, unp_link);
570         so->so_pcb = (caddr_t)unp;
571         return (0);
572 }
573
574 static void
575 unp_detach(struct unpcb *unp)
576 {
577         LIST_REMOVE(unp, unp_link);
578         unp->unp_gencnt = ++unp_gencnt;
579         --unp_count;
580         if (unp->unp_vnode) {
581                 unp->unp_vnode->v_socket = NULL;
582                 vrele(unp->unp_vnode);
583                 unp->unp_vnode = NULL;
584         }
585         if (unp->unp_conn)
586                 unp_disconnect(unp);
587         while (!LIST_EMPTY(&unp->unp_refs))
588                 unp_drop(LIST_FIRST(&unp->unp_refs), ECONNRESET);
589         soisdisconnected(unp->unp_socket);
590         unp->unp_socket->so_pcb = NULL;
591         if (unp_rights) {
592                 /*
593                  * Normally the receive buffer is flushed later,
594                  * in sofree, but if our receive buffer holds references
595                  * to descriptors that are now garbage, we will dispose
596                  * of those descriptor references after the garbage collector
597                  * gets them (resulting in a "panic: closef: count < 0").
598                  */
599                 sorflush(unp->unp_socket);
600                 unp_gc();
601         }
602         if (unp->unp_addr)
603                 kfree(unp->unp_addr, M_SONAME);
604         zfree(unp_zone, unp);
605 }
606
607 static int
608 unp_bind(struct unpcb *unp, struct sockaddr *nam, struct thread *td)
609 {
610         struct proc *p = td->td_proc;
611         struct sockaddr_un *soun = (struct sockaddr_un *)nam;
612         struct vnode *vp;
613         struct vattr vattr;
614         int error, namelen;
615         struct nlookupdata nd;
616         char buf[SOCK_MAXADDRLEN];
617
618         if (unp->unp_vnode != NULL)
619                 return (EINVAL);
620         namelen = soun->sun_len - offsetof(struct sockaddr_un, sun_path);
621         if (namelen <= 0)
622                 return (EINVAL);
623         strncpy(buf, soun->sun_path, namelen);
624         buf[namelen] = 0;       /* null-terminate the string */
625         error = nlookup_init(&nd, buf, UIO_SYSSPACE,
626                              NLC_LOCKVP | NLC_CREATE | NLC_REFDVP);
627         if (error == 0)
628                 error = nlookup(&nd);
629         if (error == 0 && nd.nl_nch.ncp->nc_vp != NULL)
630                 error = EADDRINUSE;
631         if (error)
632                 goto done;
633
634         VATTR_NULL(&vattr);
635         vattr.va_type = VSOCK;
636         vattr.va_mode = (ACCESSPERMS & ~p->p_fd->fd_cmask);
637         error = VOP_NCREATE(&nd.nl_nch, nd.nl_dvp, &vp, nd.nl_cred, &vattr);
638         if (error == 0) {
639                 vp->v_socket = unp->unp_socket;
640                 unp->unp_vnode = vp;
641                 unp->unp_addr = (struct sockaddr_un *)dup_sockaddr(nam);
642                 vn_unlock(vp);
643         }
644 done:
645         nlookup_done(&nd);
646         return (error);
647 }
648
649 static int
650 unp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
651 {
652         struct proc *p = td->td_proc;
653         struct sockaddr_un *soun = (struct sockaddr_un *)nam;
654         struct vnode *vp;
655         struct socket *so2, *so3;
656         struct unpcb *unp, *unp2, *unp3;
657         int error, len;
658         struct nlookupdata nd;
659         char buf[SOCK_MAXADDRLEN];
660
661         KKASSERT(p);
662
663         len = nam->sa_len - offsetof(struct sockaddr_un, sun_path);
664         if (len <= 0)
665                 return EINVAL;
666         strncpy(buf, soun->sun_path, len);
667         buf[len] = 0;
668
669         vp = NULL;
670         error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_FOLLOW);
671         if (error == 0)
672                 error = nlookup(&nd);
673         if (error == 0)
674                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
675         nlookup_done(&nd);
676         if (error)
677                 return (error);
678
679         if (vp->v_type != VSOCK) {
680                 error = ENOTSOCK;
681                 goto bad;
682         }
683         error = VOP_ACCESS(vp, VWRITE, p->p_ucred);
684         if (error)
685                 goto bad;
686         so2 = vp->v_socket;
687         if (so2 == NULL) {
688                 error = ECONNREFUSED;
689                 goto bad;
690         }
691         if (so->so_type != so2->so_type) {
692                 error = EPROTOTYPE;
693                 goto bad;
694         }
695         if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
696                 if (!(so2->so_options & SO_ACCEPTCONN) ||
697                     (so3 = sonewconn(so2, 0)) == NULL) {
698                         error = ECONNREFUSED;
699                         goto bad;
700                 }
701                 unp = so->so_pcb;
702                 unp2 = so2->so_pcb;
703                 unp3 = so3->so_pcb;
704                 if (unp2->unp_addr)
705                         unp3->unp_addr = (struct sockaddr_un *)
706                                 dup_sockaddr((struct sockaddr *)unp2->unp_addr);
707
708                 /*
709                  * unp_peercred management:
710                  *
711                  * The connecter's (client's) credentials are copied
712                  * from its process structure at the time of connect()
713                  * (which is now).
714                  */
715                 cru2x(p->p_ucred, &unp3->unp_peercred);
716                 unp3->unp_flags |= UNP_HAVEPC;
717                 /*
718                  * The receiver's (server's) credentials are copied
719                  * from the unp_peercred member of socket on which the
720                  * former called listen(); unp_listen() cached that
721                  * process's credentials at that time so we can use
722                  * them now.
723                  */
724                 KASSERT(unp2->unp_flags & UNP_HAVEPCCACHED,
725                     ("unp_connect: listener without cached peercred"));
726                 memcpy(&unp->unp_peercred, &unp2->unp_peercred,
727                     sizeof(unp->unp_peercred));
728                 unp->unp_flags |= UNP_HAVEPC;
729
730                 so2 = so3;
731         }
732         error = unp_connect2(so, so2);
733 bad:
734         vput(vp);
735         return (error);
736 }
737
738 int
739 unp_connect2(struct socket *so, struct socket *so2)
740 {
741         struct unpcb *unp = so->so_pcb;
742         struct unpcb *unp2;
743
744         if (so2->so_type != so->so_type)
745                 return (EPROTOTYPE);
746         unp2 = so2->so_pcb;
747         unp->unp_conn = unp2;
748         switch (so->so_type) {
749
750         case SOCK_DGRAM:
751                 LIST_INSERT_HEAD(&unp2->unp_refs, unp, unp_reflink);
752                 soisconnected(so);
753                 break;
754
755         case SOCK_STREAM:
756                 unp2->unp_conn = unp;
757                 soisconnected(so);
758                 soisconnected(so2);
759                 break;
760
761         default:
762                 panic("unp_connect2");
763         }
764         return (0);
765 }
766
767 static void
768 unp_disconnect(struct unpcb *unp)
769 {
770         struct unpcb *unp2 = unp->unp_conn;
771
772         if (unp2 == NULL)
773                 return;
774
775         unp->unp_conn = NULL;
776
777         switch (unp->unp_socket->so_type) {
778         case SOCK_DGRAM:
779                 LIST_REMOVE(unp, unp_reflink);
780                 unp->unp_socket->so_state &= ~SS_ISCONNECTED;
781                 break;
782         case SOCK_STREAM:
783                 soisdisconnected(unp->unp_socket);
784                 unp2->unp_conn = NULL;
785                 soisdisconnected(unp2->unp_socket);
786                 break;
787         }
788 }
789
790 #ifdef notdef
791 void
792 unp_abort(struct unpcb *unp)
793 {
794
795         unp_detach(unp);
796 }
797 #endif
798
799 static int
800 prison_unpcb(struct thread *td, struct unpcb *unp)
801 {
802         struct proc *p;
803
804         if (td == NULL)
805                 return (0);
806         if ((p = td->td_proc) == NULL)
807                 return (0);
808         if (!p->p_ucred->cr_prison)
809                 return (0);
810         if (p->p_fd->fd_rdir == unp->unp_rvnode)
811                 return (0);
812         return (1);
813 }
814
815 static int
816 unp_pcblist(SYSCTL_HANDLER_ARGS)
817 {
818         int error, i, n;
819         struct unpcb *unp, **unp_list;
820         unp_gen_t gencnt;
821         struct unp_head *head;
822
823         head = ((intptr_t)arg1 == SOCK_DGRAM ? &unp_dhead : &unp_shead);
824
825         KKASSERT(curproc != NULL);
826
827         /*
828          * The process of preparing the PCB list is too time-consuming and
829          * resource-intensive to repeat twice on every request.
830          */
831         if (req->oldptr == NULL) {
832                 n = unp_count;
833                 req->oldidx = (n + n/8) * sizeof(struct xunpcb);
834                 return 0;
835         }
836
837         if (req->newptr != NULL)
838                 return EPERM;
839
840         /*
841          * OK, now we're committed to doing something.
842          */
843         gencnt = unp_gencnt;
844         n = unp_count;
845
846         unp_list = kmalloc(n * sizeof *unp_list, M_TEMP, M_WAITOK);
847         
848         for (unp = LIST_FIRST(head), i = 0; unp && i < n;
849              unp = LIST_NEXT(unp, unp_link)) {
850                 if (unp->unp_gencnt <= gencnt && !prison_unpcb(req->td, unp))
851                         unp_list[i++] = unp;
852         }
853         n = i;                  /* in case we lost some during malloc */
854
855         error = 0;
856         for (i = 0; i < n; i++) {
857                 unp = unp_list[i];
858                 if (unp->unp_gencnt <= gencnt) {
859                         struct xunpcb xu;
860                         xu.xu_len = sizeof xu;
861                         xu.xu_unpp = unp;
862                         /*
863                          * XXX - need more locking here to protect against
864                          * connect/disconnect races for SMP.
865                          */
866                         if (unp->unp_addr)
867                                 bcopy(unp->unp_addr, &xu.xu_addr, 
868                                       unp->unp_addr->sun_len);
869                         if (unp->unp_conn && unp->unp_conn->unp_addr)
870                                 bcopy(unp->unp_conn->unp_addr,
871                                       &xu.xu_caddr,
872                                       unp->unp_conn->unp_addr->sun_len);
873                         bcopy(unp, &xu.xu_unp, sizeof *unp);
874                         sotoxsocket(unp->unp_socket, &xu.xu_socket);
875                         error = SYSCTL_OUT(req, &xu, sizeof xu);
876                 }
877         }
878         kfree(unp_list, M_TEMP);
879         return error;
880 }
881
882 SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLFLAG_RD, 
883             (caddr_t)(long)SOCK_DGRAM, 0, unp_pcblist, "S,xunpcb",
884             "List of active local datagram sockets");
885 SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLFLAG_RD, 
886             (caddr_t)(long)SOCK_STREAM, 0, unp_pcblist, "S,xunpcb",
887             "List of active local stream sockets");
888
889 static void
890 unp_shutdown(struct unpcb *unp)
891 {
892         struct socket *so;
893
894         if (unp->unp_socket->so_type == SOCK_STREAM && unp->unp_conn != NULL &&
895             (so = unp->unp_conn->unp_socket))
896                 socantrcvmore(so);
897 }
898
899 static void
900 unp_drop(struct unpcb *unp, int err)
901 {
902         struct socket *so = unp->unp_socket;
903
904         so->so_error = err;
905         unp_disconnect(unp);
906 }
907
908 #ifdef notdef
909 void
910 unp_drain(void)
911 {
912
913 }
914 #endif
915
916 int
917 unp_externalize(struct mbuf *rights)
918 {
919         struct proc *p = curproc;               /* XXX */
920         int i;
921         struct cmsghdr *cm = mtod(rights, struct cmsghdr *);
922         int *fdp;
923         struct file **rp;
924         struct file *fp;
925         int newfds = (cm->cmsg_len - (CMSG_DATA(cm) - (u_char *)cm))
926                 / sizeof (struct file *);
927         int f;
928
929         /*
930          * if the new FD's will not fit, then we free them all
931          */
932         if (!fdavail(p, newfds)) {
933                 rp = (struct file **)CMSG_DATA(cm);
934                 for (i = 0; i < newfds; i++) {
935                         fp = *rp;
936                         /*
937                          * zero the pointer before calling unp_discard,
938                          * since it may end up in unp_gc()..
939                          */
940                         *rp++ = 0;
941                         unp_discard(fp, NULL);
942                 }
943                 return (EMSGSIZE);
944         }
945         /*
946          * now change each pointer to an fd in the global table to 
947          * an integer that is the index to the local fd table entry
948          * that we set up to point to the global one we are transferring.
949          * If sizeof (struct file *) is bigger than or equal to sizeof int,
950          * then do it in forward order. In that case, an integer will
951          * always come in the same place or before its corresponding
952          * struct file pointer.
953          * If sizeof (struct file *) is smaller than sizeof int, then
954          * do it in reverse order.
955          */
956         if (sizeof (struct file *) >= sizeof (int)) {
957                 fdp = (int *)(cm + 1);
958                 rp = (struct file **)CMSG_DATA(cm);
959                 for (i = 0; i < newfds; i++) {
960                         if (fdalloc(p, 0, &f))
961                                 panic("unp_externalize");
962                         fp = *rp++;
963                         fsetfd(p, fp, f);
964                         fdrop(fp);
965                         spin_lock_wr(&unp_spin);
966                         fp->f_msgcount--;
967                         unp_rights--;
968                         spin_unlock_wr(&unp_spin);
969                         *fdp++ = f;
970                 }
971         } else {
972                 fdp = (int *)(cm + 1) + newfds - 1;
973                 rp = (struct file **)CMSG_DATA(cm) + newfds - 1;
974                 for (i = 0; i < newfds; i++) {
975                         if (fdalloc(p, 0, &f))
976                                 panic("unp_externalize");
977                         fp = *rp--;
978                         fsetfd(p, fp, f);
979                         fdrop(fp);
980                         spin_lock_wr(&unp_spin);
981                         fp->f_msgcount--;
982                         unp_rights--;
983                         spin_unlock_wr(&unp_spin);
984                         *fdp-- = f;
985                 }
986         }
987
988         /*
989          * Adjust length, in case sizeof(struct file *) and sizeof(int)
990          * differs.
991          */
992         cm->cmsg_len = CMSG_LEN(newfds * sizeof(int));
993         rights->m_len = cm->cmsg_len;
994         return (0);
995 }
996
997 void
998 unp_init(void)
999 {
1000         unp_zone = zinit("unpcb", sizeof(struct unpcb), nmbclusters, 0, 0);
1001         if (unp_zone == NULL)
1002                 panic("unp_init");
1003         LIST_INIT(&unp_dhead);
1004         LIST_INIT(&unp_shead);
1005         spin_init(&unp_spin);
1006 }
1007
1008 static int
1009 unp_internalize(struct mbuf *control, struct thread *td)
1010 {
1011         struct proc *p = td->td_proc;
1012         struct filedesc *fdescp;
1013         struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1014         struct file **rp;
1015         struct file *fp;
1016         int i, fd, *fdp;
1017         struct cmsgcred *cmcred;
1018         int oldfds;
1019         u_int newlen;
1020
1021         KKASSERT(p);
1022         fdescp = p->p_fd;
1023         if ((cm->cmsg_type != SCM_RIGHTS && cm->cmsg_type != SCM_CREDS) ||
1024             cm->cmsg_level != SOL_SOCKET || cm->cmsg_len != control->m_len)
1025                 return (EINVAL);
1026
1027         /*
1028          * Fill in credential information.
1029          */
1030         if (cm->cmsg_type == SCM_CREDS) {
1031                 cmcred = (struct cmsgcred *)(cm + 1);
1032                 cmcred->cmcred_pid = p->p_pid;
1033                 cmcred->cmcred_uid = p->p_ucred->cr_ruid;
1034                 cmcred->cmcred_gid = p->p_ucred->cr_rgid;
1035                 cmcred->cmcred_euid = p->p_ucred->cr_uid;
1036                 cmcred->cmcred_ngroups = MIN(p->p_ucred->cr_ngroups,
1037                                                         CMGROUP_MAX);
1038                 for (i = 0; i < cmcred->cmcred_ngroups; i++)
1039                         cmcred->cmcred_groups[i] = p->p_ucred->cr_groups[i];
1040                 return(0);
1041         }
1042
1043         oldfds = (cm->cmsg_len - sizeof (*cm)) / sizeof (int);
1044         /*
1045          * check that all the FDs passed in refer to legal OPEN files
1046          * If not, reject the entire operation.
1047          */
1048         fdp = (int *)(cm + 1);
1049         for (i = 0; i < oldfds; i++) {
1050                 fd = *fdp++;
1051                 if ((unsigned)fd >= fdescp->fd_nfiles ||
1052                     fdescp->fd_files[fd].fp == NULL)
1053                         return (EBADF);
1054                 if (fdescp->fd_files[fd].fp->f_type == DTYPE_KQUEUE)
1055                         return (EOPNOTSUPP);
1056         }
1057         /*
1058          * Now replace the integer FDs with pointers to
1059          * the associated global file table entry..
1060          * Allocate a bigger buffer as necessary. But if an cluster is not
1061          * enough, return E2BIG.
1062          */
1063         newlen = CMSG_LEN(oldfds * sizeof(struct file *));
1064         if (newlen > MCLBYTES)
1065                 return (E2BIG);
1066         if (newlen - control->m_len > M_TRAILINGSPACE(control)) {
1067                 if (control->m_flags & M_EXT)
1068                         return (E2BIG);
1069                 MCLGET(control, MB_WAIT);
1070                 if (!(control->m_flags & M_EXT))
1071                         return (ENOBUFS);
1072
1073                 /* copy the data to the cluster */
1074                 memcpy(mtod(control, char *), cm, cm->cmsg_len);
1075                 cm = mtod(control, struct cmsghdr *);
1076         }
1077
1078         /*
1079          * Adjust length, in case sizeof(struct file *) and sizeof(int)
1080          * differs.
1081          */
1082         control->m_len = cm->cmsg_len = newlen;
1083
1084         /*
1085          * Transform the file descriptors into struct file pointers.
1086          * If sizeof (struct file *) is bigger than or equal to sizeof int,
1087          * then do it in reverse order so that the int won't get until
1088          * we're done.
1089          * If sizeof (struct file *) is smaller than sizeof int, then
1090          * do it in forward order.
1091          */
1092         if (sizeof (struct file *) >= sizeof (int)) {
1093                 fdp = (int *)(cm + 1) + oldfds - 1;
1094                 rp = (struct file **)CMSG_DATA(cm) + oldfds - 1;
1095                 for (i = 0; i < oldfds; i++) {
1096                         fp = fdescp->fd_files[*fdp--].fp;
1097                         *rp-- = fp;
1098                         fhold(fp);
1099                         spin_lock_wr(&unp_spin);
1100                         fp->f_msgcount++;
1101                         unp_rights++;
1102                         spin_unlock_wr(&unp_spin);
1103                 }
1104         } else {
1105                 fdp = (int *)(cm + 1);
1106                 rp = (struct file **)CMSG_DATA(cm);
1107                 for (i = 0; i < oldfds; i++) {
1108                         fp = fdescp->fd_files[*fdp++].fp;
1109                         *rp++ = fp;
1110                         fhold(fp);
1111                         spin_lock_wr(&unp_spin);
1112                         fp->f_msgcount++;
1113                         unp_rights++;
1114                         spin_unlock_wr(&unp_spin);
1115                 }
1116         }
1117         return (0);
1118 }
1119
1120 /*
1121  * Garbage collect in-transit file descriptors that get lost due to
1122  * loops (i.e. when a socket is sent to another process over itself,
1123  * and more complex situations).
1124  *
1125  * NOT MPSAFE - TODO socket flush code and maybe closef.  Rest is MPSAFE.
1126  */
1127
1128 struct unp_gc_info {
1129         struct file **extra_ref;
1130         struct file *locked_fp;
1131         int defer;
1132         int index;
1133         int maxindex;
1134 };
1135
1136 static void
1137 unp_gc(void)
1138 {
1139         struct unp_gc_info info;
1140         static boolean_t unp_gcing;
1141         struct file **fpp;
1142         int i;
1143
1144         spin_lock_wr(&unp_spin);
1145         if (unp_gcing) {
1146                 spin_unlock_wr(&unp_spin);
1147                 return;
1148         }
1149         unp_gcing = TRUE;
1150         spin_unlock_wr(&unp_spin);
1151
1152         /* 
1153          * before going through all this, set all FDs to 
1154          * be NOT defered and NOT externally accessible
1155          */
1156         info.defer = 0;
1157         allfiles_scan_exclusive(unp_gc_clearmarks, NULL);
1158         do {
1159                 allfiles_scan_exclusive(unp_gc_checkmarks, &info);
1160         } while (info.defer);
1161
1162         /*
1163          * We grab an extra reference to each of the file table entries
1164          * that are not otherwise accessible and then free the rights
1165          * that are stored in messages on them.
1166          *
1167          * The bug in the orginal code is a little tricky, so I'll describe
1168          * what's wrong with it here.
1169          *
1170          * It is incorrect to simply unp_discard each entry for f_msgcount
1171          * times -- consider the case of sockets A and B that contain
1172          * references to each other.  On a last close of some other socket,
1173          * we trigger a gc since the number of outstanding rights (unp_rights)
1174          * is non-zero.  If during the sweep phase the gc code un_discards,
1175          * we end up doing a (full) closef on the descriptor.  A closef on A
1176          * results in the following chain.  Closef calls soo_close, which
1177          * calls soclose.   Soclose calls first (through the switch
1178          * uipc_usrreq) unp_detach, which re-invokes unp_gc.  Unp_gc simply
1179          * returns because the previous instance had set unp_gcing, and
1180          * we return all the way back to soclose, which marks the socket
1181          * with SS_NOFDREF, and then calls sofree.  Sofree calls sorflush
1182          * to free up the rights that are queued in messages on the socket A,
1183          * i.e., the reference on B.  The sorflush calls via the dom_dispose
1184          * switch unp_dispose, which unp_scans with unp_discard.  This second
1185          * instance of unp_discard just calls closef on B.
1186          *
1187          * Well, a similar chain occurs on B, resulting in a sorflush on B,
1188          * which results in another closef on A.  Unfortunately, A is already
1189          * being closed, and the descriptor has already been marked with
1190          * SS_NOFDREF, and soclose panics at this point.
1191          *
1192          * Here, we first take an extra reference to each inaccessible
1193          * descriptor.  Then, we call sorflush ourself, since we know
1194          * it is a Unix domain socket anyhow.  After we destroy all the
1195          * rights carried in messages, we do a last closef to get rid
1196          * of our extra reference.  This is the last close, and the
1197          * unp_detach etc will shut down the socket.
1198          *
1199          * 91/09/19, bsy@cs.cmu.edu
1200          */
1201         info.extra_ref = kmalloc(256 * sizeof(struct file *), M_FILE, M_WAITOK);
1202         info.maxindex = 256;
1203
1204         do {
1205                 /*
1206                  * Look for matches
1207                  */
1208                 info.index = 0;
1209                 allfiles_scan_exclusive(unp_gc_checkrefs, &info);
1210
1211                 /* 
1212                  * For each FD on our hit list, do the following two things
1213                  */
1214                 for (i = info.index, fpp = info.extra_ref; --i >= 0; ++fpp) {
1215                         struct file *tfp = *fpp;
1216                         if (tfp->f_type == DTYPE_SOCKET && tfp->f_data != NULL)
1217                                 sorflush((struct socket *)(tfp->f_data));
1218                 }
1219                 for (i = info.index, fpp = info.extra_ref; --i >= 0; ++fpp)
1220                         closef(*fpp, NULL);
1221         } while (info.index == info.maxindex);
1222         kfree((caddr_t)info.extra_ref, M_FILE);
1223         unp_gcing = FALSE;
1224 }
1225
1226 /*
1227  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1228  */
1229 static int
1230 unp_gc_checkrefs(struct file *fp, void *data)
1231 {
1232         struct unp_gc_info *info = data;
1233
1234         if (fp->f_count == 0)
1235                 return(0);
1236         if (info->index == info->maxindex)
1237                 return(-1);
1238
1239         /* 
1240          * If all refs are from msgs, and it's not marked accessible
1241          * then it must be referenced from some unreachable cycle
1242          * of (shut-down) FDs, so include it in our
1243          * list of FDs to remove
1244          */
1245         if (fp->f_count == fp->f_msgcount && !(fp->f_flag & FMARK)) {
1246                 info->extra_ref[info->index++] = fp;
1247                 fhold(fp);
1248         }
1249         return(0);
1250 }
1251
1252 /*
1253  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1254  */
1255 static int
1256 unp_gc_clearmarks(struct file *fp, void *data __unused)
1257 {
1258         fp->f_flag &= ~(FMARK|FDEFER);
1259         return(0);
1260 }
1261
1262 /*
1263  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1264  */
1265 static int
1266 unp_gc_checkmarks(struct file *fp, void *data)
1267 {
1268         struct unp_gc_info *info = data;
1269         struct socket *so;
1270
1271         /*
1272          * If the file is not open, skip it
1273          */
1274         if (fp->f_count == 0)
1275                 return(0);
1276         /*
1277          * If we already marked it as 'defer'  in a
1278          * previous pass, then try process it this time
1279          * and un-mark it
1280          */
1281         if (fp->f_flag & FDEFER) {
1282                 fp->f_flag &= ~FDEFER;
1283                 --info->defer;
1284         } else {
1285                 /*
1286                  * if it's not defered, then check if it's
1287                  * already marked.. if so skip it
1288                  */
1289                 if (fp->f_flag & FMARK)
1290                         return(0);
1291                 /* 
1292                  * If all references are from messages
1293                  * in transit, then skip it. it's not 
1294                  * externally accessible.
1295                  */ 
1296                 if (fp->f_count == fp->f_msgcount)
1297                         return(0);
1298                 /* 
1299                  * If it got this far then it must be
1300                  * externally accessible.
1301                  */
1302                 fp->f_flag |= FMARK;
1303         }
1304         /*
1305          * either it was defered, or it is externally 
1306          * accessible and not already marked so.
1307          * Now check if it is possibly one of OUR sockets.
1308          */ 
1309         if (fp->f_type != DTYPE_SOCKET ||
1310             (so = (struct socket *)fp->f_data) == NULL)
1311                 return(0);
1312         if (so->so_proto->pr_domain != &localdomain ||
1313             !(so->so_proto->pr_flags & PR_RIGHTS))
1314                 return(0);
1315 #ifdef notdef
1316         XXX note: exclusive fp->f_spin lock held
1317         if (so->so_rcv.sb_flags & SB_LOCK) {
1318                 /*
1319                  * This is problematical; it's not clear
1320                  * we need to wait for the sockbuf to be
1321                  * unlocked (on a uniprocessor, at least),
1322                  * and it's also not clear what to do
1323                  * if sbwait returns an error due to receipt
1324                  * of a signal.  If sbwait does return
1325                  * an error, we'll go into an infinite
1326                  * loop.  Delete all of this for now.
1327                  */
1328                 sbwait(&so->so_rcv);
1329                 goto restart;
1330         }
1331 #endif
1332         /*
1333          * So, Ok, it's one of our sockets and it IS externally
1334          * accessible (or was defered). Now we look
1335          * to see if we hold any file descriptors in its
1336          * message buffers. Follow those links and mark them 
1337          * as accessible too.
1338          */
1339         info->locked_fp = fp;
1340 /*      spin_lock_wr(&so->so_rcv.sb_spin); */
1341         unp_scan(so->so_rcv.ssb_mb, unp_mark, info);
1342 /*      spin_unlock_wr(&so->so_rcv.sb_spin);*/
1343         return (0);
1344 }
1345
1346 void
1347 unp_dispose(struct mbuf *m)
1348 {
1349         if (m)
1350                 unp_scan(m, unp_discard, NULL);
1351 }
1352
1353 static int
1354 unp_listen(struct unpcb *unp, struct thread *td)
1355 {
1356         struct proc *p = td->td_proc;
1357
1358         KKASSERT(p);
1359         cru2x(p->p_ucred, &unp->unp_peercred);
1360         unp->unp_flags |= UNP_HAVEPCCACHED;
1361         return (0);
1362 }
1363
1364 static void
1365 unp_scan(struct mbuf *m0, void (*op)(struct file *, void *), void *data)
1366 {
1367         struct mbuf *m;
1368         struct file **rp;
1369         struct cmsghdr *cm;
1370         int i;
1371         int qfds;
1372
1373         while (m0) {
1374                 for (m = m0; m; m = m->m_next) {
1375                         if (m->m_type == MT_CONTROL &&
1376                             m->m_len >= sizeof(*cm)) {
1377                                 cm = mtod(m, struct cmsghdr *);
1378                                 if (cm->cmsg_level != SOL_SOCKET ||
1379                                     cm->cmsg_type != SCM_RIGHTS)
1380                                         continue;
1381                                 qfds = (cm->cmsg_len -
1382                                         (CMSG_DATA(cm) - (u_char *)cm))
1383                                                 / sizeof (struct file *);
1384                                 rp = (struct file **)CMSG_DATA(cm);
1385                                 for (i = 0; i < qfds; i++)
1386                                         (*op)(*rp++, data);
1387                                 break;          /* XXX, but saves time */
1388                         }
1389                 }
1390                 m0 = m0->m_nextpkt;
1391         }
1392 }
1393
1394 static void
1395 unp_mark(struct file *fp, void *data)
1396 {
1397         struct unp_gc_info *info = data;
1398
1399         if (info->locked_fp != fp)
1400                 spin_lock_wr(&fp->f_spin);
1401         if ((fp->f_flag & FMARK) == 0) {
1402                 ++info->defer;
1403                 fp->f_flag |= (FMARK|FDEFER);
1404         }
1405         if (info->locked_fp != fp)
1406                 spin_unlock_wr(&fp->f_spin);
1407 }
1408
1409 static void
1410 unp_discard(struct file *fp, void *data __unused)
1411 {
1412         spin_lock_wr(&unp_spin);
1413         fp->f_msgcount--;
1414         unp_rights--;
1415         spin_unlock_wr(&unp_spin);
1416         closef(fp, NULL);
1417 }
1418