Changeset 3489e3b in rtems-libbsd for freebsd/sys/kern/uipc_syscalls.c


Ignore:
Timestamp:
Aug 22, 2018, 12:59:50 PM (2 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
b96abfd647154f10ea8f7fac68e25676636eded5, debc0aed8b9bef9996b8ec0ae7a70b0b41912e27, 0ad342ae5f65d22eb6c914d58664d3b5d1d3d43f, 98d197895b6162050176ea18d66783a1dc216d82
Children:
1af372a
Parents:
3becda1
git-author:
Sebastian Huber <sebastian.huber@…> (08/22/18 12:59:50)
git-committer:
Sebastian Huber <sebastian.huber@…> (09/21/18 08:29:41)
Message:

Update to FreeBSD head 2018-09-17

Git mirror commit 6c2192b1ef8c50788c751f878552526800b1e319.

Update #3472.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • freebsd/sys/kern/uipc_syscalls.c

    r3becda1 r3489e3b  
    6161#include <sys/syscallsubr.h>
    6262#include <sys/uio.h>
     63#include <sys/un.h>
     64#include <sys/unpcb.h>
    6365#ifdef KTRACE
    6466#include <sys/ktrace.h>
     
    832834                 if (error != 0)
    833835                        goto free4;
     836        } else if (so1->so_proto->pr_flags & PR_CONNREQUIRED) {
     837                struct unpcb *unp, *unp2;
     838                unp = sotounpcb(so1);
     839                unp2 = sotounpcb(so2);
     840                /*
     841                 * No need to lock the unps, because the sockets are brand-new.
     842                 * No other threads can be using them yet
     843                 */
     844                unp_copy_peercred(td, unp, unp2, unp);
    834845        }
    835846        finit(fp1, FREAD | FWRITE | fflag, DTYPE_SOCKET, fp1->f_data,
     
    12611272        struct uio auio;
    12621273        struct iovec *iov;
    1263         struct mbuf *m, *control = NULL;
     1274        struct mbuf *control, *m;
    12641275        caddr_t ctlbuf;
    12651276        struct file *fp;
     
    13081319                ktruio = cloneuio(&auio);
    13091320#endif
     1321        control = NULL;
    13101322        len = auio.uio_resid;
    13111323        error = soreceive(so, &fromsa, &auio, NULL,
     
    13711383                }
    13721384#endif
     1385                ctlbuf = mp->msg_control;
    13731386                len = mp->msg_controllen;
    1374                 m = control;
    13751387                mp->msg_controllen = 0;
    1376                 ctlbuf = mp->msg_control;
    1377 
    1378                 while (m && len > 0) {
    1379                         unsigned int tocopy;
    1380 
    1381                         if (len >= m->m_len)
    1382                                 tocopy = m->m_len;
    1383                         else {
    1384                                 mp->msg_flags |= MSG_CTRUNC;
    1385                                 tocopy = len;
    1386                         }
    1387 
    1388                         if ((error = copyout(mtod(m, caddr_t),
    1389                                         ctlbuf, tocopy)) != 0)
     1388                for (m = control; m != NULL && len >= m->m_len; m = m->m_next) {
     1389                        if ((error = copyout(mtod(m, caddr_t), ctlbuf,
     1390                            m->m_len)) != 0)
    13901391                                goto out;
    13911392
    1392                         ctlbuf += tocopy;
    1393                         len -= tocopy;
    1394                         m = m->m_next;
     1393                        ctlbuf += m->m_len;
     1394                        len -= m->m_len;
     1395                        mp->msg_controllen += m->m_len;
    13951396                }
    1396                 mp->msg_controllen = ctlbuf - (caddr_t)mp->msg_control;
     1397                if (m != NULL) {
     1398                        mp->msg_flags |= MSG_CTRUNC;
     1399                        m_dispose_extcontrolm(m);
     1400                }
    13971401        }
    13981402out:
     
    14061410        if (error == 0 && controlp != NULL)
    14071411                *controlp = control;
    1408         else  if (control)
     1412        else if (control != NULL) {
     1413                if (error != 0)
     1414                        m_dispose_extcontrolm(control);
    14091415                m_freem(control);
     1416        }
    14101417
    14111418        return (error);
     
    21352142#endif /* __rtems__ */
    21362143}
     2144
     2145/*
     2146 * Dispose of externalized rights from an SCM_RIGHTS message.  This function
     2147 * should be used in error or truncation cases to avoid leaking file descriptors
     2148 * into the recipient's (the current thread's) table.
     2149 */
     2150void
     2151m_dispose_extcontrolm(struct mbuf *m)
     2152{
     2153        struct cmsghdr *cm;
     2154        struct file *fp;
     2155        struct thread *td;
     2156        socklen_t clen, datalen;
     2157        int error, fd, *fds, nfd;
     2158
     2159        td = curthread;
     2160        for (; m != NULL; m = m->m_next) {
     2161                if (m->m_type != MT_EXTCONTROL)
     2162                        continue;
     2163                cm = mtod(m, struct cmsghdr *);
     2164                clen = m->m_len;
     2165                while (clen > 0) {
     2166                        if (clen < sizeof(*cm))
     2167                                panic("%s: truncated mbuf %p", __func__, m);
     2168                        datalen = CMSG_SPACE(cm->cmsg_len - CMSG_SPACE(0));
     2169                        if (clen < datalen)
     2170                                panic("%s: truncated mbuf %p", __func__, m);
     2171
     2172                        if (cm->cmsg_level == SOL_SOCKET &&
     2173                            cm->cmsg_type == SCM_RIGHTS) {
     2174                                fds = (int *)CMSG_DATA(cm);
     2175                                nfd = (cm->cmsg_len - CMSG_SPACE(0)) /
     2176                                    sizeof(int);
     2177
     2178                                while (nfd-- > 0) {
     2179                                        fd = *fds++;
     2180                                        error = fget(td, fd, &cap_no_rights,
     2181                                            &fp);
     2182                                        if (error == 0)
     2183                                                fdclose(td, fp, fd);
     2184                                }
     2185                        }
     2186                        clen -= datalen;
     2187                        cm = (struct cmsghdr *)((uint8_t *)cm + datalen);
     2188                }
     2189                m_chtype(m, MT_CONTROL);
     2190        }
     2191}
Note: See TracChangeset for help on using the changeset viewer.