__private_extern__ void
sotoxsocket_n(struct socket *so, struct xsocket_n *xso)
{
xso->xso_len = sizeof (struct xsocket_n);
xso->xso_kind = XSO_SOCKET;
if (so != NULL) {
xso->xso_so = (uint64_t)VM_KERNEL_ADDRPERM(so);
xso->so_type = so->so_type;
xso->so_options = so->so_options;
xso->so_linger = so->so_linger;
xso->so_state = so->so_state;
xso->so_pcb = (uint64_t)VM_KERNEL_ADDRPERM(so->so_pcb);
if (so->so_proto) {
xso->xso_protocol = SOCK_PROTO(so);
xso->xso_family = SOCK_DOM(so);
} else {
xso->xso_protocol = xso->xso_family = 0;
}
xso->so_qlen = so->so_qlen;
xso->so_incqlen = so->so_incqlen;
xso->so_qlimit = so->so_qlimit;
xso->so_timeo = so->so_timeo;
xso->so_error = so->so_error;
xso->so_pgid = so->so_pgid;
xso->so_oobmark = so->so_oobmark;
xso->so_uid = kauth_cred_getuid(so->so_cred);
xso->so_last_pid = so->last_pid;
xso->so_e_pid = so->e_pid;
}
}
static void
fill_common_sockinfo(struct socket *so, struct socket_info *si)
{
si->soi_so = (u_int64_t)VM_KERNEL_ADDRPERM(so);
si->soi_type = so->so_type;
si->soi_options = (short)(so->so_options & 0xffff);
si->soi_linger = so->so_linger;
si->soi_state = so->so_state;
si->soi_pcb = (u_int64_t)VM_KERNEL_ADDRPERM(so->so_pcb);
if (so->so_proto) {
si->soi_protocol = SOCK_PROTO(so);
if (so->so_proto->pr_domain)
si->soi_family = SOCK_DOM(so);
else
si->soi_family = 0;
} else {
si->soi_protocol = si->soi_family = 0;
}
si->soi_qlen = so->so_qlen;
si->soi_incqlen = so->so_incqlen;
si->soi_qlimit = so->so_qlimit;
si->soi_timeo = so->so_timeo;
si->soi_error = so->so_error;
si->soi_oobmark = so->so_oobmark;
fill_sockbuf_info(&so->so_snd, &si->soi_snd);
fill_sockbuf_info(&so->so_rcv, &si->soi_rcv);
}
__private_extern__ uint32_t
inpcb_count_opportunistic(unsigned int ifindex, struct inpcbinfo *pcbinfo,
u_int32_t flags)
{
uint32_t opportunistic = 0;
struct inpcb *inp;
inp_gen_t gencnt;
lck_rw_lock_shared(pcbinfo->ipi_lock);
gencnt = pcbinfo->ipi_gencnt;
for (inp = LIST_FIRST(pcbinfo->ipi_listhead);
inp != NULL; inp = LIST_NEXT(inp, inp_list)) {
if (inp->inp_gencnt <= gencnt &&
inp->inp_state != INPCB_STATE_DEAD &&
inp->inp_socket != NULL &&
so_get_opportunistic(inp->inp_socket) &&
inp->inp_last_outifp != NULL &&
ifindex == inp->inp_last_outifp->if_index) {
opportunistic++;
struct socket *so = inp->inp_socket;
if ((flags & INPCB_OPPORTUNISTIC_SETCMD) &&
(so->so_state & SS_ISCONNECTED)) {
socket_lock(so, 1);
if (flags & INPCB_OPPORTUNISTIC_THROTTLEON) {
so->so_flags |= SOF_SUSPENDED;
soevent(so,
(SO_FILT_HINT_LOCKED |
SO_FILT_HINT_SUSPEND));
} else {
so->so_flags &= ~(SOF_SUSPENDED);
soevent(so,
(SO_FILT_HINT_LOCKED |
SO_FILT_HINT_RESUME));
}
SOTHROTTLELOG(("throttle[%d]: so 0x%llx "
"[%d,%d] %s\n", so->last_pid,
(uint64_t)VM_KERNEL_ADDRPERM(so),
SOCK_DOM(so), SOCK_TYPE(so),
(so->so_flags & SOF_SUSPENDED) ?
"SUSPENDED" : "RESUMED"));
socket_unlock(so, 1);
}
}
}
lck_rw_done(pcbinfo->ipi_lock);
return (opportunistic);
}
__private_extern__ uint32_t
inpcb_find_anypcb_byaddr(struct ifaddr *ifa, struct inpcbinfo *pcbinfo)
{
struct inpcb *inp;
inp_gen_t gencnt = pcbinfo->ipi_gencnt;
struct socket *so = NULL;
int af;
if ((ifa->ifa_addr->sa_family != AF_INET) &&
(ifa->ifa_addr->sa_family != AF_INET6)) {
return (0);
}
lck_rw_lock_shared(pcbinfo->ipi_lock);
for (inp = LIST_FIRST(pcbinfo->ipi_listhead);
inp != NULL; inp = LIST_NEXT(inp, inp_list)) {
if (inp->inp_gencnt <= gencnt &&
inp->inp_state != INPCB_STATE_DEAD &&
inp->inp_socket != NULL) {
so = inp->inp_socket;
af = SOCK_DOM(so);
if (af != ifa->ifa_addr->sa_family)
continue;
if (inp->inp_last_outifp != ifa->ifa_ifp)
continue;
if (af == AF_INET) {
if (inp->inp_laddr.s_addr ==
(satosin(ifa->ifa_addr))->sin_addr.s_addr) {
lck_rw_done(pcbinfo->ipi_lock);
return (1);
}
}
if (af == AF_INET6) {
if (IN6_ARE_ADDR_EQUAL(IFA_IN6(ifa),
&inp->in6p_laddr)) {
lck_rw_done(pcbinfo->ipi_lock);
return (1);
}
}
}
}
lck_rw_done(pcbinfo->ipi_lock);
return (0);
}
errno_t
fill_socketinfo(struct socket *so, struct socket_info *si)
{
errno_t error = 0;
int domain;
short type;
short protocol;
socket_lock(so, 0);
si->soi_kind = SOCKINFO_GENERIC;
fill_common_sockinfo(so, si);
if (so->so_pcb == NULL || so->so_proto == 0 ||
so->so_proto->pr_domain == NULL)
goto out;
/*
* The kind of socket is determined by the triplet
* {domain, type, protocol}
*/
domain = SOCK_DOM(so);
type = SOCK_TYPE(so);
protocol = SOCK_PROTO(so);
switch (domain) {
case PF_INET:
case PF_INET6: {
struct in_sockinfo *insi = &si->soi_proto.pri_in;
struct inpcb *inp = (struct inpcb *)so->so_pcb;
si->soi_kind = SOCKINFO_IN;
insi->insi_fport = inp->inp_fport;
insi->insi_lport = inp->inp_lport;
insi->insi_gencnt = inp->inp_gencnt;
insi->insi_flags = inp->inp_flags;
insi->insi_vflag = inp->inp_vflag;
insi->insi_ip_ttl = inp->inp_ip_ttl;
insi->insi_faddr.ina_6 = inp->inp_dependfaddr.inp6_foreign;
insi->insi_laddr.ina_6 = inp->inp_dependladdr.inp6_local;
insi->insi_v4.in4_tos = inp->inp_depend4.inp4_ip_tos;
insi->insi_v6.in6_hlim = 0;
insi->insi_v6.in6_cksum = inp->inp_depend6.inp6_cksum;
insi->insi_v6.in6_ifindex = 0;
insi->insi_v6.in6_hops = inp->inp_depend6.inp6_hops;
if (type == SOCK_STREAM && (protocol == 0 ||
protocol == IPPROTO_TCP) && inp->inp_ppcb != NULL) {
struct tcp_sockinfo *tcpsi = &si->soi_proto.pri_tcp;
struct tcpcb *tp = (struct tcpcb *)inp->inp_ppcb;
si->soi_kind = SOCKINFO_TCP;
tcpsi->tcpsi_state = tp->t_state;
tcpsi->tcpsi_timer[TCPT_REXMT] =
tp->t_timer[TCPT_REXMT];
tcpsi->tcpsi_timer[TCPT_PERSIST] =
tp->t_timer[TCPT_PERSIST];
tcpsi->tcpsi_timer[TCPT_KEEP] = tp->t_timer[TCPT_KEEP];
tcpsi->tcpsi_timer[TCPT_2MSL] = tp->t_timer[TCPT_2MSL];
tcpsi->tcpsi_mss = tp->t_maxseg;
tcpsi->tcpsi_flags = tp->t_flags;
tcpsi->tcpsi_tp =
(u_int64_t)VM_KERNEL_ADDRPERM(tp);
}
break;
}
case PF_UNIX: {
struct unpcb *unp = (struct unpcb *)so->so_pcb;
struct un_sockinfo *unsi = &si->soi_proto.pri_un;
si->soi_kind = SOCKINFO_UN;
unsi->unsi_conn_pcb =
(uint64_t)VM_KERNEL_ADDRPERM(unp->unp_conn);
if (unp->unp_conn)
unsi->unsi_conn_so = (uint64_t)
VM_KERNEL_ADDRPERM(unp->unp_conn->unp_socket);
if (unp->unp_addr) {
size_t addrlen = unp->unp_addr->sun_len;
if (addrlen > SOCK_MAXADDRLEN)
addrlen = SOCK_MAXADDRLEN;
bcopy(unp->unp_addr, &unsi->unsi_addr, addrlen);
}
if (unp->unp_conn && unp->unp_conn->unp_addr) {
size_t addrlen = unp->unp_conn->unp_addr->sun_len;
if (addrlen > SOCK_MAXADDRLEN)
addrlen = SOCK_MAXADDRLEN;
bcopy(unp->unp_conn->unp_addr, &unsi->unsi_caddr,
addrlen);
}
break;
}
case PF_NDRV: {
struct ndrv_cb *ndrv_cb = (struct ndrv_cb *)so->so_pcb;
struct ndrv_info *ndrvsi = &si->soi_proto.pri_ndrv;
si->soi_kind = SOCKINFO_NDRV;
/* TDB lock ifnet ???? */
if (ndrv_cb->nd_if != 0) {
struct ifnet *ifp = ndrv_cb->nd_if;
ndrvsi->ndrvsi_if_family = ifp->if_family;
ndrvsi->ndrvsi_if_unit = ifp->if_unit;
strlcpy(ndrvsi->ndrvsi_if_name, ifp->if_name, IFNAMSIZ);
}
break;
}
case PF_SYSTEM:
if (SOCK_PROTO(so) == SYSPROTO_EVENT) {
struct kern_event_pcb *ev_pcb =
(struct kern_event_pcb *)so->so_pcb;
struct kern_event_info *kesi =
&si->soi_proto.pri_kern_event;
si->soi_kind = SOCKINFO_KERN_EVENT;
kesi->kesi_vendor_code_filter =
ev_pcb->evp_vendor_code_filter;
kesi->kesi_class_filter = ev_pcb->evp_class_filter;
kesi->kesi_subclass_filter = ev_pcb->evp_subclass_filter;
} else if (SOCK_PROTO(so) == SYSPROTO_CONTROL) {
struct ctl_cb *kcb = (struct ctl_cb *)so->so_pcb;
struct kern_ctl_info *kcsi =
&si->soi_proto.pri_kern_ctl;
struct kctl *kctl = kcb->kctl;
si->soi_kind = SOCKINFO_KERN_CTL;
if (kctl == 0)
break;
kcsi->kcsi_id = kctl->id;
kcsi->kcsi_reg_unit = kctl->id;
kcsi->kcsi_flags = kctl->flags;
kcsi->kcsi_recvbufsize = kctl->recvbufsize;
kcsi->kcsi_sendbufsize = kctl->sendbufsize;
kcsi->kcsi_unit = kcb->unit;
strlcpy(kcsi->kcsi_name, kctl->name, MAX_KCTL_NAME);
}
break;
case PF_ROUTE:
case PF_PPP:
default:
break;
}
out:
socket_unlock(so, 0);
return (error);
}
static int
shutdown_sockets_on_interface_proc_callout(proc_t p, void *arg)
{
struct filedesc *fdp;
int i;
struct ifnet *ifp = (struct ifnet *)arg;
if (ifp == NULL)
return (PROC_RETURNED);
proc_fdlock(p);
fdp = p->p_fd;
for (i = 0; i < fdp->fd_nfiles; i++) {
struct fileproc *fp = fdp->fd_ofiles[i];
struct fileglob *fg;
struct socket *so;
struct inpcb *inp;
struct ifnet *inp_ifp;
int error;
if (fp == NULL || (fdp->fd_ofileflags[i] & UF_RESERVED) != 0) {
continue;
}
fg = fp->f_fglob;
if (FILEGLOB_DTYPE(fg) != DTYPE_SOCKET)
continue;
so = (struct socket *)fp->f_fglob->fg_data;
if (SOCK_DOM(so) != PF_INET && SOCK_DOM(so) != PF_INET6)
continue;
inp = (struct inpcb *)so->so_pcb;
if (in_pcb_checkstate(inp, WNT_ACQUIRE, 0) == WNT_STOPUSING)
continue;
socket_lock(so, 1);
if (in_pcb_checkstate(inp, WNT_RELEASE, 1) == WNT_STOPUSING) {
socket_unlock(so, 1);
continue;
}
if (inp->inp_boundifp != NULL) {
inp_ifp = inp->inp_boundifp;
} else if (inp->inp_last_outifp != NULL) {
inp_ifp = inp->inp_last_outifp;
} else {
socket_unlock(so, 1);
continue;
}
if (inp_ifp != ifp && inp_ifp->if_delegated.ifp != ifp) {
socket_unlock(so, 1);
continue;
}
error = sosetdefunct(p, so, 0, TRUE);
if (error != 0) {
log(LOG_ERR, "%s: sosetdefunct() error %d",
__func__, error);
} else {
error = sodefunct(p, so, 0);
if (error != 0) {
log(LOG_ERR, "%s: sodefunct() error %d",
__func__, error);
}
}
socket_unlock(so, 1);
}
proc_fdunlock(p);
return (PROC_RETURNED);
}