3f5bc1a25c20d2141090a88e5b5573ae55b03754
[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.38 2008/05/08 01:41:05 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 *dvp;
613         struct vnode *vp;
614         struct vattr vattr;
615         int error, namelen;
616         struct nlookupdata nd;
617         char buf[SOCK_MAXADDRLEN];
618
619         if (unp->unp_vnode != NULL)
620                 return (EINVAL);
621         namelen = soun->sun_len - offsetof(struct sockaddr_un, sun_path);
622         if (namelen <= 0)
623                 return (EINVAL);
624         strncpy(buf, soun->sun_path, namelen);
625         buf[namelen] = 0;       /* null-terminate the string */
626         error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_LOCKVP|NLC_CREATE);
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 == 0 && (dvp = cache_dvpref(nd.nl_nch.ncp)) == NULL)
632                 error = EPERM;
633         if (error)
634                 goto done;
635
636         VATTR_NULL(&vattr);
637         vattr.va_type = VSOCK;
638         vattr.va_mode = (ACCESSPERMS & ~p->p_fd->fd_cmask);
639         error = VOP_NCREATE(&nd.nl_nch, dvp, &vp, nd.nl_cred, &vattr);
640         cache_dvprel(dvp);
641         if (error == 0) {
642                 vp->v_socket = unp->unp_socket;
643                 unp->unp_vnode = vp;
644                 unp->unp_addr = (struct sockaddr_un *)dup_sockaddr(nam);
645                 vn_unlock(vp);
646         }
647 done:
648         nlookup_done(&nd);
649         return (error);
650 }
651
652 static int
653 unp_connect(struct socket *so, struct sockaddr *nam, struct thread *td)
654 {
655         struct proc *p = td->td_proc;
656         struct sockaddr_un *soun = (struct sockaddr_un *)nam;
657         struct vnode *vp;
658         struct socket *so2, *so3;
659         struct unpcb *unp, *unp2, *unp3;
660         int error, len;
661         struct nlookupdata nd;
662         char buf[SOCK_MAXADDRLEN];
663
664         KKASSERT(p);
665
666         len = nam->sa_len - offsetof(struct sockaddr_un, sun_path);
667         if (len <= 0)
668                 return EINVAL;
669         strncpy(buf, soun->sun_path, len);
670         buf[len] = 0;
671
672         vp = NULL;
673         error = nlookup_init(&nd, buf, UIO_SYSSPACE, NLC_FOLLOW);
674         if (error == 0)
675                 error = nlookup(&nd);
676         if (error == 0)
677                 error = cache_vget(&nd.nl_nch, nd.nl_cred, LK_EXCLUSIVE, &vp);
678         nlookup_done(&nd);
679         if (error)
680                 return (error);
681
682         if (vp->v_type != VSOCK) {
683                 error = ENOTSOCK;
684                 goto bad;
685         }
686         error = VOP_ACCESS(vp, VWRITE, p->p_ucred);
687         if (error)
688                 goto bad;
689         so2 = vp->v_socket;
690         if (so2 == NULL) {
691                 error = ECONNREFUSED;
692                 goto bad;
693         }
694         if (so->so_type != so2->so_type) {
695                 error = EPROTOTYPE;
696                 goto bad;
697         }
698         if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
699                 if (!(so2->so_options & SO_ACCEPTCONN) ||
700                     (so3 = sonewconn(so2, 0)) == NULL) {
701                         error = ECONNREFUSED;
702                         goto bad;
703                 }
704                 unp = so->so_pcb;
705                 unp2 = so2->so_pcb;
706                 unp3 = so3->so_pcb;
707                 if (unp2->unp_addr)
708                         unp3->unp_addr = (struct sockaddr_un *)
709                                 dup_sockaddr((struct sockaddr *)unp2->unp_addr);
710
711                 /*
712                  * unp_peercred management:
713                  *
714                  * The connecter's (client's) credentials are copied
715                  * from its process structure at the time of connect()
716                  * (which is now).
717                  */
718                 cru2x(p->p_ucred, &unp3->unp_peercred);
719                 unp3->unp_flags |= UNP_HAVEPC;
720                 /*
721                  * The receiver's (server's) credentials are copied
722                  * from the unp_peercred member of socket on which the
723                  * former called listen(); unp_listen() cached that
724                  * process's credentials at that time so we can use
725                  * them now.
726                  */
727                 KASSERT(unp2->unp_flags & UNP_HAVEPCCACHED,
728                     ("unp_connect: listener without cached peercred"));
729                 memcpy(&unp->unp_peercred, &unp2->unp_peercred,
730                     sizeof(unp->unp_peercred));
731                 unp->unp_flags |= UNP_HAVEPC;
732
733                 so2 = so3;
734         }
735         error = unp_connect2(so, so2);
736 bad:
737         vput(vp);
738         return (error);
739 }
740
741 int
742 unp_connect2(struct socket *so, struct socket *so2)
743 {
744         struct unpcb *unp = so->so_pcb;
745         struct unpcb *unp2;
746
747         if (so2->so_type != so->so_type)
748                 return (EPROTOTYPE);
749         unp2 = so2->so_pcb;
750         unp->unp_conn = unp2;
751         switch (so->so_type) {
752
753         case SOCK_DGRAM:
754                 LIST_INSERT_HEAD(&unp2->unp_refs, unp, unp_reflink);
755                 soisconnected(so);
756                 break;
757
758         case SOCK_STREAM:
759                 unp2->unp_conn = unp;
760                 soisconnected(so);
761                 soisconnected(so2);
762                 break;
763
764         default:
765                 panic("unp_connect2");
766         }
767         return (0);
768 }
769
770 static void
771 unp_disconnect(struct unpcb *unp)
772 {
773         struct unpcb *unp2 = unp->unp_conn;
774
775         if (unp2 == NULL)
776                 return;
777
778         unp->unp_conn = NULL;
779
780         switch (unp->unp_socket->so_type) {
781         case SOCK_DGRAM:
782                 LIST_REMOVE(unp, unp_reflink);
783                 unp->unp_socket->so_state &= ~SS_ISCONNECTED;
784                 break;
785         case SOCK_STREAM:
786                 soisdisconnected(unp->unp_socket);
787                 unp2->unp_conn = NULL;
788                 soisdisconnected(unp2->unp_socket);
789                 break;
790         }
791 }
792
793 #ifdef notdef
794 void
795 unp_abort(struct unpcb *unp)
796 {
797
798         unp_detach(unp);
799 }
800 #endif
801
802 static int
803 prison_unpcb(struct thread *td, struct unpcb *unp)
804 {
805         struct proc *p;
806
807         if (td == NULL)
808                 return (0);
809         if ((p = td->td_proc) == NULL)
810                 return (0);
811         if (!p->p_ucred->cr_prison)
812                 return (0);
813         if (p->p_fd->fd_rdir == unp->unp_rvnode)
814                 return (0);
815         return (1);
816 }
817
818 static int
819 unp_pcblist(SYSCTL_HANDLER_ARGS)
820 {
821         int error, i, n;
822         struct unpcb *unp, **unp_list;
823         unp_gen_t gencnt;
824         struct unp_head *head;
825
826         head = ((intptr_t)arg1 == SOCK_DGRAM ? &unp_dhead : &unp_shead);
827
828         KKASSERT(curproc != NULL);
829
830         /*
831          * The process of preparing the PCB list is too time-consuming and
832          * resource-intensive to repeat twice on every request.
833          */
834         if (req->oldptr == NULL) {
835                 n = unp_count;
836                 req->oldidx = (n + n/8) * sizeof(struct xunpcb);
837                 return 0;
838         }
839
840         if (req->newptr != NULL)
841                 return EPERM;
842
843         /*
844          * OK, now we're committed to doing something.
845          */
846         gencnt = unp_gencnt;
847         n = unp_count;
848
849         unp_list = kmalloc(n * sizeof *unp_list, M_TEMP, M_WAITOK);
850         
851         for (unp = LIST_FIRST(head), i = 0; unp && i < n;
852              unp = LIST_NEXT(unp, unp_link)) {
853                 if (unp->unp_gencnt <= gencnt && !prison_unpcb(req->td, unp))
854                         unp_list[i++] = unp;
855         }
856         n = i;                  /* in case we lost some during malloc */
857
858         error = 0;
859         for (i = 0; i < n; i++) {
860                 unp = unp_list[i];
861                 if (unp->unp_gencnt <= gencnt) {
862                         struct xunpcb xu;
863                         xu.xu_len = sizeof xu;
864                         xu.xu_unpp = unp;
865                         /*
866                          * XXX - need more locking here to protect against
867                          * connect/disconnect races for SMP.
868                          */
869                         if (unp->unp_addr)
870                                 bcopy(unp->unp_addr, &xu.xu_addr, 
871                                       unp->unp_addr->sun_len);
872                         if (unp->unp_conn && unp->unp_conn->unp_addr)
873                                 bcopy(unp->unp_conn->unp_addr,
874                                       &xu.xu_caddr,
875                                       unp->unp_conn->unp_addr->sun_len);
876                         bcopy(unp, &xu.xu_unp, sizeof *unp);
877                         sotoxsocket(unp->unp_socket, &xu.xu_socket);
878                         error = SYSCTL_OUT(req, &xu, sizeof xu);
879                 }
880         }
881         kfree(unp_list, M_TEMP);
882         return error;
883 }
884
885 SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLFLAG_RD, 
886             (caddr_t)(long)SOCK_DGRAM, 0, unp_pcblist, "S,xunpcb",
887             "List of active local datagram sockets");
888 SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLFLAG_RD, 
889             (caddr_t)(long)SOCK_STREAM, 0, unp_pcblist, "S,xunpcb",
890             "List of active local stream sockets");
891
892 static void
893 unp_shutdown(struct unpcb *unp)
894 {
895         struct socket *so;
896
897         if (unp->unp_socket->so_type == SOCK_STREAM && unp->unp_conn != NULL &&
898             (so = unp->unp_conn->unp_socket))
899                 socantrcvmore(so);
900 }
901
902 static void
903 unp_drop(struct unpcb *unp, int err)
904 {
905         struct socket *so = unp->unp_socket;
906
907         so->so_error = err;
908         unp_disconnect(unp);
909 }
910
911 #ifdef notdef
912 void
913 unp_drain(void)
914 {
915
916 }
917 #endif
918
919 int
920 unp_externalize(struct mbuf *rights)
921 {
922         struct proc *p = curproc;               /* XXX */
923         int i;
924         struct cmsghdr *cm = mtod(rights, struct cmsghdr *);
925         int *fdp;
926         struct file **rp;
927         struct file *fp;
928         int newfds = (cm->cmsg_len - (CMSG_DATA(cm) - (u_char *)cm))
929                 / sizeof (struct file *);
930         int f;
931
932         /*
933          * if the new FD's will not fit, then we free them all
934          */
935         if (!fdavail(p, newfds)) {
936                 rp = (struct file **)CMSG_DATA(cm);
937                 for (i = 0; i < newfds; i++) {
938                         fp = *rp;
939                         /*
940                          * zero the pointer before calling unp_discard,
941                          * since it may end up in unp_gc()..
942                          */
943                         *rp++ = 0;
944                         unp_discard(fp, NULL);
945                 }
946                 return (EMSGSIZE);
947         }
948         /*
949          * now change each pointer to an fd in the global table to 
950          * an integer that is the index to the local fd table entry
951          * that we set up to point to the global one we are transferring.
952          * If sizeof (struct file *) is bigger than or equal to sizeof int,
953          * then do it in forward order. In that case, an integer will
954          * always come in the same place or before its corresponding
955          * struct file pointer.
956          * If sizeof (struct file *) is smaller than sizeof int, then
957          * do it in reverse order.
958          */
959         if (sizeof (struct file *) >= sizeof (int)) {
960                 fdp = (int *)(cm + 1);
961                 rp = (struct file **)CMSG_DATA(cm);
962                 for (i = 0; i < newfds; i++) {
963                         if (fdalloc(p, 0, &f))
964                                 panic("unp_externalize");
965                         fp = *rp++;
966                         fsetfd(p, fp, f);
967                         fdrop(fp);
968                         spin_lock_wr(&unp_spin);
969                         fp->f_msgcount--;
970                         unp_rights--;
971                         spin_unlock_wr(&unp_spin);
972                         *fdp++ = f;
973                 }
974         } else {
975                 fdp = (int *)(cm + 1) + newfds - 1;
976                 rp = (struct file **)CMSG_DATA(cm) + newfds - 1;
977                 for (i = 0; i < newfds; i++) {
978                         if (fdalloc(p, 0, &f))
979                                 panic("unp_externalize");
980                         fp = *rp--;
981                         fsetfd(p, fp, f);
982                         fdrop(fp);
983                         spin_lock_wr(&unp_spin);
984                         fp->f_msgcount--;
985                         unp_rights--;
986                         spin_unlock_wr(&unp_spin);
987                         *fdp-- = f;
988                 }
989         }
990
991         /*
992          * Adjust length, in case sizeof(struct file *) and sizeof(int)
993          * differs.
994          */
995         cm->cmsg_len = CMSG_LEN(newfds * sizeof(int));
996         rights->m_len = cm->cmsg_len;
997         return (0);
998 }
999
1000 void
1001 unp_init(void)
1002 {
1003         unp_zone = zinit("unpcb", sizeof(struct unpcb), nmbclusters, 0, 0);
1004         if (unp_zone == NULL)
1005                 panic("unp_init");
1006         LIST_INIT(&unp_dhead);
1007         LIST_INIT(&unp_shead);
1008         spin_init(&unp_spin);
1009 }
1010
1011 static int
1012 unp_internalize(struct mbuf *control, struct thread *td)
1013 {
1014         struct proc *p = td->td_proc;
1015         struct filedesc *fdescp;
1016         struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1017         struct file **rp;
1018         struct file *fp;
1019         int i, fd, *fdp;
1020         struct cmsgcred *cmcred;
1021         int oldfds;
1022         u_int newlen;
1023
1024         KKASSERT(p);
1025         fdescp = p->p_fd;
1026         if ((cm->cmsg_type != SCM_RIGHTS && cm->cmsg_type != SCM_CREDS) ||
1027             cm->cmsg_level != SOL_SOCKET || cm->cmsg_len != control->m_len)
1028                 return (EINVAL);
1029
1030         /*
1031          * Fill in credential information.
1032          */
1033         if (cm->cmsg_type == SCM_CREDS) {
1034                 cmcred = (struct cmsgcred *)(cm + 1);
1035                 cmcred->cmcred_pid = p->p_pid;
1036                 cmcred->cmcred_uid = p->p_ucred->cr_ruid;
1037                 cmcred->cmcred_gid = p->p_ucred->cr_rgid;
1038                 cmcred->cmcred_euid = p->p_ucred->cr_uid;
1039                 cmcred->cmcred_ngroups = MIN(p->p_ucred->cr_ngroups,
1040                                                         CMGROUP_MAX);
1041                 for (i = 0; i < cmcred->cmcred_ngroups; i++)
1042                         cmcred->cmcred_groups[i] = p->p_ucred->cr_groups[i];
1043                 return(0);
1044         }
1045
1046         oldfds = (cm->cmsg_len - sizeof (*cm)) / sizeof (int);
1047         /*
1048          * check that all the FDs passed in refer to legal OPEN files
1049          * If not, reject the entire operation.
1050          */
1051         fdp = (int *)(cm + 1);
1052         for (i = 0; i < oldfds; i++) {
1053                 fd = *fdp++;
1054                 if ((unsigned)fd >= fdescp->fd_nfiles ||
1055                     fdescp->fd_files[fd].fp == NULL)
1056                         return (EBADF);
1057                 if (fdescp->fd_files[fd].fp->f_type == DTYPE_KQUEUE)
1058                         return (EOPNOTSUPP);
1059         }
1060         /*
1061          * Now replace the integer FDs with pointers to
1062          * the associated global file table entry..
1063          * Allocate a bigger buffer as necessary. But if an cluster is not
1064          * enough, return E2BIG.
1065          */
1066         newlen = CMSG_LEN(oldfds * sizeof(struct file *));
1067         if (newlen > MCLBYTES)
1068                 return (E2BIG);
1069         if (newlen - control->m_len > M_TRAILINGSPACE(control)) {
1070                 if (control->m_flags & M_EXT)
1071                         return (E2BIG);
1072                 MCLGET(control, MB_WAIT);
1073                 if (!(control->m_flags & M_EXT))
1074                         return (ENOBUFS);
1075
1076                 /* copy the data to the cluster */
1077                 memcpy(mtod(control, char *), cm, cm->cmsg_len);
1078                 cm = mtod(control, struct cmsghdr *);
1079         }
1080
1081         /*
1082          * Adjust length, in case sizeof(struct file *) and sizeof(int)
1083          * differs.
1084          */
1085         control->m_len = cm->cmsg_len = newlen;
1086
1087         /*
1088          * Transform the file descriptors into struct file pointers.
1089          * If sizeof (struct file *) is bigger than or equal to sizeof int,
1090          * then do it in reverse order so that the int won't get until
1091          * we're done.
1092          * If sizeof (struct file *) is smaller than sizeof int, then
1093          * do it in forward order.
1094          */
1095         if (sizeof (struct file *) >= sizeof (int)) {
1096                 fdp = (int *)(cm + 1) + oldfds - 1;
1097                 rp = (struct file **)CMSG_DATA(cm) + oldfds - 1;
1098                 for (i = 0; i < oldfds; i++) {
1099                         fp = fdescp->fd_files[*fdp--].fp;
1100                         *rp-- = fp;
1101                         fhold(fp);
1102                         spin_lock_wr(&unp_spin);
1103                         fp->f_msgcount++;
1104                         unp_rights++;
1105                         spin_unlock_wr(&unp_spin);
1106                 }
1107         } else {
1108                 fdp = (int *)(cm + 1);
1109                 rp = (struct file **)CMSG_DATA(cm);
1110                 for (i = 0; i < oldfds; i++) {
1111                         fp = fdescp->fd_files[*fdp++].fp;
1112                         *rp++ = fp;
1113                         fhold(fp);
1114                         spin_lock_wr(&unp_spin);
1115                         fp->f_msgcount++;
1116                         unp_rights++;
1117                         spin_unlock_wr(&unp_spin);
1118                 }
1119         }
1120         return (0);
1121 }
1122
1123 /*
1124  * Garbage collect in-transit file descriptors that get lost due to
1125  * loops (i.e. when a socket is sent to another process over itself,
1126  * and more complex situations).
1127  *
1128  * NOT MPSAFE - TODO socket flush code and maybe closef.  Rest is MPSAFE.
1129  */
1130
1131 struct unp_gc_info {
1132         struct file **extra_ref;
1133         struct file *locked_fp;
1134         int defer;
1135         int index;
1136         int maxindex;
1137 };
1138
1139 static void
1140 unp_gc(void)
1141 {
1142         struct unp_gc_info info;
1143         static boolean_t unp_gcing;
1144         struct file **fpp;
1145         int i;
1146
1147         spin_lock_wr(&unp_spin);
1148         if (unp_gcing) {
1149                 spin_unlock_wr(&unp_spin);
1150                 return;
1151         }
1152         unp_gcing = TRUE;
1153         spin_unlock_wr(&unp_spin);
1154
1155         /* 
1156          * before going through all this, set all FDs to 
1157          * be NOT defered and NOT externally accessible
1158          */
1159         info.defer = 0;
1160         allfiles_scan_exclusive(unp_gc_clearmarks, NULL);
1161         do {
1162                 allfiles_scan_exclusive(unp_gc_checkmarks, &info);
1163         } while (info.defer);
1164
1165         /*
1166          * We grab an extra reference to each of the file table entries
1167          * that are not otherwise accessible and then free the rights
1168          * that are stored in messages on them.
1169          *
1170          * The bug in the orginal code is a little tricky, so I'll describe
1171          * what's wrong with it here.
1172          *
1173          * It is incorrect to simply unp_discard each entry for f_msgcount
1174          * times -- consider the case of sockets A and B that contain
1175          * references to each other.  On a last close of some other socket,
1176          * we trigger a gc since the number of outstanding rights (unp_rights)
1177          * is non-zero.  If during the sweep phase the gc code un_discards,
1178          * we end up doing a (full) closef on the descriptor.  A closef on A
1179          * results in the following chain.  Closef calls soo_close, which
1180          * calls soclose.   Soclose calls first (through the switch
1181          * uipc_usrreq) unp_detach, which re-invokes unp_gc.  Unp_gc simply
1182          * returns because the previous instance had set unp_gcing, and
1183          * we return all the way back to soclose, which marks the socket
1184          * with SS_NOFDREF, and then calls sofree.  Sofree calls sorflush
1185          * to free up the rights that are queued in messages on the socket A,
1186          * i.e., the reference on B.  The sorflush calls via the dom_dispose
1187          * switch unp_dispose, which unp_scans with unp_discard.  This second
1188          * instance of unp_discard just calls closef on B.
1189          *
1190          * Well, a similar chain occurs on B, resulting in a sorflush on B,
1191          * which results in another closef on A.  Unfortunately, A is already
1192          * being closed, and the descriptor has already been marked with
1193          * SS_NOFDREF, and soclose panics at this point.
1194          *
1195          * Here, we first take an extra reference to each inaccessible
1196          * descriptor.  Then, we call sorflush ourself, since we know
1197          * it is a Unix domain socket anyhow.  After we destroy all the
1198          * rights carried in messages, we do a last closef to get rid
1199          * of our extra reference.  This is the last close, and the
1200          * unp_detach etc will shut down the socket.
1201          *
1202          * 91/09/19, bsy@cs.cmu.edu
1203          */
1204         info.extra_ref = kmalloc(256 * sizeof(struct file *), M_FILE, M_WAITOK);
1205         info.maxindex = 256;
1206
1207         do {
1208                 /*
1209                  * Look for matches
1210                  */
1211                 info.index = 0;
1212                 allfiles_scan_exclusive(unp_gc_checkrefs, &info);
1213
1214                 /* 
1215                  * For each FD on our hit list, do the following two things
1216                  */
1217                 for (i = info.index, fpp = info.extra_ref; --i >= 0; ++fpp) {
1218                         struct file *tfp = *fpp;
1219                         if (tfp->f_type == DTYPE_SOCKET && tfp->f_data != NULL)
1220                                 sorflush((struct socket *)(tfp->f_data));
1221                 }
1222                 for (i = info.index, fpp = info.extra_ref; --i >= 0; ++fpp)
1223                         closef(*fpp, NULL);
1224         } while (info.index == info.maxindex);
1225         kfree((caddr_t)info.extra_ref, M_FILE);
1226         unp_gcing = FALSE;
1227 }
1228
1229 /*
1230  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1231  */
1232 static int
1233 unp_gc_checkrefs(struct file *fp, void *data)
1234 {
1235         struct unp_gc_info *info = data;
1236
1237         if (fp->f_count == 0)
1238                 return(0);
1239         if (info->index == info->maxindex)
1240                 return(-1);
1241
1242         /* 
1243          * If all refs are from msgs, and it's not marked accessible
1244          * then it must be referenced from some unreachable cycle
1245          * of (shut-down) FDs, so include it in our
1246          * list of FDs to remove
1247          */
1248         if (fp->f_count == fp->f_msgcount && !(fp->f_flag & FMARK)) {
1249                 info->extra_ref[info->index++] = fp;
1250                 fhold(fp);
1251         }
1252         return(0);
1253 }
1254
1255 /*
1256  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1257  */
1258 static int
1259 unp_gc_clearmarks(struct file *fp, void *data __unused)
1260 {
1261         fp->f_flag &= ~(FMARK|FDEFER);
1262         return(0);
1263 }
1264
1265 /*
1266  * MPSAFE - NOTE: filehead list and file pointer spinlocked on entry
1267  */
1268 static int
1269 unp_gc_checkmarks(struct file *fp, void *data)
1270 {
1271         struct unp_gc_info *info = data;
1272         struct socket *so;
1273
1274         /*
1275          * If the file is not open, skip it
1276          */
1277         if (fp->f_count == 0)
1278                 return(0);
1279         /*
1280          * If we already marked it as 'defer'  in a
1281          * previous pass, then try process it this time
1282          * and un-mark it
1283          */
1284         if (fp->f_flag & FDEFER) {
1285                 fp->f_flag &= ~FDEFER;
1286                 --info->defer;
1287         } else {
1288                 /*
1289                  * if it's not defered, then check if it's
1290                  * already marked.. if so skip it
1291                  */
1292                 if (fp->f_flag & FMARK)
1293                         return(0);
1294                 /* 
1295                  * If all references are from messages
1296                  * in transit, then skip it. it's not 
1297                  * externally accessible.
1298                  */ 
1299                 if (fp->f_count == fp->f_msgcount)
1300                         return(0);
1301                 /* 
1302                  * If it got this far then it must be
1303                  * externally accessible.
1304                  */
1305                 fp->f_flag |= FMARK;
1306         }
1307         /*
1308          * either it was defered, or it is externally 
1309          * accessible and not already marked so.
1310          * Now check if it is possibly one of OUR sockets.
1311          */ 
1312         if (fp->f_type != DTYPE_SOCKET ||
1313             (so = (struct socket *)fp->f_data) == NULL)
1314                 return(0);
1315         if (so->so_proto->pr_domain != &localdomain ||
1316             !(so->so_proto->pr_flags & PR_RIGHTS))
1317                 return(0);
1318 #ifdef notdef
1319         XXX note: exclusive fp->f_spin lock held
1320         if (so->so_rcv.sb_flags & SB_LOCK) {
1321                 /*
1322                  * This is problematical; it's not clear
1323                  * we need to wait for the sockbuf to be
1324                  * unlocked (on a uniprocessor, at least),
1325                  * and it's also not clear what to do
1326                  * if sbwait returns an error due to receipt
1327                  * of a signal.  If sbwait does return
1328                  * an error, we'll go into an infinite
1329                  * loop.  Delete all of this for now.
1330                  */
1331                 sbwait(&so->so_rcv);
1332                 goto restart;
1333         }
1334 #endif
1335         /*
1336          * So, Ok, it's one of our sockets and it IS externally
1337          * accessible (or was defered). Now we look
1338          * to see if we hold any file descriptors in its
1339          * message buffers. Follow those links and mark them 
1340          * as accessible too.
1341          */
1342         info->locked_fp = fp;
1343 /*      spin_lock_wr(&so->so_rcv.sb_spin); */
1344         unp_scan(so->so_rcv.ssb_mb, unp_mark, info);
1345 /*      spin_unlock_wr(&so->so_rcv.sb_spin);*/
1346         return (0);
1347 }
1348
1349 void
1350 unp_dispose(struct mbuf *m)
1351 {
1352         if (m)
1353                 unp_scan(m, unp_discard, NULL);
1354 }
1355
1356 static int
1357 unp_listen(struct unpcb *unp, struct thread *td)
1358 {
1359         struct proc *p = td->td_proc;
1360
1361         KKASSERT(p);
1362         cru2x(p->p_ucred, &unp->unp_peercred);
1363         unp->unp_flags |= UNP_HAVEPCCACHED;
1364         return (0);
1365 }
1366
1367 static void
1368 unp_scan(struct mbuf *m0, void (*op)(struct file *, void *), void *data)
1369 {
1370         struct mbuf *m;
1371         struct file **rp;
1372         struct cmsghdr *cm;
1373         int i;
1374         int qfds;
1375
1376         while (m0) {
1377                 for (m = m0; m; m = m->m_next) {
1378                         if (m->m_type == MT_CONTROL &&
1379                             m->m_len >= sizeof(*cm)) {
1380                                 cm = mtod(m, struct cmsghdr *);
1381                                 if (cm->cmsg_level != SOL_SOCKET ||
1382                                     cm->cmsg_type != SCM_RIGHTS)
1383                                         continue;
1384                                 qfds = (cm->cmsg_len -
1385                                         (CMSG_DATA(cm) - (u_char *)cm))
1386                                                 / sizeof (struct file *);
1387                                 rp = (struct file **)CMSG_DATA(cm);
1388                                 for (i = 0; i < qfds; i++)
1389                                         (*op)(*rp++, data);
1390                                 break;          /* XXX, but saves time */
1391                         }
1392                 }
1393                 m0 = m0->m_nextpkt;
1394         }
1395 }
1396
1397 static void
1398 unp_mark(struct file *fp, void *data)
1399 {
1400         struct unp_gc_info *info = data;
1401
1402         if (info->locked_fp != fp)
1403                 spin_lock_wr(&fp->f_spin);
1404         if ((fp->f_flag & FMARK) == 0) {
1405                 ++info->defer;
1406                 fp->f_flag |= (FMARK|FDEFER);
1407         }
1408         if (info->locked_fp != fp)
1409                 spin_unlock_wr(&fp->f_spin);
1410 }
1411
1412 static void
1413 unp_discard(struct file *fp, void *data __unused)
1414 {
1415         spin_lock_wr(&unp_spin);
1416         fp->f_msgcount--;
1417         unp_rights--;
1418         spin_unlock_wr(&unp_spin);
1419         closef(fp, NULL);
1420 }
1421