BSD 4_3 release

[unix-history] / usr / src / sys / sys / uipc_usrreq.c

diff --git a/usr/src/sys/sys/uipc_usrreq.c b/usr/src/sys/sys/uipc_usrreq.c
index df87c7c..52b712d 100644 (file)
--- a/usr/src/sys/sys/uipc_usrreq.c
+++ b/usr/src/sys/sys/uipc_usrreq.c
@@ -1,17 +1,24 @@
-/*     uipc_usrreq.c   6.2     83/09/08        */
-
-#include "../h/param.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/mbuf.h"
-#include "../h/protosw.h"
-#include "../h/socket.h"
-#include "../h/socketvar.h"
-#include "../h/unpcb.h"
-#include "../h/un.h"
-#include "../h/inode.h"
-#include "../h/nami.h"
-#include "../h/file.h"
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)uipc_usrreq.c       7.1 (Berkeley) 6/5/86
+ */
+
+#include "param.h"
+#include "dir.h"
+#include "user.h"
+#include "mbuf.h"
+#include "domain.h"
+#include "protosw.h"
+#include "socket.h"
+#include "socketvar.h"
+#include "unpcb.h"
+#include "un.h"
+#include "inode.h"
+#include "file.h"
+#include "stat.h"

 
 /*
  * Unix communications domain.
 
 /*
  * Unix communications domain.


@@ -22,6 +29,7 @@
  *     need a proper out-of-band
  */
 struct sockaddr sun_noname = { AF_UNIX };
  *     need a proper out-of-band
  */
 struct sockaddr sun_noname = { AF_UNIX };

+ino_t  unp_ino;                        /* prototype for fake inode numbers */

 
 /*ARGSUSED*/
 uipc_usrreq(so, req, m, nam, rights)
 
 /*ARGSUSED*/
 uipc_usrreq(so, req, m, nam, rights)


@@ -33,6 +41,8 @@ uipc_usrreq(so, req, m, nam, rights)
        register struct socket *so2;
        int error = 0;
 
        register struct socket *so2;
        int error = 0;
 

+       if (req == PRU_CONTROL)
+               return (EOPNOTSUPP);

        if (req != PRU_SEND && rights && rights->m_len) {
                error = EOPNOTSUPP;
                goto release;
        if (req != PRU_SEND && rights && rights->m_len) {
                error = EOPNOTSUPP;
                goto release;


@@ -69,8 +79,7 @@ uipc_usrreq(so, req, m, nam, rights)
                break;
 
        case PRU_CONNECT2:
                break;
 
        case PRU_CONNECT2:

-               error = unp_connect2(so, (struct mbuf *)0,
-                   (struct socket *)nam);
+               error = unp_connect2(so, (struct socket *)nam);

                break;
 
        case PRU_DISCONNECT:
                break;
 
        case PRU_DISCONNECT:


@@ -78,9 +87,19 @@ uipc_usrreq(so, req, m, nam, rights)
                break;
 
        case PRU_ACCEPT:
                break;
 
        case PRU_ACCEPT:

-               nam->m_len = unp->unp_remaddr->m_len;
-               bcopy(mtod(unp->unp_remaddr, caddr_t),
-                   mtod(nam, caddr_t), (unsigned)nam->m_len);
+               /*
+                * Pass back name of connected socket,
+                * if it was bound and we are still connected
+                * (our peer may have closed already!).
+                */
+               if (unp->unp_conn && unp->unp_conn->unp_addr) {
+                       nam->m_len = unp->unp_conn->unp_addr->m_len;
+                       bcopy(mtod(unp->unp_conn->unp_addr, caddr_t),
+                           mtod(nam, caddr_t), (unsigned)nam->m_len);
+               } else {
+                       nam->m_len = sizeof(sun_noname);
+                       *(mtod(nam, struct sockaddr *)) = sun_noname;
+               }

                break;
 
        case PRU_SHUTDOWN:
                break;
 
        case PRU_SHUTDOWN:


@@ -102,14 +121,14 @@ uipc_usrreq(so, req, m, nam, rights)
                                break;
                        so2 = unp->unp_conn->unp_socket;
                        /*
                                break;
                        so2 = unp->unp_conn->unp_socket;
                        /*

-                        * Transfer resources back to send port
+                        * Adjust backpressure on sender

                         * and wakeup any waiting to write.
                         */
                         * and wakeup any waiting to write.
                         */

-                       snd->sb_mbmax += rcv->sb_mbmax - rcv->sb_mbcnt;
-                       rcv->sb_mbmax = rcv->sb_mbcnt;
-                       snd->sb_hiwat += rcv->sb_hiwat - rcv->sb_cc;
-                       rcv->sb_hiwat = rcv->sb_cc;
-                       sbwakeup(snd);
+                       snd->sb_mbmax += unp->unp_mbcnt - rcv->sb_mbcnt;
+                       unp->unp_mbcnt = rcv->sb_mbcnt;
+                       snd->sb_hiwat += unp->unp_cc - rcv->sb_cc;
+                       unp->unp_cc = rcv->sb_cc;
+                       sowwakeup(so2);

 #undef snd
 #undef rcv
                        break;
 #undef snd
 #undef rcv
                        break;


@@ -120,9 +139,16 @@ uipc_usrreq(so, req, m, nam, rights)
                break;
 
        case PRU_SEND:
                break;
 
        case PRU_SEND:

+               if (rights) {
+                       error = unp_internalize(rights);
+                       if (error)
+                               break;
+               }

                switch (so->so_type) {
 
                switch (so->so_type) {
 

-               case SOCK_DGRAM:
+               case SOCK_DGRAM: {
+                       struct sockaddr *from;
+

                        if (nam) {
                                if (unp->unp_conn) {
                                        error = EISCONN;
                        if (nam) {
                                if (unp->unp_conn) {
                                        error = EISCONN;


@@ -138,48 +164,47 @@ uipc_usrreq(so, req, m, nam, rights)
                                }
                        }
                        so2 = unp->unp_conn->unp_socket;
                                }
                        }
                        so2 = unp->unp_conn->unp_socket;

-                       /* BEGIN XXX */
-                       if (rights) {
-                               error = unp_internalize(rights);
-                               if (error)
-                                       break;
-                       }
-                       if (sbspace(&so2->so_rcv) > 0) {
-                               /*
-                                * There's no record of source socket's
-                                * name, so send null name for the moment.
-                                */
-                               (void) sbappendaddr(&so2->so_rcv,
-                                   &sun_noname, m, rights);
-                               sbwakeup(&so2->so_rcv);
+                       if (unp->unp_addr)
+                               from = mtod(unp->unp_addr, struct sockaddr *);
+                       else
+                               from = &sun_noname;
+                       if (sbspace(&so2->so_rcv) > 0 &&
+                           sbappendaddr(&so2->so_rcv, from, m, rights)) {
+                               sorwakeup(so2);

                                m = 0;
                                m = 0;

-                       }
-                       /* END XXX */
+                       } else
+                               error = ENOBUFS;

                        if (nam)
                                unp_disconnect(unp);
                        break;
                        if (nam)
                                unp_disconnect(unp);
                        break;

+               }

 
                case SOCK_STREAM:
 #define        rcv (&so2->so_rcv)
 #define        snd (&so->so_snd)
 
                case SOCK_STREAM:
 #define        rcv (&so2->so_rcv)
 #define        snd (&so->so_snd)

-                       if (rights && rights->m_len) {
-                               error = EOPNOTSUPP;
+                       if (so->so_state & SS_CANTSENDMORE) {
+                               error = EPIPE;

                                break;
                        }
                        if (unp->unp_conn == 0)
                                panic("uipc 3");
                        so2 = unp->unp_conn->unp_socket;
                        /*
                                break;
                        }
                        if (unp->unp_conn == 0)
                                panic("uipc 3");
                        so2 = unp->unp_conn->unp_socket;
                        /*

-                        * Send to paired receive port, and then
-                        * give it enough resources to hold what it already has.
+                        * Send to paired receive port, and then reduce
+                        * send buffer hiwater marks to maintain backpressure.

                         * Wake up readers.
                         */
                         * Wake up readers.
                         */

-                       sbappend(rcv, m);
-                       snd->sb_mbmax -= rcv->sb_mbcnt - rcv->sb_mbmax;
-                       rcv->sb_mbmax = rcv->sb_mbcnt;
-                       snd->sb_hiwat -= rcv->sb_cc - rcv->sb_hiwat;
-                       rcv->sb_hiwat = rcv->sb_cc;
-                       sbwakeup(rcv);
+                       if (rights)
+                               (void)sbappendrights(rcv, m, rights);
+                       else
+                               sbappend(rcv, m);
+                       snd->sb_mbmax -=
+                           rcv->sb_mbcnt - unp->unp_conn->unp_mbcnt;
+                       unp->unp_conn->unp_mbcnt = rcv->sb_mbcnt;
+                       snd->sb_hiwat -= rcv->sb_cc - unp->unp_conn->unp_cc;
+                       unp->unp_conn->unp_cc = rcv->sb_cc;
+                       sorwakeup(so2);
+                       m = 0;

 #undef snd
 #undef rcv
                        break;
 #undef snd
 #undef rcv
                        break;


@@ -187,32 +212,40 @@ uipc_usrreq(so, req, m, nam, rights)
                default:
                        panic("uipc 4");
                }
                default:
                        panic("uipc 4");
                }

-               m = 0;

                break;
 
        case PRU_ABORT:
                unp_drop(unp, ECONNABORTED);
                break;
 
                break;
 
        case PRU_ABORT:
                unp_drop(unp, ECONNABORTED);
                break;
 

-/* SOME AS YET UNIMPLEMENTED HOOKS */
-       case PRU_CONTROL:
-               return (EOPNOTSUPP);
-

        case PRU_SENSE:
        case PRU_SENSE:

-               error = EOPNOTSUPP;
-               break;
-/* END UNIMPLEMENTED HOOKS */
+               ((struct stat *) m)->st_blksize = so->so_snd.sb_hiwat;
+               if (so->so_type == SOCK_STREAM && unp->unp_conn != 0) {
+                       so2 = unp->unp_conn->unp_socket;
+                       ((struct stat *) m)->st_blksize += so2->so_rcv.sb_cc;
+               }
+               ((struct stat *) m)->st_dev = NODEV;
+               if (unp->unp_ino == 0)
+                       unp->unp_ino = unp_ino++;
+               ((struct stat *) m)->st_ino = unp->unp_ino;
+               return (0);

 
        case PRU_RCVOOB:
 
        case PRU_RCVOOB:

-               break;
+               return (EOPNOTSUPP);

 
        case PRU_SENDOOB:
 
        case PRU_SENDOOB:

+               error = EOPNOTSUPP;

                break;
 
        case PRU_SOCKADDR:
                break;
 
        case PRU_PEERADDR:
                break;
 
        case PRU_SOCKADDR:
                break;
 
        case PRU_PEERADDR:

+               if (unp->unp_conn && unp->unp_conn->unp_addr) {
+                       nam->m_len = unp->unp_conn->unp_addr->m_len;
+                       bcopy(mtod(unp->unp_conn->unp_addr, caddr_t),
+                           mtod(m, caddr_t), (unsigned)m->m_len);
+               }

                break;
 
        case PRU_SLOWTIMO:
                break;
 
        case PRU_SLOWTIMO:


@@ -227,9 +260,21 @@ release:
        return (error);
 }
 
        return (error);
 }
 

-/* SHOULD BE PIPSIZ and 0 */
-int    unp_sendspace = 1024*2;
-int    unp_recvspace = 1024*2;
+/*
+ * Both send and receive buffers are allocated PIPSIZ bytes of buffering
+ * for stream sockets, although the total for sender and receiver is
+ * actually only PIPSIZ.
+ * Datagram sockets really use the sendspace as the maximum datagram size,
+ * and don't really want to reserve the sendspace.  Their recvspace should
+ * be large enough for at least one max-size datagram plus address.
+ */
+#define        PIPSIZ  4096
+int    unpst_sendspace = PIPSIZ;
+int    unpst_recvspace = PIPSIZ;
+int    unpdg_sendspace = 2*1024;       /* really max datagram size */
+int    unpdg_recvspace = 4*1024;
+
+int    unp_rights;                     /* file descriptors in flight */

 
 unp_attach(so)
        struct socket *so;
 
 unp_attach(so)
        struct socket *so;


@@ -238,7 +283,16 @@ unp_attach(so)
        register struct unpcb *unp;
        int error;
        
        register struct unpcb *unp;
        int error;
        

-       error = soreserve(so, unp_sendspace, unp_recvspace);
+       switch (so->so_type) {
+
+       case SOCK_STREAM:
+               error = soreserve(so, unpst_sendspace, unpst_recvspace);
+               break;
+
+       case SOCK_DGRAM:
+               error = soreserve(so, unpdg_sendspace, unpdg_recvspace);
+               break;
+       }

        if (error)
                return (error);
        m = m_getclr(M_DONTWAIT, MT_PCB);
        if (error)
                return (error);
        m = m_getclr(M_DONTWAIT, MT_PCB);


@@ -255,6 +309,7 @@ unp_detach(unp)
 {
        
        if (unp->unp_inode) {
 {
        
        if (unp->unp_inode) {

+               unp->unp_inode->i_socket = 0;

                irele(unp->unp_inode);
                unp->unp_inode = 0;
        }
                irele(unp->unp_inode);
                unp->unp_inode = 0;
        }


@@ -264,8 +319,10 @@ unp_detach(unp)
                unp_drop(unp->unp_refs, ECONNRESET);
        soisdisconnected(unp->unp_socket);
        unp->unp_socket->so_pcb = 0;
                unp_drop(unp->unp_refs, ECONNRESET);
        soisdisconnected(unp->unp_socket);
        unp->unp_socket->so_pcb = 0;

-       m_freem(unp->unp_remaddr);
+       m_freem(unp->unp_addr);

        (void) m_free(dtom(unp));
        (void) m_free(dtom(unp));

+       if (unp_rights)
+               unp_gc();

 }
 
 unp_bind(unp, nam)
 }
 
 unp_bind(unp, nam)


@@ -274,15 +331,17 @@ unp_bind(unp, nam)
 {
        struct sockaddr_un *soun = mtod(nam, struct sockaddr_un *);
        register struct inode *ip;
 {
        struct sockaddr_un *soun = mtod(nam, struct sockaddr_un *);
        register struct inode *ip;

-       extern schar();
+       register struct nameidata *ndp = &u.u_nd;

        int error;
 
        int error;
 

-       u.u_dirp = soun->sun_path;
-       if (nam->m_len == MLEN)
+       ndp->ni_dirp = soun->sun_path;
+       if (unp->unp_inode != NULL || nam->m_len == MLEN)

                return (EINVAL);
        *(mtod(nam, caddr_t) + nam->m_len) = 0;
 /* SHOULD BE ABLE TO ADOPT EXISTING AND wakeup() ALA FIFO's */
                return (EINVAL);
        *(mtod(nam, caddr_t) + nam->m_len) = 0;
 /* SHOULD BE ABLE TO ADOPT EXISTING AND wakeup() ALA FIFO's */

-       ip = namei(schar, CREATE, 1);
+       ndp->ni_nameiop = CREATE | FOLLOW;
+       ndp->ni_segflg = UIO_SYSSPACE;
+       ip = namei(ndp);

        if (ip) {
                iput(ip);
                return (EADDRINUSE);
        if (ip) {
                iput(ip);
                return (EADDRINUSE);


@@ -291,7 +350,7 @@ unp_bind(unp, nam)
                u.u_error = 0;                  /* XXX */
                return (error);
        }
                u.u_error = 0;                  /* XXX */
                return (error);
        }

-       ip = maknode(IFSOCK | 0777);
+       ip = maknode(IFSOCK | 0777, ndp);

        if (ip == NULL) {
                error = u.u_error;              /* XXX */
                u.u_error = 0;                  /* XXX */
        if (ip == NULL) {
                error = u.u_error;              /* XXX */
                u.u_error = 0;                  /* XXX */


@@ -299,6 +358,7 @@ unp_bind(unp, nam)
        }
        ip->i_socket = unp->unp_socket;
        unp->unp_inode = ip;
        }
        ip->i_socket = unp->unp_socket;
        unp->unp_inode = ip;

+       unp->unp_addr = m_copy(nam, 0, (int)M_COPYALL);

        iunlock(ip);                    /* but keep reference */
        return (0);
 }
        iunlock(ip);                    /* but keep reference */
        return (0);
 }


@@ -311,17 +371,25 @@ unp_connect(so, nam)
        register struct inode *ip;
        int error;
        register struct socket *so2;
        register struct inode *ip;
        int error;
        register struct socket *so2;

+       register struct nameidata *ndp = &u.u_nd;

 
 

-       u.u_dirp = soun->sun_path;
+       ndp->ni_dirp = soun->sun_path;

        if (nam->m_len + (nam->m_off - MMINOFF) == MLEN)
                return (EMSGSIZE);
        *(mtod(nam, caddr_t) + nam->m_len) = 0;
        if (nam->m_len + (nam->m_off - MMINOFF) == MLEN)
                return (EMSGSIZE);
        *(mtod(nam, caddr_t) + nam->m_len) = 0;

-       ip = namei(schar, LOOKUP, 1);
+       ndp->ni_nameiop = LOOKUP | FOLLOW;
+       ndp->ni_segflg = UIO_SYSSPACE;
+       ip = namei(ndp);

        if (ip == 0) {
                error = u.u_error;
                u.u_error = 0;
                return (error);         /* XXX */
        }
        if (ip == 0) {
                error = u.u_error;
                u.u_error = 0;
                return (error);         /* XXX */
        }

+       if (access(ip, IWRITE)) {
+               error = u.u_error;
+               u.u_error = 0;          /* XXX */
+               goto bad;
+       }

        if ((ip->i_mode&IFMT) != IFSOCK) {
                error = ENOTSOCK;
                goto bad;
        if ((ip->i_mode&IFMT) != IFSOCK) {
                error = ENOTSOCK;
                goto bad;


@@ -341,15 +409,14 @@ unp_connect(so, nam)
                error = ECONNREFUSED;
                goto bad;
        }
                error = ECONNREFUSED;
                goto bad;
        }

-       error = unp_connect2(so, nam, so2);
+       error = unp_connect2(so, so2);

 bad:
        iput(ip);
        return (error);
 }
 
 bad:
        iput(ip);
        return (error);
 }
 

-unp_connect2(so, sonam, so2)
+unp_connect2(so, so2)

        register struct socket *so;
        register struct socket *so;

-       struct mbuf *sonam;

        register struct socket *so2;
 {
        register struct unpcb *unp = sotounpcb(so);
        register struct socket *so2;
 {
        register struct unpcb *unp = sotounpcb(so);


@@ -364,12 +431,11 @@ unp_connect2(so, sonam, so2)
        case SOCK_DGRAM:
                unp->unp_nextref = unp2->unp_refs;
                unp2->unp_refs = unp;
        case SOCK_DGRAM:
                unp->unp_nextref = unp2->unp_refs;
                unp2->unp_refs = unp;

+               soisconnected(so);

                break;
 
        case SOCK_STREAM:
                unp2->unp_conn = unp;
                break;
 
        case SOCK_STREAM:
                unp2->unp_conn = unp;

-               if (sonam)
-                       unp2->unp_remaddr = m_copy(sonam, 0, (int)M_COPYALL);

                soisconnected(so2);
                soisconnected(so);
                break;
                soisconnected(so2);
                soisconnected(so);
                break;


@@ -405,6 +471,7 @@ unp_disconnect(unp)
                        unp2->unp_nextref = unp->unp_nextref;
                }
                unp->unp_nextref = 0;
                        unp2->unp_nextref = unp->unp_nextref;
                }
                unp->unp_nextref = 0;

+               unp->unp_socket->so_state &= ~SS_ISCONNECTED;

                break;
 
        case SOCK_STREAM:
                break;
 
        case SOCK_STREAM:


@@ -435,9 +502,16 @@ unp_drop(unp, errno)
        struct unpcb *unp;
        int errno;
 {
        struct unpcb *unp;
        int errno;
 {

+       struct socket *so = unp->unp_socket;

 
 

-       unp->unp_socket->so_error = errno;
+       so->so_error = errno;

        unp_disconnect(unp);
        unp_disconnect(unp);

+       if (so->so_head) {
+               so->so_pcb = (caddr_t) 0;
+               m_freem(unp->unp_addr);
+               (void) m_free(dtom(unp));
+               sofree(so);
+       }

 }
 
 #ifdef notdef
 }
 
 #ifdef notdef


@@ -471,6 +545,7 @@ unp_externalize(rights)
                fp = *rp;
                u.u_ofile[f] = fp;
                fp->f_msgcount--;
                fp = *rp;
                u.u_ofile[f] = fp;
                fp->f_msgcount--;

+               unp_rights--;

                *(int *)rp++ = f;
        }
        return (0);
                *(int *)rp++ = f;
        }
        return (0);


@@ -494,12 +569,14 @@ unp_internalize(rights)
                *rp++ = fp;
                fp->f_count++;
                fp->f_msgcount++;
                *rp++ = fp;
                fp->f_count++;
                fp->f_msgcount++;

+               unp_rights++;

        }
        return (0);
 }
 
 int    unp_defer, unp_gcing;
 int    unp_mark();
        }
        return (0);
 }
 
 int    unp_defer, unp_gcing;
 int    unp_mark();

+extern struct domain unixdomain;

 
 unp_gc()
 {
 
 unp_gc()
 {


@@ -530,8 +607,8 @@ restart:
                        if (fp->f_type != DTYPE_SOCKET)
                                continue;
                        so = (struct socket *)fp->f_data;
                        if (fp->f_type != DTYPE_SOCKET)
                                continue;
                        so = (struct socket *)fp->f_data;

-                       if (so->so_proto->pr_family != AF_UNIX ||
-                           (so->so_proto->pr_flags&PR_ADDR) == 0)
+                       if (so->so_proto->pr_domain != &unixdomain ||
+                           (so->so_proto->pr_flags&PR_RIGHTS) == 0)

                                continue;
                        if (so->so_rcv.sb_flags & SB_LOCK) {
                                sbwait(&so->so_rcv);
                                continue;
                        if (so->so_rcv.sb_flags & SB_LOCK) {
                                sbwait(&so->so_rcv);


@@ -543,43 +620,42 @@ restart:
        for (fp = file; fp < fileNFILE; fp++) {
                if (fp->f_count == 0)
                        continue;
        for (fp = file; fp < fileNFILE; fp++) {
                if (fp->f_count == 0)
                        continue;

-               if (fp->f_count == fp->f_msgcount && (fp->f_flag&FMARK)==0) {
-                       if (fp->f_type != DTYPE_SOCKET)
-                               panic("unp_gc");
-                       (void) soshutdown((struct socket *)fp->f_data, 0);
-               }
+               if (fp->f_count == fp->f_msgcount && (fp->f_flag & FMARK) == 0)
+                       while (fp->f_msgcount)
+                               unp_discard(fp);

        }
        unp_gcing = 0;
 }
 
        }
        unp_gcing = 0;
 }
 

-unp_scan(m, op)
-       register struct mbuf *m;
+unp_dispose(m)
+       struct mbuf *m;
+{
+       int unp_discard();
+
+       if (m)
+               unp_scan(m, unp_discard);
+}
+
+unp_scan(m0, op)
+       register struct mbuf *m0;

        int (*op)();
 {
        int (*op)();
 {

+       register struct mbuf *m;

        register struct file **rp;
        register int i;
        int qfds;
 
        register struct file **rp;
        register int i;
        int qfds;
 

-       while (m) {
-               m = m->m_next;
-               if (m == 0)
-                       goto bad;
-               if (m->m_len) {
-                       qfds = m->m_len / sizeof (struct file *);
-                       rp = mtod(m, struct file **);
-                       for (i = 0; i < qfds; i++)
-                               (*op)(*rp++);
-               }
-               do {
-                       m = m->m_next;
-                       if (m == 0)
-                               goto bad;
-               } while (m->m_act == 0);
-               m = m->m_next;
+       while (m0) {
+               for (m = m0; m; m = m->m_next)
+                       if (m->m_type == MT_RIGHTS && m->m_len) {
+                               qfds = m->m_len / sizeof (struct file *);
+                               rp = mtod(m, struct file **);
+                               for (i = 0; i < qfds; i++)
+                                       (*op)(*rp++);
+                               break;          /* XXX, but saves time */
+                       }
+               m0 = m0->m_act;

        }
        }

-       return;
-bad:
-       panic("unp_gcscan");

 }
 
 unp_mark(fp)
 }
 
 unp_mark(fp)


@@ -597,5 +673,6 @@ unp_discard(fp)
 {
 
        fp->f_msgcount--;
 {
 
        fp->f_msgcount--;

+       unp_rights--;

        closef(fp);
 }
        closef(fp);
 }