#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/domain.h>
#include <sys/fcntl.h>
#include <sys/malloc.h>
#include <sys/file_internal.h>
#include <sys/filedesc.h>
#include <sys/lock.h>
#include <sys/mbuf.h>
#include <sys/namei.h>
#include <sys/proc_internal.h>
#include <sys/kauth.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/un.h>
#include <sys/unpcb.h>
#include <sys/vnode_internal.h>
#include <sys/kdebug.h>
#include <kern/zalloc.h>
#include <kern/locks.h>
#if CONFIG_MACF
#include <security/mac_framework.h>
#endif
#include <mach/vm_param.h>
#define f_msgcount f_fglob->fg_msgcount
#define f_cred f_fglob->fg_cred
#define f_ops f_fglob->fg_ops
#define f_offset f_fglob->fg_offset
#define f_data f_fglob->fg_data
struct zone *unp_zone;
static unp_gen_t unp_gencnt;
static u_int unp_count;
static lck_attr_t *unp_mtx_attr;
static lck_grp_t *unp_mtx_grp;
static lck_grp_attr_t *unp_mtx_grp_attr;
static lck_rw_t *unp_list_mtx;
static lck_mtx_t *unp_disconnect_lock;
static lck_mtx_t *unp_connect_lock;
static u_int disconnect_in_progress;
extern lck_mtx_t *uipc_lock;
static struct unp_head unp_shead, unp_dhead;
#define MDNSRESPONDER_PATH "/var/run/mDNSResponder"
static int unpst_tracemdns;
#define MDNS_IPC_MSG_HDR_VERSION_1 1
struct mdns_ipc_msg_hdr {
uint32_t version;
uint32_t datalen;
uint32_t ipc_flags;
uint32_t op;
union {
void *context;
uint32_t u32[2];
} __attribute__((packed));
uint32_t reg_index;
} __attribute__((packed));
static struct sockaddr sun_noname = { sizeof (sun_noname), AF_LOCAL, { 0 } };
static ino_t unp_ino;
static int unp_attach(struct socket *);
static void unp_detach(struct unpcb *);
static int unp_bind(struct unpcb *, struct sockaddr *, proc_t);
static int unp_connect(struct socket *, struct sockaddr *, proc_t);
static void unp_disconnect(struct unpcb *);
static void unp_shutdown(struct unpcb *);
static void unp_drop(struct unpcb *, int);
__private_extern__ void unp_gc(void);
static void unp_scan(struct mbuf *, void (*)(struct fileglob *));
static void unp_mark(struct fileglob *);
static void unp_discard(struct fileglob *);
static void unp_discard_fdlocked(struct fileglob *, proc_t);
static int unp_internalize(struct mbuf *, proc_t);
static int unp_listen(struct unpcb *, proc_t);
static void unpcb_to_compat(struct unpcb *, struct unpcb_compat *);
static void unp_get_locks_in_order(struct socket *so, struct socket *conn_so);
static void
unp_get_locks_in_order(struct socket *so, struct socket *conn_so)
{
if (so < conn_so) {
socket_lock(conn_so, 1);
} else {
struct unpcb *unp = sotounpcb(so);
unp->unp_flags |= UNP_DONTDISCONNECT;
unp->rw_thrcount++;
socket_unlock(so, 0);
socket_lock(conn_so, 1);
socket_lock(so, 0);
unp->rw_thrcount--;
if (unp->rw_thrcount == 0) {
unp->unp_flags &= ~UNP_DONTDISCONNECT;
wakeup(unp);
}
}
}
static int
uipc_abort(struct socket *so)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
unp_drop(unp, ECONNABORTED);
unp_detach(unp);
sofree(so);
return (0);
}
static int
uipc_accept(struct socket *so, struct sockaddr **nam)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
if (unp->unp_conn && unp->unp_conn->unp_addr) {
*nam = dup_sockaddr((struct sockaddr *)
unp->unp_conn->unp_addr, 1);
} else {
*nam = dup_sockaddr((struct sockaddr *)&sun_noname, 1);
}
return (0);
}
static int
uipc_attach(struct socket *so, __unused int proto, __unused proc_t p)
{
struct unpcb *unp = sotounpcb(so);
if (unp != 0)
return (EISCONN);
return (unp_attach(so));
}
static int
uipc_bind(struct socket *so, struct sockaddr *nam, proc_t p)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
return (unp_bind(unp, nam, p));
}
static int
uipc_connect(struct socket *so, struct sockaddr *nam, proc_t p)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
return (unp_connect(so, nam, p));
}
static int
uipc_connect2(struct socket *so1, struct socket *so2)
{
struct unpcb *unp = sotounpcb(so1);
if (unp == 0)
return (EINVAL);
return (unp_connect2(so1, so2));
}
static int
uipc_detach(struct socket *so)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
lck_mtx_assert(&unp->unp_mtx, LCK_MTX_ASSERT_OWNED);
unp_detach(unp);
return (0);
}
static int
uipc_disconnect(struct socket *so)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
unp_disconnect(unp);
return (0);
}
static int
uipc_listen(struct socket *so, __unused proc_t p)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0 || unp->unp_vnode == 0)
return (EINVAL);
return (unp_listen(unp, p));
}
static int
uipc_peeraddr(struct socket *so, struct sockaddr **nam)
{
struct unpcb *unp = sotounpcb(so);
if (unp == NULL)
return (EINVAL);
if (unp->unp_conn != NULL && unp->unp_conn->unp_addr != NULL) {
*nam = dup_sockaddr((struct sockaddr *)
unp->unp_conn->unp_addr, 1);
} else {
*nam = dup_sockaddr((struct sockaddr *)&sun_noname, 1);
}
return (0);
}
static int
uipc_rcvd(struct socket *so, __unused int flags)
{
struct unpcb *unp = sotounpcb(so);
struct socket *so2;
if (unp == 0)
return (EINVAL);
switch (so->so_type) {
case SOCK_DGRAM:
panic("uipc_rcvd DGRAM?");
case SOCK_STREAM:
#define rcv (&so->so_rcv)
#define snd (&so2->so_snd)
if (unp->unp_conn == 0)
break;
so2 = unp->unp_conn->unp_socket;
unp_get_locks_in_order(so, so2);
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);
socket_unlock(so2, 1);
#undef snd
#undef rcv
break;
default:
panic("uipc_rcvd unknown socktype");
}
return (0);
}
static int
uipc_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam,
struct mbuf *control, proc_t p)
{
int error = 0;
struct unpcb *unp = sotounpcb(so);
struct socket *so2;
if (unp == 0) {
error = EINVAL;
goto release;
}
if (flags & PRUS_OOB) {
error = EOPNOTSUPP;
goto release;
}
if (control) {
socket_unlock(so, 0);
error = unp_internalize(control, p);
socket_lock(so, 0);
if (error)
goto release;
}
switch (so->so_type) {
case SOCK_DGRAM:
{
struct sockaddr *from;
if (nam) {
if (unp->unp_conn) {
error = EISCONN;
break;
}
error = unp_connect(so, nam, p);
if (error)
break;
} else {
if (unp->unp_conn == 0) {
error = ENOTCONN;
break;
}
}
so2 = unp->unp_conn->unp_socket;
if (so != so2)
unp_get_locks_in_order(so, so2);
if (unp->unp_addr)
from = (struct sockaddr *)unp->unp_addr;
else
from = &sun_noname;
if (sbappendaddr(&so2->so_rcv, from, m, control, &error)) {
control = NULL;
sorwakeup(so2);
} else if (control != NULL && error == 0) {
control = NULL;
}
if (so != so2)
socket_unlock(so2, 1);
m = NULL;
if (nam)
unp_disconnect(unp);
break;
}
case SOCK_STREAM: {
int didreceive = 0;
#define rcv (&so2->so_rcv)
#define snd (&so->so_snd)
if ((so->so_state & SS_ISCONNECTED) == 0) {
if (nam) {
error = unp_connect(so, nam, p);
if (error)
break;
} else {
error = ENOTCONN;
break;
}
}
if (so->so_state & SS_CANTSENDMORE) {
error = EPIPE;
break;
}
if (unp->unp_conn == 0)
panic("uipc_send connected but no connection?");
so2 = unp->unp_conn->unp_socket;
unp_get_locks_in_order(so, so2);
if ((so->so_state & SS_CANTSENDMORE)) {
error = EPIPE;
socket_unlock(so2, 1);
break;
}
if (unp->unp_flags & UNP_TRACE_MDNS) {
struct mdns_ipc_msg_hdr hdr;
if (mbuf_copydata(m, 0, sizeof (hdr), &hdr) == 0 &&
hdr.version == ntohl(MDNS_IPC_MSG_HDR_VERSION_1)) {
printf("%s[mDNSResponder] pid=%d (%s): op=0x%x\n",
__func__, p->p_pid, p->p_comm, ntohl(hdr.op));
}
}
didreceive = control ?
sbappendcontrol(rcv, m, control, &error) : 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;
if (didreceive) {
control = NULL;
sorwakeup(so2);
} else if (control != NULL && error == 0) {
control = NULL;
}
socket_unlock(so2, 1);
m = NULL;
#undef snd
#undef rcv
}
break;
default:
panic("uipc_send unknown socktype");
}
if (flags & PRUS_EOF) {
socantsendmore(so);
unp_shutdown(unp);
}
if (control && error != 0) {
socket_unlock(so, 0);
unp_dispose(control);
socket_lock(so, 0);
}
release:
if (control)
m_freem(control);
if (m)
m_freem(m);
return (error);
}
static int
uipc_sense(struct socket *so, void *ub, int isstat64)
{
struct unpcb *unp = sotounpcb(so);
struct socket *so2;
blksize_t blksize;
if (unp == 0)
return (EINVAL);
blksize = so->so_snd.sb_hiwat;
if (so->so_type == SOCK_STREAM && unp->unp_conn != 0) {
so2 = unp->unp_conn->unp_socket;
blksize += so2->so_rcv.sb_cc;
}
if (unp->unp_ino == 0)
unp->unp_ino = unp_ino++;
if (isstat64 != 0) {
struct stat64 *sb64;
sb64 = (struct stat64 *)ub;
sb64->st_blksize = blksize;
sb64->st_dev = NODEV;
sb64->st_ino = (ino64_t)unp->unp_ino;
} else {
struct stat *sb;
sb = (struct stat *)ub;
sb->st_blksize = blksize;
sb->st_dev = NODEV;
sb->st_ino = (ino_t)(uintptr_t)unp->unp_ino;
}
return (0);
}
static int
uipc_shutdown(struct socket *so)
{
struct unpcb *unp = sotounpcb(so);
if (unp == 0)
return (EINVAL);
socantsendmore(so);
unp_shutdown(unp);
return (0);
}
static int
uipc_sockaddr(struct socket *so, struct sockaddr **nam)
{
struct unpcb *unp = sotounpcb(so);
if (unp == NULL)
return (EINVAL);
if (unp->unp_addr != NULL) {
*nam = dup_sockaddr((struct sockaddr *)unp->unp_addr, 1);
} else {
*nam = dup_sockaddr((struct sockaddr *)&sun_noname, 1);
}
return (0);
}
struct pr_usrreqs uipc_usrreqs = {
uipc_abort, uipc_accept, uipc_attach, uipc_bind, uipc_connect,
uipc_connect2, pru_control_notsupp, uipc_detach, uipc_disconnect,
uipc_listen, uipc_peeraddr, uipc_rcvd, pru_rcvoob_notsupp,
uipc_send, uipc_sense, uipc_shutdown, uipc_sockaddr,
sosend, soreceive, pru_sopoll_notsupp
};
int
uipc_ctloutput(struct socket *so, struct sockopt *sopt)
{
struct unpcb *unp = sotounpcb(so);
int error;
switch (sopt->sopt_dir) {
case SOPT_GET:
switch (sopt->sopt_name) {
case LOCAL_PEERCRED:
if (unp->unp_flags & UNP_HAVEPC) {
error = sooptcopyout(sopt, &unp->unp_peercred,
sizeof (unp->unp_peercred));
} else {
if (so->so_type == SOCK_STREAM)
error = ENOTCONN;
else
error = EINVAL;
}
break;
case LOCAL_PEERPID:
if (unp->unp_conn != NULL) {
if (unp->unp_conn->unp_socket != NULL) {
pid_t peerpid = unp->unp_conn->unp_socket->last_pid;
error = sooptcopyout(sopt, &peerpid, sizeof (peerpid));
} else {
panic("peer is connected but has no socket?");
}
} else {
error = ENOTCONN;
}
break;
default:
error = EOPNOTSUPP;
break;
}
break;
case SOPT_SET:
default:
error = EOPNOTSUPP;
break;
}
return (error);
}
#ifndef PIPSIZ
#define PIPSIZ 8192
#endif
static u_int32_t unpst_sendspace = PIPSIZ;
static u_int32_t unpst_recvspace = PIPSIZ;
static u_int32_t unpdg_sendspace = 2*1024;
static u_int32_t unpdg_recvspace = 4*1024;
static int unp_rights;
static int unp_disposed;
SYSCTL_DECL(_net_local_stream);
SYSCTL_INT(_net_local_stream, OID_AUTO, sendspace, CTLFLAG_RW | CTLFLAG_LOCKED,
&unpst_sendspace, 0, "");
SYSCTL_INT(_net_local_stream, OID_AUTO, recvspace, CTLFLAG_RW | CTLFLAG_LOCKED,
&unpst_recvspace, 0, "");
SYSCTL_INT(_net_local_stream, OID_AUTO, tracemdns, CTLFLAG_RW | CTLFLAG_LOCKED,
&unpst_tracemdns, 0, "");
SYSCTL_DECL(_net_local_dgram);
SYSCTL_INT(_net_local_dgram, OID_AUTO, maxdgram, CTLFLAG_RW | CTLFLAG_LOCKED,
&unpdg_sendspace, 0, "");
SYSCTL_INT(_net_local_dgram, OID_AUTO, recvspace, CTLFLAG_RW | CTLFLAG_LOCKED,
&unpdg_recvspace, 0, "");
SYSCTL_DECL(_net_local);
SYSCTL_INT(_net_local, OID_AUTO, inflight, CTLFLAG_RD | CTLFLAG_LOCKED, &unp_rights, 0, "");
static int
unp_attach(struct socket *so)
{
struct unpcb *unp;
int error = 0;
if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
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;
default:
panic("unp_attach");
}
if (error)
return (error);
}
unp = (struct unpcb *)zalloc(unp_zone);
if (unp == NULL)
return (ENOBUFS);
bzero(unp, sizeof (*unp));
lck_mtx_init(&unp->unp_mtx,
unp_mtx_grp, unp_mtx_attr);
lck_rw_lock_exclusive(unp_list_mtx);
LIST_INIT(&unp->unp_refs);
unp->unp_socket = so;
unp->unp_gencnt = ++unp_gencnt;
unp_count++;
LIST_INSERT_HEAD(so->so_type == SOCK_DGRAM ?
&unp_dhead : &unp_shead, unp, unp_link);
lck_rw_done(unp_list_mtx);
so->so_pcb = (caddr_t)unp;
so->so_rcv.sb_flags |= SB_UNIX;
so->so_snd.sb_flags |= SB_UNIX;
return (0);
}
static void
unp_detach(struct unpcb *unp)
{
int so_locked = 1;
lck_rw_lock_exclusive(unp_list_mtx);
LIST_REMOVE(unp, unp_link);
--unp_count;
++unp_gencnt;
lck_rw_done(unp_list_mtx);
if (unp->unp_vnode) {
struct vnode *tvp = NULL;
socket_unlock(unp->unp_socket, 0);
lck_mtx_lock(unp_connect_lock);
socket_lock(unp->unp_socket, 0);
if (unp->unp_vnode) {
tvp = unp->unp_vnode;
unp->unp_vnode->v_socket = NULL;
unp->unp_vnode = NULL;
}
lck_mtx_unlock(unp_connect_lock);
if (tvp != NULL)
vnode_rele(tvp);
}
if (unp->unp_conn)
unp_disconnect(unp);
while (unp->unp_refs.lh_first) {
struct unpcb *unp2 = NULL;
if (so_locked == 1) {
socket_unlock(unp->unp_socket, 0);
so_locked = 0;
}
lck_mtx_lock(unp_disconnect_lock);
while (disconnect_in_progress != 0) {
(void)msleep((caddr_t)&disconnect_in_progress, unp_disconnect_lock,
PSOCK, "disconnect", NULL);
}
disconnect_in_progress = 1;
lck_mtx_unlock(unp_disconnect_lock);
if (unp->unp_refs.lh_first != NULL) {
unp2 = unp->unp_refs.lh_first;
socket_lock(unp2->unp_socket, 1);
}
lck_mtx_lock(unp_disconnect_lock);
disconnect_in_progress = 0;
wakeup(&disconnect_in_progress);
lck_mtx_unlock(unp_disconnect_lock);
if (unp2 != NULL) {
unp_drop(unp2, ECONNRESET);
socket_unlock(unp2->unp_socket, 1);
}
}
if (so_locked == 0) {
socket_lock(unp->unp_socket, 0);
so_locked = 1;
}
soisdisconnected(unp->unp_socket);
unp->unp_socket->so_flags |= SOF_PCBCLEARING;
}
static int
unp_bind(
struct unpcb *unp,
struct sockaddr *nam,
proc_t p)
{
struct sockaddr_un *soun = (struct sockaddr_un *)nam;
struct vnode *vp, *dvp;
struct vnode_attr va;
vfs_context_t ctx = vfs_context_current();
int error, namelen;
struct nameidata nd;
struct socket *so = unp->unp_socket;
char buf[SOCK_MAXADDRLEN];
if (nam->sa_family != 0 && nam->sa_family != AF_UNIX) {
return (EAFNOSUPPORT);
}
if (unp->unp_vnode != NULL)
return (EINVAL);
namelen = soun->sun_len - offsetof(struct sockaddr_un, sun_path);
if (namelen <= 0)
return (EINVAL);
socket_unlock(so, 0);
strlcpy(buf, soun->sun_path, namelen+1);
NDINIT(&nd, CREATE, OP_MKFIFO, FOLLOW | LOCKPARENT, UIO_SYSSPACE,
CAST_USER_ADDR_T(buf), ctx);
error = namei(&nd);
if (error) {
socket_lock(so, 0);
return (error);
}
dvp = nd.ni_dvp;
vp = nd.ni_vp;
if (vp != NULL) {
nameidone(&nd);
vnode_put(dvp);
vnode_put(vp);
socket_lock(so, 0);
return (EADDRINUSE);
}
VATTR_INIT(&va);
VATTR_SET(&va, va_type, VSOCK);
VATTR_SET(&va, va_mode, (ACCESSPERMS & ~p->p_fd->fd_cmask));
#if CONFIG_MACF
error = mac_vnode_check_create(ctx,
nd.ni_dvp, &nd.ni_cnd, &va);
if (error == 0)
#endif
#if CONFIG_MACF_SOCKET_SUBSET
error = mac_vnode_check_uipc_bind(ctx,
nd.ni_dvp, &nd.ni_cnd, &va);
if (error == 0)
#endif
error = vnode_authorize(dvp, NULL, KAUTH_VNODE_ADD_FILE, ctx);
if (!error) {
error = vn_create(dvp, &vp, &nd, &va, 0, 0, NULL, ctx);
}
nameidone(&nd);
vnode_put(dvp);
if (error) {
socket_lock(so, 0);
return (error);
}
vnode_ref(vp);
socket_lock(so, 0);
vp->v_socket = unp->unp_socket;
unp->unp_vnode = vp;
unp->unp_addr = (struct sockaddr_un *)dup_sockaddr(nam, 1);
vnode_put(vp);
return (0);
}
static int
unp_connect(struct socket *so, struct sockaddr *nam, __unused proc_t p)
{
struct sockaddr_un *soun = (struct sockaddr_un *)nam;
struct vnode *vp;
struct socket *so2, *so3, *list_so=NULL;
struct unpcb *unp, *unp2, *unp3;
vfs_context_t ctx = vfs_context_current();
int error, len;
struct nameidata nd;
char buf[SOCK_MAXADDRLEN];
if (nam->sa_family != 0 && nam->sa_family != AF_UNIX) {
return (EAFNOSUPPORT);
}
unp = sotounpcb(so);
so2 = so3 = NULL;
len = nam->sa_len - offsetof(struct sockaddr_un, sun_path);
if (len <= 0)
return (EINVAL);
strlcpy(buf, soun->sun_path, len+1);
socket_unlock(so, 0);
NDINIT(&nd, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF, UIO_SYSSPACE,
CAST_USER_ADDR_T(buf), ctx);
error = namei(&nd);
if (error) {
socket_lock(so, 0);
return (error);
}
nameidone(&nd);
vp = nd.ni_vp;
if (vp->v_type != VSOCK) {
error = ENOTSOCK;
socket_lock(so, 0);
goto out;
}
#if CONFIG_MACF_SOCKET_SUBSET
error = mac_vnode_check_uipc_connect(ctx, vp);
if (error) {
socket_lock(so, 0);
goto out;
}
#endif
error = vnode_authorize(vp, NULL, KAUTH_VNODE_WRITE_DATA, ctx);
if (error) {
socket_lock(so, 0);
goto out;
}
lck_mtx_lock(unp_connect_lock);
if (vp->v_socket == 0) {
lck_mtx_unlock(unp_connect_lock);
error = ECONNREFUSED;
socket_lock(so, 0);
goto out;
}
socket_lock(vp->v_socket, 1);
so2 = vp->v_socket;
lck_mtx_unlock(unp_connect_lock);
if (so2->so_pcb == NULL) {
error = ECONNREFUSED;
if (so != so2) {
socket_unlock(so2, 1);
socket_lock(so, 0);
} else {
so2->so_usecount--;
}
goto out;
}
if (so < so2) {
socket_unlock(so2, 0);
socket_lock(so, 0);
socket_lock(so2, 0);
} else if (so > so2) {
socket_lock(so, 0);
}
if ((so->so_state & SS_ISCONNECTED) != 0) {
error = EISCONN;
goto decref_out;
}
if (so->so_type != so2->so_type) {
error = EPROTOTYPE;
goto decref_out;
}
if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
socket_unlock(so, 0);
if ((so2->so_options & SO_ACCEPTCONN) == 0 ||
(so3 = sonewconn(so2, 0, nam)) == 0) {
error = ECONNREFUSED;
if (so != so2) {
socket_unlock(so2, 1);
socket_lock(so, 0);
} else {
socket_lock(so, 0);
so2->so_usecount--;
}
goto out;
}
unp2 = sotounpcb(so2);
unp3 = sotounpcb(so3);
if (unp2->unp_addr)
unp3->unp_addr = (struct sockaddr_un *)
dup_sockaddr((struct sockaddr *)unp2->unp_addr, 1);
cru2x(vfs_context_ucred(ctx), &unp3->unp_peercred);
unp3->unp_flags |= UNP_HAVEPC;
KASSERT(unp2->unp_flags & UNP_HAVEPCCACHED,
("unp_connect: listener without cached peercred"));
if (so < so2) {
socket_unlock(so2, 0);
socket_lock(so, 0);
socket_lock(so2, 0);
} else {
socket_lock(so, 0);
}
if ((so->so_state & SS_ISCONNECTED) != 0) {
error = EISCONN;
socket_unlock(so2, 1);
socket_lock(so3, 0);
sofreelastref(so3, 1);
goto out;
}
memcpy(&unp->unp_peercred, &unp2->unp_peercred,
sizeof (unp->unp_peercred));
unp->unp_flags |= UNP_HAVEPC;
#if CONFIG_MACF_SOCKET
mac_socketpeer_label_associate_socket(so, so3);
mac_socketpeer_label_associate_socket(so3, so);
#endif
socket_unlock(so2, 0);
list_so = so2;
socket_lock(so3, 1);
so2 = so3;
if (unpst_tracemdns &&
!strncmp(soun->sun_path, MDNSRESPONDER_PATH,
sizeof (MDNSRESPONDER_PATH))) {
unp->unp_flags |= UNP_TRACE_MDNS;
unp2->unp_flags |= UNP_TRACE_MDNS;
}
}
error = unp_connect2(so, so2);
decref_out:
if (so2 != NULL) {
if (so != so2) {
socket_unlock(so2, 1);
} else {
so2->so_usecount--;
}
}
if (list_so != NULL) {
socket_lock(list_so, 0);
socket_unlock(list_so, 1);
}
out:
lck_mtx_assert(&unp->unp_mtx, LCK_MTX_ASSERT_OWNED);
vnode_put(vp);
return (error);
}
int
unp_connect2(struct socket *so, struct socket *so2)
{
struct unpcb *unp = sotounpcb(so);
struct unpcb *unp2;
if (so2->so_type != so->so_type)
return (EPROTOTYPE);
unp2 = sotounpcb(so2);
lck_mtx_assert(&unp->unp_mtx, LCK_MTX_ASSERT_OWNED);
lck_mtx_assert(&unp2->unp_mtx, LCK_MTX_ASSERT_OWNED);
if (unp == 0 || unp2 == 0)
return (EINVAL);
unp->unp_conn = unp2;
so2->so_usecount++;
switch (so->so_type) {
case SOCK_DGRAM:
LIST_INSERT_HEAD(&unp2->unp_refs, unp, unp_reflink);
if (so != so2) {
socket_unlock(so2, 0);
soisconnected(so);
unp_get_locks_in_order(so, so2);
so2->so_usecount--;
} else {
soisconnected(so);
}
break;
case SOCK_STREAM:
if (!(unp->unp_flags & UNP_HAVEPC) &&
!(unp2->unp_flags & UNP_HAVEPC)) {
cru2x(kauth_cred_get(), &unp->unp_peercred);
unp->unp_flags |= UNP_HAVEPC;
cru2x(kauth_cred_get(), &unp2->unp_peercred);
unp2->unp_flags |= UNP_HAVEPC;
}
unp2->unp_conn = unp;
so->so_usecount++;
socket_unlock(so, 0);
soisconnected(so2);
socket_unlock(so2, 0);
socket_lock(so, 0);
soisconnected(so);
unp_get_locks_in_order(so, so2);
so2->so_usecount--;
break;
default:
panic("unknown socket type %d in unp_connect2", so->so_type);
}
lck_mtx_assert(&unp->unp_mtx, LCK_MTX_ASSERT_OWNED);
lck_mtx_assert(&unp2->unp_mtx, LCK_MTX_ASSERT_OWNED);
return (0);
}
static void
unp_disconnect(struct unpcb *unp)
{
struct unpcb *unp2 = NULL;
struct socket *so2 = NULL, *so;
struct socket *waitso;
int so_locked = 1, strdisconn = 0;
so = unp->unp_socket;
if (unp->unp_conn == NULL) {
return;
}
lck_mtx_lock(unp_disconnect_lock);
while (disconnect_in_progress != 0) {
if (so_locked == 1) {
socket_unlock(so, 0);
so_locked = 0;
}
(void)msleep((caddr_t)&disconnect_in_progress, unp_disconnect_lock,
PSOCK, "disconnect", NULL);
}
disconnect_in_progress = 1;
lck_mtx_unlock(unp_disconnect_lock);
if (so_locked == 0) {
socket_lock(so, 0);
so_locked = 1;
}
unp2 = unp->unp_conn;
if (unp2 == 0 || unp2->unp_socket == NULL) {
goto out;
}
so2 = unp2->unp_socket;
try_again:
if (so == so2) {
if (so_locked == 0) {
socket_lock(so, 0);
}
waitso = so;
} else if (so < so2) {
if (so_locked == 0) {
socket_lock(so, 0);
}
socket_lock(so2, 1);
waitso = so2;
} else {
if (so_locked == 1) {
socket_unlock(so, 0);
}
socket_lock(so2, 1);
socket_lock(so, 0);
waitso = so;
}
so_locked = 1;
lck_mtx_assert(&unp->unp_mtx, LCK_MTX_ASSERT_OWNED);
lck_mtx_assert(&unp2->unp_mtx, LCK_MTX_ASSERT_OWNED);
if ((((struct unpcb *)waitso->so_pcb)->unp_flags & UNP_DONTDISCONNECT) != 0) {
if (so != so2) {
socket_unlock(so2, 1);
}
so_locked = 0;
(void)msleep(waitso->so_pcb, &unp->unp_mtx,
PSOCK | PDROP, "unpdisconnect", NULL);
goto try_again;
}
if (unp->unp_conn == NULL) {
panic("unp_conn became NULL after sleep");
}
unp->unp_conn = NULL;
so2->so_usecount--;
if (unp->unp_flags & UNP_TRACE_MDNS)
unp->unp_flags &= ~UNP_TRACE_MDNS;
switch (unp->unp_socket->so_type) {
case SOCK_DGRAM:
LIST_REMOVE(unp, unp_reflink);
unp->unp_socket->so_state &= ~SS_ISCONNECTED;
if (so != so2)
socket_unlock(so2, 1);
break;
case SOCK_STREAM:
unp2->unp_conn = NULL;
so->so_usecount--;
unp->unp_socket->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
unp->unp_socket->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE|SS_ISDISCONNECTED);
unp2->unp_socket->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
unp->unp_socket->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE|SS_ISDISCONNECTED);
if (unp2->unp_flags & UNP_TRACE_MDNS)
unp2->unp_flags &= ~UNP_TRACE_MDNS;
strdisconn = 1;
break;
default:
panic("unknown socket type %d", so->so_type);
}
out:
lck_mtx_lock(unp_disconnect_lock);
disconnect_in_progress = 0;
wakeup(&disconnect_in_progress);
lck_mtx_unlock(unp_disconnect_lock);
if (strdisconn) {
socket_unlock(so, 0);
soisdisconnected(so2);
socket_unlock(so2, 1);
socket_lock(so,0);
soisdisconnected(so);
}
lck_mtx_assert(&unp->unp_mtx, LCK_MTX_ASSERT_OWNED);
return;
}
static void
unpcb_to_compat(struct unpcb *up, struct unpcb_compat *cp)
{
#if defined(__LP64__)
cp->unp_link.le_next = (u_int32_t)
VM_KERNEL_ADDRPERM(up->unp_link.le_next);
cp->unp_link.le_prev = (u_int32_t)
VM_KERNEL_ADDRPERM(up->unp_link.le_prev);
#else
cp->unp_link.le_next = (struct unpcb_compat *)
VM_KERNEL_ADDRPERM(up->unp_link.le_next);
cp->unp_link.le_prev = (struct unpcb_compat **)
VM_KERNEL_ADDRPERM(up->unp_link.le_prev);
#endif
cp->unp_socket = (_UNPCB_PTR(struct socket *))
VM_KERNEL_ADDRPERM(up->unp_socket);
cp->unp_vnode = (_UNPCB_PTR(struct vnode *))
VM_KERNEL_ADDRPERM(up->unp_vnode);
cp->unp_ino = up->unp_ino;
cp->unp_conn = (_UNPCB_PTR(struct unpcb_compat *))
VM_KERNEL_ADDRPERM(up->unp_conn);
cp->unp_refs = (u_int32_t)VM_KERNEL_ADDRPERM(up->unp_refs.lh_first);
#if defined(__LP64__)
cp->unp_reflink.le_next =
(u_int32_t)VM_KERNEL_ADDRPERM(up->unp_reflink.le_next);
cp->unp_reflink.le_prev =
(u_int32_t)VM_KERNEL_ADDRPERM(up->unp_reflink.le_prev);
#else
cp->unp_reflink.le_next =
(struct unpcb_compat *)VM_KERNEL_ADDRPERM(up->unp_reflink.le_next);
cp->unp_reflink.le_prev =
(struct unpcb_compat **)VM_KERNEL_ADDRPERM(up->unp_reflink.le_prev);
#endif
cp->unp_addr = (_UNPCB_PTR(struct sockaddr_un *))
VM_KERNEL_ADDRPERM(up->unp_addr);
cp->unp_cc = up->unp_cc;
cp->unp_mbcnt = up->unp_mbcnt;
cp->unp_gencnt = up->unp_gencnt;
}
static int
unp_pcblist SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp,arg2)
int error, i, n;
struct unpcb *unp, **unp_list;
unp_gen_t gencnt;
struct xunpgen xug;
struct unp_head *head;
lck_rw_lock_shared(unp_list_mtx);
head = ((intptr_t)arg1 == SOCK_DGRAM ? &unp_dhead : &unp_shead);
if (req->oldptr == USER_ADDR_NULL) {
n = unp_count;
req->oldidx = 2 * sizeof (xug) + (n + n / 8) *
sizeof (struct xunpcb);
lck_rw_done(unp_list_mtx);
return (0);
}
if (req->newptr != USER_ADDR_NULL) {
lck_rw_done(unp_list_mtx);
return (EPERM);
}
gencnt = unp_gencnt;
n = unp_count;
bzero(&xug, sizeof (xug));
xug.xug_len = sizeof (xug);
xug.xug_count = n;
xug.xug_gen = gencnt;
xug.xug_sogen = so_gencnt;
error = SYSCTL_OUT(req, &xug, sizeof (xug));
if (error) {
lck_rw_done(unp_list_mtx);
return (error);
}
if (n == 0) {
lck_rw_done(unp_list_mtx);
return (0);
}
MALLOC(unp_list, struct unpcb **, n * sizeof (*unp_list),
M_TEMP, M_WAITOK);
if (unp_list == 0) {
lck_rw_done(unp_list_mtx);
return (ENOMEM);
}
for (unp = head->lh_first, i = 0; unp && i < n;
unp = unp->unp_link.le_next) {
if (unp->unp_gencnt <= gencnt)
unp_list[i++] = unp;
}
n = i;
error = 0;
for (i = 0; i < n; i++) {
unp = unp_list[i];
if (unp->unp_gencnt <= gencnt) {
struct xunpcb xu;
bzero(&xu, sizeof (xu));
xu.xu_len = sizeof (xu);
xu.xu_unpp = (_UNPCB_PTR(struct unpcb_compat *))
VM_KERNEL_ADDRPERM(unp);
if (unp->unp_addr)
bcopy(unp->unp_addr, &xu.xu_addr,
unp->unp_addr->sun_len);
if (unp->unp_conn && unp->unp_conn->unp_addr)
bcopy(unp->unp_conn->unp_addr,
&xu.xu_caddr,
unp->unp_conn->unp_addr->sun_len);
unpcb_to_compat(unp, &xu.xu_unp);
sotoxsocket(unp->unp_socket, &xu.xu_socket);
error = SYSCTL_OUT(req, &xu, sizeof (xu));
}
}
if (!error) {
bzero(&xug, sizeof (xug));
xug.xug_len = sizeof (xug);
xug.xug_gen = unp_gencnt;
xug.xug_sogen = so_gencnt;
xug.xug_count = unp_count;
error = SYSCTL_OUT(req, &xug, sizeof (xug));
}
FREE(unp_list, M_TEMP);
lck_rw_done(unp_list_mtx);
return (error);
}
SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist, CTLFLAG_RD | CTLFLAG_LOCKED,
(caddr_t)(long)SOCK_DGRAM, 0, unp_pcblist, "S,xunpcb",
"List of active local datagram sockets");
SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist, CTLFLAG_RD | CTLFLAG_LOCKED,
(caddr_t)(long)SOCK_STREAM, 0, unp_pcblist, "S,xunpcb",
"List of active local stream sockets");
#if !CONFIG_EMBEDDED
static int
unp_pcblist64 SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp,arg2)
int error, i, n;
struct unpcb *unp, **unp_list;
unp_gen_t gencnt;
struct xunpgen xug;
struct unp_head *head;
lck_rw_lock_shared(unp_list_mtx);
head = ((intptr_t)arg1 == SOCK_DGRAM ? &unp_dhead : &unp_shead);
if (req->oldptr == USER_ADDR_NULL) {
n = unp_count;
req->oldidx = 2 * sizeof (xug) + (n + n / 8) *
(sizeof (struct xunpcb64));
lck_rw_done(unp_list_mtx);
return (0);
}
if (req->newptr != USER_ADDR_NULL) {
lck_rw_done(unp_list_mtx);
return (EPERM);
}
gencnt = unp_gencnt;
n = unp_count;
bzero(&xug, sizeof (xug));
xug.xug_len = sizeof (xug);
xug.xug_count = n;
xug.xug_gen = gencnt;
xug.xug_sogen = so_gencnt;
error = SYSCTL_OUT(req, &xug, sizeof (xug));
if (error) {
lck_rw_done(unp_list_mtx);
return (error);
}
if (n == 0) {
lck_rw_done(unp_list_mtx);
return (0);
}
MALLOC(unp_list, struct unpcb **, n * sizeof (*unp_list),
M_TEMP, M_WAITOK);
if (unp_list == 0) {
lck_rw_done(unp_list_mtx);
return (ENOMEM);
}
for (unp = head->lh_first, i = 0; unp && i < n;
unp = unp->unp_link.le_next) {
if (unp->unp_gencnt <= gencnt)
unp_list[i++] = unp;
}
n = i;
error = 0;
for (i = 0; i < n; i++) {
unp = unp_list[i];
if (unp->unp_gencnt <= gencnt) {
struct xunpcb64 xu;
size_t xu_len = sizeof(struct xunpcb64);
bzero(&xu, xu_len);
xu.xu_len = xu_len;
xu.xu_unpp = (u_int64_t)VM_KERNEL_ADDRPERM(unp);
xu.xunp_link.le_next = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_link.le_next);
xu.xunp_link.le_prev = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_link.le_prev);
xu.xunp_socket = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_socket);
xu.xunp_vnode = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_vnode);
xu.xunp_ino = unp->unp_ino;
xu.xunp_conn = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_conn);
xu.xunp_refs = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_refs.lh_first);
xu.xunp_reflink.le_next = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_reflink.le_next);
xu.xunp_reflink.le_prev = (u_int64_t)
VM_KERNEL_ADDRPERM(unp->unp_reflink.le_prev);
xu.xunp_cc = unp->unp_cc;
xu.xunp_mbcnt = unp->unp_mbcnt;
xu.xunp_gencnt = unp->unp_gencnt;
if (unp->unp_socket)
sotoxsocket64(unp->unp_socket, &xu.xu_socket);
if (unp->unp_addr)
bcopy(unp->unp_addr, &xu.xunp_addr,
unp->unp_addr->sun_len);
if (unp->unp_conn && unp->unp_conn->unp_addr)
bcopy(unp->unp_conn->unp_addr,
&xu.xunp_caddr,
unp->unp_conn->unp_addr->sun_len);
error = SYSCTL_OUT(req, &xu, xu_len);
}
}
if (!error) {
bzero(&xug, sizeof (xug));
xug.xug_len = sizeof (xug);
xug.xug_gen = unp_gencnt;
xug.xug_sogen = so_gencnt;
xug.xug_count = unp_count;
error = SYSCTL_OUT(req, &xug, sizeof (xug));
}
FREE(unp_list, M_TEMP);
lck_rw_done(unp_list_mtx);
return (error);
}
SYSCTL_PROC(_net_local_dgram, OID_AUTO, pcblist64, CTLFLAG_RD | CTLFLAG_LOCKED,
(caddr_t)(long)SOCK_DGRAM, 0, unp_pcblist64, "S,xunpcb64",
"List of active local datagram sockets 64 bit");
SYSCTL_PROC(_net_local_stream, OID_AUTO, pcblist64, CTLFLAG_RD | CTLFLAG_LOCKED,
(caddr_t)(long)SOCK_STREAM, 0, unp_pcblist64, "S,xunpcb64",
"List of active local stream sockets 64 bit");
#endif
static void
unp_shutdown(struct unpcb *unp)
{
struct socket *so = unp->unp_socket;
struct socket *so2;
if (unp->unp_socket->so_type == SOCK_STREAM && unp->unp_conn) {
so2 = unp->unp_conn->unp_socket;
unp_get_locks_in_order(so, so2);
socantrcvmore(so2);
socket_unlock(so2, 1);
}
}
static void
unp_drop(struct unpcb *unp, int errno)
{
struct socket *so = unp->unp_socket;
so->so_error = errno;
unp_disconnect(unp);
}
int
unp_externalize(struct mbuf *rights)
{
proc_t p = current_proc();
int i;
struct cmsghdr *cm = mtod(rights, struct cmsghdr *);
struct fileglob **rp = (struct fileglob **)(cm + 1);
int *fds = (int *)(cm + 1);
struct fileproc *fp;
struct fileglob *fg;
int newfds = (cm->cmsg_len - sizeof (*cm)) / sizeof (int);
int f;
proc_fdlock(p);
if (!fdavail(p, newfds)) {
for (i = 0; i < newfds; i++) {
fg = *rp;
unp_discard_fdlocked(fg, p);
*rp++ = NULL;
}
proc_fdunlock(p);
return (EMSGSIZE);
}
for (i = 0; i < newfds; i++) {
#if CONFIG_MACF_SOCKET
if (mac_file_check_receive(kauth_cred_get(), *rp)) {
fg = *rp;
*rp++ = 0;
unp_discard_fdlocked(fg, p);
continue;
}
#endif
if (fdalloc(p, 0, &f))
panic("unp_externalize:fdalloc");
fg = rp[i];
MALLOC_ZONE(fp, struct fileproc *, sizeof (struct fileproc),
M_FILEPROC, M_WAITOK);
if (fp == NULL)
panic("unp_externalize: MALLOC_ZONE");
bzero(fp, sizeof (struct fileproc));
fp->f_iocount = 0;
fp->f_fglob = fg;
fg_removeuipc(fg);
procfdtbl_releasefd(p, f, fp);
(void) OSAddAtomic(-1, &unp_rights);
fds[i] = f;
}
proc_fdunlock(p);
return (0);
}
void
unp_init(void)
{
unp_zone = zinit(sizeof (struct unpcb),
(nmbclusters * sizeof (struct unpcb)), 4096, "unpzone");
if (unp_zone == 0)
panic("unp_init");
LIST_INIT(&unp_dhead);
LIST_INIT(&unp_shead);
unp_mtx_grp_attr = lck_grp_attr_alloc_init();
unp_mtx_grp = lck_grp_alloc_init("unp_list", unp_mtx_grp_attr);
unp_mtx_attr = lck_attr_alloc_init();
if ((unp_list_mtx = lck_rw_alloc_init(unp_mtx_grp,
unp_mtx_attr)) == NULL)
return;
if ((unp_disconnect_lock = lck_mtx_alloc_init(unp_mtx_grp,
unp_mtx_attr)) == NULL)
return;
if ((unp_connect_lock = lck_mtx_alloc_init(unp_mtx_grp,
unp_mtx_attr)) == NULL)
return;
}
#ifndef MIN
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
static int
unp_internalize(struct mbuf *control, proc_t p)
{
struct cmsghdr *cm = mtod(control, struct cmsghdr *);
int *fds;
struct fileglob **rp;
struct fileproc *fp;
int i, error;
int oldfds;
if (cm->cmsg_type != SCM_RIGHTS || cm->cmsg_level != SOL_SOCKET ||
(socklen_t)cm->cmsg_len != (socklen_t)control->m_len) {
return (EINVAL);
}
oldfds = (cm->cmsg_len - sizeof (*cm)) / sizeof (int);
proc_fdlock(p);
fds = (int *)(cm + 1);
for (i = 0; i < oldfds; i++) {
struct fileproc *tmpfp;
if (((error = fdgetf_noref(p, fds[i], &tmpfp)) != 0)) {
proc_fdunlock(p);
return (error);
} else if (!filetype_issendable(tmpfp->f_fglob->fg_type)) {
proc_fdunlock(p);
return (EINVAL);
}
}
rp = (struct fileglob **)(cm + 1);
for (i = (oldfds - 1); i >= 0; i--) {
(void) fdgetf_noref(p, fds[i], &fp);
fg_insertuipc(fp->f_fglob);
rp[i] = fp->f_fglob;
(void) OSAddAtomic(1, &unp_rights);
}
proc_fdunlock(p);
return (0);
}
static int unp_defer, unp_gcing, unp_gcwait;
static thread_t unp_gcthread = NULL;
void
unp_gc_wait(void)
{
if (unp_gcthread == current_thread())
return;
while (unp_gcing != 0) {
unp_gcwait = 1;
msleep(&unp_gcing, uipc_lock, 0 , "unp_gc_wait", NULL);
}
}
__private_extern__ void
unp_gc(void)
{
struct fileglob *fg, *nextfg;
struct socket *so;
static struct fileglob **extra_ref;
struct fileglob **fpp;
int nunref, i;
int need_gcwakeup = 0;
lck_mtx_lock(uipc_lock);
if (unp_gcing) {
lck_mtx_unlock(uipc_lock);
return;
}
unp_gcing = 1;
unp_defer = 0;
unp_gcthread = current_thread();
lck_mtx_unlock(uipc_lock);
for (fg = fmsghead.lh_first; fg != 0; fg = fg->f_msglist.le_next) {
lck_mtx_lock(&fg->fg_lock);
fg->fg_flag &= ~(FMARK|FDEFER);
lck_mtx_unlock(&fg->fg_lock);
}
do {
for (fg = fmsghead.lh_first; fg != 0;
fg = fg->f_msglist.le_next) {
lck_mtx_lock(&fg->fg_lock);
if (fg->fg_count == 0) {
lck_mtx_unlock(&fg->fg_lock);
continue;
}
if (fg->fg_flag & FDEFER) {
fg->fg_flag &= ~FDEFER;
unp_defer--;
} else {
if (fg->fg_flag & FMARK) {
lck_mtx_unlock(&fg->fg_lock);
continue;
}
if (fg->fg_count == fg->fg_msgcount) {
lck_mtx_unlock(&fg->fg_lock);
continue;
}
fg->fg_flag |= FMARK;
}
if (fg->fg_type != DTYPE_SOCKET ||
(so = (struct socket *)fg->fg_data) == 0) {
lck_mtx_unlock(&fg->fg_lock);
continue;
}
if (so->so_proto->pr_domain != &localdomain ||
(so->so_proto->pr_flags&PR_RIGHTS) == 0) {
lck_mtx_unlock(&fg->fg_lock);
continue;
}
#ifdef notdef
if (so->so_rcv.sb_flags & SB_LOCK) {
(void) sbwait(&so->so_rcv);
goto restart;
}
#endif
lck_mtx_unlock(&fg->fg_lock);
unp_scan(so->so_rcv.sb_mb, unp_mark);
}
} while (unp_defer);
extra_ref = _MALLOC(nfiles * sizeof (struct fileglob *),
M_FILEGLOB, M_WAITOK);
if (extra_ref == NULL)
goto bail;
for (nunref = 0, fg = fmsghead.lh_first, fpp = extra_ref; fg != 0;
fg = nextfg) {
lck_mtx_lock(&fg->fg_lock);
nextfg = fg->f_msglist.le_next;
if (fg->fg_count == 0) {
lck_mtx_unlock(&fg->fg_lock);
continue;
}
if (fg->fg_count == fg->fg_msgcount && !(fg->fg_flag & FMARK)) {
fg->fg_count++;
*fpp++ = fg;
nunref++;
}
lck_mtx_unlock(&fg->fg_lock);
}
for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp) {
struct fileglob *tfg;
tfg = *fpp;
if (tfg->fg_type == DTYPE_SOCKET && tfg->fg_data != NULL) {
so = (struct socket *)(tfg->fg_data);
socket_lock(so, 0);
sorflush(so);
socket_unlock(so, 0);
}
}
for (i = nunref, fpp = extra_ref; --i >= 0; ++fpp)
closef_locked((struct fileproc *)0, *fpp, (proc_t)NULL);
FREE((caddr_t)extra_ref, M_FILEGLOB);
bail:
lck_mtx_lock(uipc_lock);
unp_gcing = 0;
unp_gcthread = NULL;
if (unp_gcwait != 0) {
unp_gcwait = 0;
need_gcwakeup = 1;
}
lck_mtx_unlock(uipc_lock);
if (need_gcwakeup != 0)
wakeup(&unp_gcing);
}
void
unp_dispose(struct mbuf *m)
{
if (m) {
unp_scan(m, unp_discard);
}
}
static int
unp_listen(struct unpcb *unp, proc_t p)
{
kauth_cred_t safecred = kauth_cred_proc_ref(p);
cru2x(safecred, &unp->unp_peercred);
kauth_cred_unref(&safecred);
unp->unp_flags |= UNP_HAVEPCCACHED;
return (0);
}
static void
unp_scan(struct mbuf *m0, void (*op)(struct fileglob *))
{
struct mbuf *m;
struct fileglob **rp;
struct cmsghdr *cm;
int i;
int qfds;
while (m0) {
for (m = m0; m; m = m->m_next)
if (m->m_type == MT_CONTROL &&
(size_t)m->m_len >= sizeof (*cm)) {
cm = mtod(m, struct cmsghdr *);
if (cm->cmsg_level != SOL_SOCKET ||
cm->cmsg_type != SCM_RIGHTS)
continue;
qfds = (cm->cmsg_len - sizeof (*cm)) /
sizeof (int);
rp = (struct fileglob **)(cm + 1);
for (i = 0; i < qfds; i++)
(*op)(*rp++);
break;
}
m0 = m0->m_act;
}
}
static void
unp_mark(struct fileglob *fg)
{
lck_mtx_lock(&fg->fg_lock);
if (fg->fg_flag & FMARK) {
lck_mtx_unlock(&fg->fg_lock);
return;
}
fg->fg_flag |= (FMARK|FDEFER);
lck_mtx_unlock(&fg->fg_lock);
unp_defer++;
}
static void
unp_discard(struct fileglob *fg)
{
proc_t p = current_proc();
(void) OSAddAtomic(1, &unp_disposed);
proc_fdlock(p);
unp_discard_fdlocked(fg, p);
proc_fdunlock(p);
}
static void
unp_discard_fdlocked(struct fileglob *fg, proc_t p)
{
fg_removeuipc(fg);
(void) OSAddAtomic(-1, &unp_rights);
(void) closef_locked((struct fileproc *)0, fg, p);
}
int
unp_lock(struct socket *so, int refcount, void * lr)
{
void * lr_saved;
if (lr == 0)
lr_saved = (void *) __builtin_return_address(0);
else lr_saved = lr;
if (so->so_pcb) {
lck_mtx_lock(&((struct unpcb *)so->so_pcb)->unp_mtx);
} else {
panic("unp_lock: so=%p NO PCB! lr=%p ref=0x%x\n",
so, lr_saved, so->so_usecount);
}
if (so->so_usecount < 0)
panic("unp_lock: so=%p so_pcb=%p lr=%p ref=0x%x\n",
so, so->so_pcb, lr_saved, so->so_usecount);
if (refcount)
so->so_usecount++;
so->lock_lr[so->next_lock_lr] = lr_saved;
so->next_lock_lr = (so->next_lock_lr+1) % SO_LCKDBG_MAX;
return (0);
}
int
unp_unlock(struct socket *so, int refcount, void * lr)
{
void * lr_saved;
lck_mtx_t * mutex_held = NULL;
struct unpcb *unp = sotounpcb(so);
if (lr == 0)
lr_saved = (void *) __builtin_return_address(0);
else lr_saved = lr;
if (refcount)
so->so_usecount--;
if (so->so_usecount < 0)
panic("unp_unlock: so=%p usecount=%x\n", so, so->so_usecount);
if (so->so_pcb == NULL) {
panic("unp_unlock: so=%p NO PCB usecount=%x\n", so, so->so_usecount);
} else {
mutex_held = &((struct unpcb *)so->so_pcb)->unp_mtx;
}
lck_mtx_assert(mutex_held, LCK_MTX_ASSERT_OWNED);
so->unlock_lr[so->next_unlock_lr] = lr_saved;
so->next_unlock_lr = (so->next_unlock_lr+1) % SO_LCKDBG_MAX;
if (so->so_usecount == 0 && (so->so_flags & SOF_PCBCLEARING)) {
sofreelastref(so, 1);
if (unp->unp_addr)
FREE(unp->unp_addr, M_SONAME);
lck_mtx_unlock(mutex_held);
lck_mtx_destroy(&unp->unp_mtx, unp_mtx_grp);
zfree(unp_zone, unp);
unp_gc();
} else {
lck_mtx_unlock(mutex_held);
}
return (0);
}
lck_mtx_t *
unp_getlock(struct socket *so, __unused int locktype)
{
struct unpcb *unp = (struct unpcb *)so->so_pcb;
if (so->so_pcb) {
if (so->so_usecount < 0)
panic("unp_getlock: so=%p usecount=%x\n", so, so->so_usecount);
return(&unp->unp_mtx);
} else {
panic("unp_getlock: so=%p NULL so_pcb\n", so);
return (so->so_proto->pr_domain->dom_mtx);
}
}