X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/6d2010ae8f7a6078e10b361c6962983bab233e0f..4bd07ac2140668789aa3ee8ec4dde4a3e0a3bba5:/bsd/net/if.c diff --git a/bsd/net/if.c b/bsd/net/if.c index 26314b948..57d48d21c 100644 --- a/bsd/net/if.c +++ b/bsd/net/if.c @@ -1,8 +1,8 @@ /* - * Copyright (c) 2000-2010 Apple Inc. All rights reserved. + * Copyright (c) 2000-2015 Apple Inc. All rights reserved. * * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ - * + * * This file contains Original Code and/or Modifications of Original Code * as defined in and that are subject to the Apple Public Source License * Version 2.0 (the 'License'). You may not use this file except in @@ -11,10 +11,10 @@ * unlawful or unlicensed copies of an Apple operating system, or to * circumvent, violate, or enable the circumvention or violation of, any * terms of an Apple operating system software license agreement. - * + * * Please obtain a copy of the License at * http://www.opensource.apple.com/apsl/ and read it before using this file. - * + * * The Original Code and all software distributed under the License are * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, @@ -22,7 +22,7 @@ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. * Please see the License for the specific language governing rights and * limitations under the License. - * + * * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* @@ -82,6 +82,8 @@ #include #include #include +#include +#include #include #include @@ -93,17 +95,15 @@ #include #include #include -#include +#include #include +#include #include #include -#ifdef __APPLE__ #include -//#include #include #include -#endif #if INET || INET6 /*XXX*/ @@ -111,29 +111,48 @@ #include #include #include +#include +#include +#include +#include +#include #if INET6 #include #include #include -#endif -#endif +#include +#endif /* INET6 */ +#endif /* INET || INET6 */ -#if CONFIG_MACF_NET +#if CONFIG_MACF_NET #include #endif +#if PF_ALTQ +#include +#endif /* !PF_ALTQ */ /* * System initialization */ +extern char *proc_name_address(void *); + /* Lock group and attribute for ifaddr lock */ lck_attr_t *ifa_mtx_attr; lck_grp_t *ifa_mtx_grp; static lck_grp_attr_t *ifa_mtx_grp_attr; +static int ifioctl_ifreq(struct socket *, u_long, struct ifreq *, + struct proc *); +static int ifioctl_ifconf(u_long, caddr_t); +static int ifioctl_ifclone(u_long, caddr_t); +static int ifioctl_ifdesc(struct ifnet *, u_long, caddr_t, struct proc *); +static int ifioctl_linkparams(struct ifnet *, u_long, caddr_t, struct proc *); +static int ifioctl_qstats(struct ifnet *, u_long, caddr_t); +static int ifioctl_throttle(struct ifnet *, u_long, caddr_t, struct proc *); +static int ifioctl_netsignature(struct ifnet *, u_long, caddr_t); static int ifconf(u_long cmd, user_addr_t ifrp, int * ret_space); -static void if_qflush(struct ifqueue *); __private_extern__ void link_rtrequest(int, struct rtentry *, struct sockaddr *); void if_rtproto_del(struct ifnet *ifp, int protocol); @@ -145,13 +164,10 @@ static int if_delmulti_common(struct ifmultiaddr *, struct ifnet *, static int if_rtmtu(struct radix_node *, void *); static void if_rtmtu_update(struct ifnet *); -#if IF_CLONE_LIST -static int if_clone_list(int count, int * total, user_addr_t dst); -#endif /* IF_CLONE_LIST */ +static int if_clone_list(int, int *, user_addr_t); MALLOC_DEFINE(M_IFADDR, "ifaddr", "interface address"); -int ifqmaxlen = IFQ_MAXLEN; struct ifnethead ifnet_head = TAILQ_HEAD_INITIALIZER(ifnet_head); static int if_cloners_count; @@ -213,6 +229,15 @@ extern void nd6_setmtu(struct ifnet *); extern lck_mtx_t *nd6_mutex; #endif +SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Link layers"); +SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW|CTLFLAG_LOCKED, 0, + "Generic link-management"); + +SYSCTL_DECL(_net_link_generic_system); + +static uint32_t if_verbose = 0; +SYSCTL_INT(_net_link_generic_system, OID_AUTO, if_verbose, + CTLFLAG_RW | CTLFLAG_LOCKED, &if_verbose, 0, ""); void ifa_init(void) @@ -394,7 +419,7 @@ if_next_index(void) /* allocate space for the larger arrays */ n = (2 * new_if_indexlim + 1) * sizeof(caddr_t); - new_ifnet_addrs = _MALLOC(n, M_IFADDR, M_WAITOK); + new_ifnet_addrs = _MALLOC(n, M_IFADDR, M_WAITOK | M_ZERO); if (new_ifnet_addrs == NULL) { --if_index; return -1; @@ -402,7 +427,6 @@ if_next_index(void) new_ifindex2ifnet = new_ifnet_addrs + new_if_indexlim * sizeof(caddr_t); - bzero(new_ifnet_addrs, n); if (ifnet_addrs != NULL) { /* copy the existing data */ bcopy((caddr_t)ifnet_addrs, new_ifnet_addrs, @@ -413,8 +437,8 @@ if_next_index(void) } /* switch to the new tables and size */ - ifnet_addrs = (struct ifaddr **)new_ifnet_addrs; - ifindex2ifnet = (struct ifnet **)new_ifindex2ifnet; + ifnet_addrs = (struct ifaddr **)(void *)new_ifnet_addrs; + ifindex2ifnet = (struct ifnet **)(void *)new_ifindex2ifnet; if_indexlim = new_if_indexlim; /* release the old data */ @@ -546,7 +570,7 @@ if_clone_lookup(const char *name, u_int32_t *unitp) { struct if_clone *ifc; const char *cp; - size_t i; + u_int32_t i; for (ifc = LIST_FIRST(&if_cloners); ifc != NULL;) { for (cp = name, i = 0; i < ifc->ifc_namelen; i++, cp++) { @@ -563,7 +587,7 @@ if_clone_lookup(const char *name, u_int32_t *unitp) found_name: if (*cp == '\0') { - i = 0xffff; + i = UINT32_MAX; } else { for (i = 0; *cp != '\0'; cp++) { if (*cp < '0' || *cp > '9') { @@ -604,7 +628,6 @@ if_clone_attach(struct if_clone *ifc) ifc->ifc_units = _MALLOC(len, M_CLONE, M_WAITOK | M_ZERO); if (ifc->ifc_units == NULL) return ENOBUFS; - bzero(ifc->ifc_units, len); ifc->ifc_bmlen = len; LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list); @@ -631,24 +654,22 @@ if_clone_attach(struct if_clone *ifc) void if_clone_detach(struct if_clone *ifc) { - LIST_REMOVE(ifc, ifc_list); FREE(ifc->ifc_units, M_CLONE); if_cloners_count--; } -#if IF_CLONE_LIST /* * Provide list of interface cloners to userspace. */ static int -if_clone_list(int count, int * total, user_addr_t dst) +if_clone_list(int count, int *ret_total, user_addr_t dst) { char outbuf[IFNAMSIZ]; struct if_clone *ifc; int error = 0; - *total = if_cloners_count; + *ret_total = if_cloners_count; if (dst == USER_ADDR_NULL) { /* Just asking how many there are. */ return (0); @@ -669,7 +690,28 @@ if_clone_list(int count, int * total, user_addr_t dst) return (error); } -#endif /* IF_CLONE_LIST */ + +u_int32_t +if_functional_type(struct ifnet *ifp) +{ + u_int32_t ret = IFRTYPE_FUNCTIONAL_UNKNOWN; + if (ifp != NULL) { + if (ifp->if_flags & IFF_LOOPBACK) { + ret = IFRTYPE_FUNCTIONAL_LOOPBACK; + } else if (IFNET_IS_WIFI(ifp)) { + if (ifp->if_eflags & IFEF_AWDL) + ret = IFRTYPE_FUNCTIONAL_WIFI_AWDL; + else + ret = IFRTYPE_FUNCTIONAL_WIFI_INFRA; + } else if (IFNET_IS_CELLULAR(ifp)) { + ret = IFRTYPE_FUNCTIONAL_CELLULAR; + } else if (IFNET_IS_WIRED(ifp)) { + ret = IFRTYPE_FUNCTIONAL_WIRED; + } + } + + return ret; +} /* * Similar to ifa_ifwithaddr, except that this is IPv4 specific @@ -951,7 +993,8 @@ ifa_ifwithnet_common(const struct sockaddr *addr, unsigned int ifscope) * so do that if we can. */ if (af == AF_LINK) { - const struct sockaddr_dl *sdl = (const struct sockaddr_dl *)addr; + const struct sockaddr_dl *sdl = + (const struct sockaddr_dl *)(uintptr_t)(size_t)addr; if (sdl->sdl_index && sdl->sdl_index <= if_index) { ifa = ifnet_addrs[sdl->sdl_index - 1]; if (ifa != NULL) @@ -979,81 +1022,52 @@ next: IFA_UNLOCK(ifa); continue; } -#ifndef __APPLE__ -/* This breaks tunneling application trying to install a route with - * a specific subnet and the local address as the destination - * It's breaks binary compatibility with previous version of MacOS X - */ - if ( -#if INET6 /* XXX: for maching gif tunnel dst as routing entry gateway */ - addr->sa_family != AF_INET6 && -#endif - ifp->if_flags & IFF_POINTOPOINT) { - /* - * This is a bit broken as it doesn't - * take into account that the remote end may - * be a single node in the network we are - * looking for. - * The trouble is that we don't know the - * netmask for the remote end. - */ - if (ifa->ifa_dstaddr != 0 && - equal(addr, ifa->ifa_dstaddr)) { - IFA_ADDREF_LOCKED(ifa); - IFA_UNLOCK(ifa); - break; - } + /* + * If we're looking up with a scope, + * find using a matching interface. + */ + if (ifscope != IFSCOPE_NONE && + ifp->if_index != ifscope) { IFA_UNLOCK(ifa); - } else -#endif /* __APPLE__*/ - { - /* - * If we're looking up with a scope, - * find using a matching interface. - */ - if (ifscope != IFSCOPE_NONE && - ifp->if_index != ifscope) { - IFA_UNLOCK(ifa); - continue; - } + continue; + } - /* - * Scan all the bits in the ifa's address. - * If a bit dissagrees with what we are - * looking for, mask it with the netmask - * to see if it really matters. - * (A byte at a time) - */ - if (ifa->ifa_netmask == 0) { - IFA_UNLOCK(ifa); - continue; - } - cp = addr_data; - cp2 = ifa->ifa_addr->sa_data; - cp3 = ifa->ifa_netmask->sa_data; - cplim = ifa->ifa_netmask->sa_len - + (char *)ifa->ifa_netmask; - while (cp3 < cplim) - if ((*cp++ ^ *cp2++) & *cp3++) - goto next; /* next address! */ - /* - * If the netmask of what we just found - * is more specific than what we had before - * (if we had one) then remember the new one - * before continuing to search - * for an even better one. - */ - if (ifa_maybe == NULL || - rn_refines((caddr_t)ifa->ifa_netmask, - (caddr_t)ifa_maybe->ifa_netmask)) { - IFA_ADDREF_LOCKED(ifa); /* ifa_maybe */ - IFA_UNLOCK(ifa); - if (ifa_maybe != NULL) - IFA_REMREF(ifa_maybe); - ifa_maybe = ifa; - } else { - IFA_UNLOCK(ifa); - } + /* + * Scan all the bits in the ifa's address. + * If a bit dissagrees with what we are + * looking for, mask it with the netmask + * to see if it really matters. + * (A byte at a time) + */ + if (ifa->ifa_netmask == 0) { + IFA_UNLOCK(ifa); + continue; + } + cp = addr_data; + cp2 = ifa->ifa_addr->sa_data; + cp3 = ifa->ifa_netmask->sa_data; + cplim = ifa->ifa_netmask->sa_len + + (char *)ifa->ifa_netmask; + while (cp3 < cplim) + if ((*cp++ ^ *cp2++) & *cp3++) + goto next; /* next address! */ + /* + * If the netmask of what we just found + * is more specific than what we had before + * (if we had one) then remember the new one + * before continuing to search + * for an even better one. + */ + if (ifa_maybe == NULL || + rn_refines((caddr_t)ifa->ifa_netmask, + (caddr_t)ifa_maybe->ifa_netmask)) { + IFA_ADDREF_LOCKED(ifa); /* ifa_maybe */ + IFA_UNLOCK(ifa); + if (ifa_maybe != NULL) + IFA_REMREF(ifa_maybe); + ifa_maybe = ifa; + } else { + IFA_UNLOCK(ifa); } IFA_LOCK_ASSERT_NOTHELD(ifa); } @@ -1220,6 +1234,7 @@ if_updown( int i; struct ifaddr **ifa; struct timespec tv; + struct ifclassq *ifq = &ifp->if_snd; /* Wait until no one else is changing the up/down state */ while ((ifp->if_eflags & IFEF_UPDOWNCHANGE) != 0) { @@ -1229,16 +1244,16 @@ if_updown( msleep(&ifp->if_eflags, NULL, 0, "if_updown", &tv); ifnet_lock_exclusive(ifp); } - + /* Verify that the interface isn't already in the right state */ if ((!up && (ifp->if_flags & IFF_UP) == 0) || (up && (ifp->if_flags & IFF_UP) == IFF_UP)) { return; } - + /* Indicate that the up/down state is changing */ ifp->if_eflags |= IFEF_UPDOWNCHANGE; - + /* Mark interface up or down */ if (up) { ifp->if_flags |= IFF_UP; @@ -1246,9 +1261,9 @@ if_updown( else { ifp->if_flags &= ~IFF_UP; } - + ifnet_touch_lastchange(ifp); - + /* Drop the lock to notify addresses and route */ ifnet_lock_done(ifp); if (ifnet_get_address_list(ifp, &ifa) == 0) { @@ -1258,15 +1273,19 @@ if_updown( ifnet_free_address_list(ifa); } rt_ifmsg(ifp); - - /* Aquire the lock to clear the changing flag and flush the send queue */ - ifnet_lock_exclusive(ifp); + if (!up) - if_qflush(&ifp->if_snd); + if_qflush(ifp, 0); + + /* Inform all transmit queues about the new link state */ + IFCQ_LOCK(ifq); + ifnet_update_sndq(ifq, up ? CLASSQ_EV_LINK_UP : CLASSQ_EV_LINK_DOWN); + IFCQ_UNLOCK(ifq); + + /* Aquire the lock to clear the changing flag */ + ifnet_lock_exclusive(ifp); ifp->if_eflags &= ~IFEF_UPDOWNCHANGE; wakeup(&ifp->if_eflags); - - return; } /* @@ -1298,19 +1317,61 @@ if_up( /* * Flush an interface queue. */ -static void -if_qflush(struct ifqueue *ifq) +void +if_qflush(struct ifnet *ifp, int ifq_locked) { - struct mbuf *m, *n; + struct ifclassq *ifq = &ifp->if_snd; + + if (!ifq_locked) + IFCQ_LOCK(ifq); + + if (IFCQ_IS_ENABLED(ifq)) + IFCQ_PURGE(ifq); +#if PF_ALTQ + if (IFCQ_IS_DRAINING(ifq)) + ifq->ifcq_drain = 0; + if (ALTQ_IS_ENABLED(IFCQ_ALTQ(ifq))) + ALTQ_PURGE(IFCQ_ALTQ(ifq)); +#endif /* PF_ALTQ */ + + VERIFY(IFCQ_IS_EMPTY(ifq)); - n = ifq->ifq_head; - while ((m = n) != 0) { - n = m->m_act; - m_freem(m); + if (!ifq_locked) + IFCQ_UNLOCK(ifq); +} + +void +if_qflush_sc(struct ifnet *ifp, mbuf_svc_class_t sc, u_int32_t flow, + u_int32_t *packets, u_int32_t *bytes, int ifq_locked) +{ + struct ifclassq *ifq = &ifp->if_snd; + u_int32_t cnt = 0, len = 0; + u_int32_t a_cnt = 0, a_len = 0; + + VERIFY(sc == MBUF_SC_UNSPEC || MBUF_VALID_SC(sc)); + VERIFY(flow != 0); + + if (!ifq_locked) + IFCQ_LOCK(ifq); + + if (IFCQ_IS_ENABLED(ifq)) + IFCQ_PURGE_SC(ifq, sc, flow, cnt, len); +#if PF_ALTQ + if (IFCQ_IS_DRAINING(ifq)) { + VERIFY((signed)(ifq->ifcq_drain - cnt) >= 0); + ifq->ifcq_drain -= cnt; } - ifq->ifq_head = NULL; - ifq->ifq_tail = NULL; - ifq->ifq_len = 0; + if (ALTQ_IS_ENABLED(IFCQ_ALTQ(ifq))) + ALTQ_PURGE_SC(IFCQ_ALTQ(ifq), sc, flow, a_cnt, a_len); +#endif /* PF_ALTQ */ + + if (!ifq_locked) + IFCQ_UNLOCK(ifq); + + if (packets != NULL) + *packets = cnt + a_cnt; + if (bytes != NULL) + *bytes = len + a_len; } /* @@ -1371,7 +1432,7 @@ struct ifnet * if_withname(struct sockaddr *sa) { char ifname[IFNAMSIZ+1]; - struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa; + struct sockaddr_dl *sdl = (struct sockaddr_dl *)(void *)sa; if ( (sa->sa_family != AF_LINK) || (sdl->sdl_nlen == 0) || (sdl->sdl_nlen > IFNAMSIZ) ) @@ -1389,70 +1450,818 @@ if_withname(struct sockaddr *sa) return (ifunit(ifname)); } +static __attribute__((noinline)) int +ifioctl_ifconf(u_long cmd, caddr_t data) +{ + int error = 0; + + switch (cmd) { + case OSIOCGIFCONF32: /* struct ifconf32 */ + case SIOCGIFCONF32: { /* struct ifconf32 */ + struct ifconf32 ifc; + bcopy(data, &ifc, sizeof (ifc)); + error = ifconf(cmd, CAST_USER_ADDR_T(ifc.ifc_req), + &ifc.ifc_len); + bcopy(&ifc, data, sizeof (ifc)); + break; + } + + case SIOCGIFCONF64: /* struct ifconf64 */ + case OSIOCGIFCONF64: { /* struct ifconf64 */ + struct ifconf64 ifc; + bcopy(data, &ifc, sizeof (ifc)); + error = ifconf(cmd, ifc.ifc_req, &ifc.ifc_len); + bcopy(&ifc, data, sizeof (ifc)); + break; + } + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +static __attribute__((noinline)) int +ifioctl_ifclone(u_long cmd, caddr_t data) +{ + int error = 0; + + switch (cmd) { + case SIOCIFGCLONERS32: { /* struct if_clonereq32 */ + struct if_clonereq32 ifcr; + bcopy(data, &ifcr, sizeof (ifcr)); + error = if_clone_list(ifcr.ifcr_count, &ifcr.ifcr_total, + CAST_USER_ADDR_T(ifcr.ifcru_buffer)); + bcopy(&ifcr, data, sizeof (ifcr)); + break; + } + + case SIOCIFGCLONERS64: { /* struct if_clonereq64 */ + struct if_clonereq64 ifcr; + bcopy(data, &ifcr, sizeof (ifcr)); + error = if_clone_list(ifcr.ifcr_count, &ifcr.ifcr_total, + ifcr.ifcru_buffer); + bcopy(&ifcr, data, sizeof (ifcr)); + break; + } + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +static __attribute__((noinline)) int +ifioctl_ifdesc(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) +{ + struct if_descreq *ifdr = (struct if_descreq *)(void *)data; + u_int32_t ifdr_len; + int error = 0; + + VERIFY(ifp != NULL); + + switch (cmd) { + case SIOCSIFDESC: { /* struct if_descreq */ + if ((error = proc_suser(p)) != 0) + break; + + ifnet_lock_exclusive(ifp); + bcopy(&ifdr->ifdr_len, &ifdr_len, sizeof (ifdr_len)); + if (ifdr_len > sizeof (ifdr->ifdr_desc) || + ifdr_len > ifp->if_desc.ifd_maxlen) { + error = EINVAL; + ifnet_lock_done(ifp); + break; + } + + bzero(ifp->if_desc.ifd_desc, ifp->if_desc.ifd_maxlen); + if ((ifp->if_desc.ifd_len = ifdr_len) > 0) { + bcopy(ifdr->ifdr_desc, ifp->if_desc.ifd_desc, + MIN(ifdr_len, ifp->if_desc.ifd_maxlen)); + } + ifnet_lock_done(ifp); + break; + } + + case SIOCGIFDESC: { /* struct if_descreq */ + ifnet_lock_shared(ifp); + ifdr_len = MIN(ifp->if_desc.ifd_len, sizeof (ifdr->ifdr_desc)); + bcopy(&ifdr_len, &ifdr->ifdr_len, sizeof (ifdr_len)); + bzero(&ifdr->ifdr_desc, sizeof (ifdr->ifdr_desc)); + if (ifdr_len > 0) { + bcopy(ifp->if_desc.ifd_desc, ifdr->ifdr_desc, ifdr_len); + } + ifnet_lock_done(ifp); + break; + } + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +static __attribute__((noinline)) int +ifioctl_linkparams(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) +{ + struct if_linkparamsreq *iflpr = + (struct if_linkparamsreq *)(void *)data; + struct ifclassq *ifq; + int error = 0; + + VERIFY(ifp != NULL); + ifq = &ifp->if_snd; + + switch (cmd) { + case SIOCSIFLINKPARAMS: { /* struct if_linkparamsreq */ + struct tb_profile tb = { 0, 0, 0 }; + + if ((error = proc_suser(p)) != 0) + break; + + IFCQ_LOCK(ifq); + if (!IFCQ_IS_READY(ifq)) { + error = ENXIO; + IFCQ_UNLOCK(ifq); + break; + } + bcopy(&iflpr->iflpr_output_tbr_rate, &tb.rate, + sizeof (tb.rate)); + bcopy(&iflpr->iflpr_output_tbr_percent, &tb.percent, + sizeof (tb.percent)); + error = ifclassq_tbr_set(ifq, &tb, TRUE); + IFCQ_UNLOCK(ifq); + break; + } + + case SIOCGIFLINKPARAMS: { /* struct if_linkparamsreq */ + u_int32_t sched_type = PKTSCHEDT_NONE, flags = 0; + u_int64_t tbr_bw = 0, tbr_pct = 0; + + IFCQ_LOCK(ifq); +#if PF_ALTQ + if (ALTQ_IS_ENABLED(IFCQ_ALTQ(ifq))) { + sched_type = IFCQ_ALTQ(ifq)->altq_type; + flags |= IFLPRF_ALTQ; + } else +#endif /* PF_ALTQ */ + { + if (IFCQ_IS_ENABLED(ifq)) + sched_type = ifq->ifcq_type; + } + bcopy(&sched_type, &iflpr->iflpr_output_sched, + sizeof (iflpr->iflpr_output_sched)); + + if (IFCQ_TBR_IS_ENABLED(ifq)) { + tbr_bw = ifq->ifcq_tbr.tbr_rate_raw; + tbr_pct = ifq->ifcq_tbr.tbr_percent; + } + bcopy(&tbr_bw, &iflpr->iflpr_output_tbr_rate, + sizeof (iflpr->iflpr_output_tbr_rate)); + bcopy(&tbr_pct, &iflpr->iflpr_output_tbr_percent, + sizeof (iflpr->iflpr_output_tbr_percent)); + IFCQ_UNLOCK(ifq); + + if (ifp->if_output_sched_model == + IFNET_SCHED_MODEL_DRIVER_MANAGED) + flags |= IFLPRF_DRVMANAGED; + bcopy(&flags, &iflpr->iflpr_flags, sizeof (iflpr->iflpr_flags)); + bcopy(&ifp->if_output_bw, &iflpr->iflpr_output_bw, + sizeof (iflpr->iflpr_output_bw)); + bcopy(&ifp->if_input_bw, &iflpr->iflpr_input_bw, + sizeof (iflpr->iflpr_input_bw)); + bcopy(&ifp->if_output_lt, &iflpr->iflpr_output_lt, + sizeof (iflpr->iflpr_output_lt)); + bcopy(&ifp->if_input_lt, &iflpr->iflpr_input_lt, + sizeof (iflpr->iflpr_input_lt)); + break; + } + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +static __attribute__((noinline)) int +ifioctl_qstats(struct ifnet *ifp, u_long cmd, caddr_t data) +{ + struct if_qstatsreq *ifqr = (struct if_qstatsreq *)(void *)data; + u_int32_t ifqr_len, ifqr_slot; + int error = 0; + + VERIFY(ifp != NULL); + + switch (cmd) { + case SIOCGIFQUEUESTATS: { /* struct if_qstatsreq */ + bcopy(&ifqr->ifqr_slot, &ifqr_slot, sizeof (ifqr_slot)); + bcopy(&ifqr->ifqr_len, &ifqr_len, sizeof (ifqr_len)); + error = ifclassq_getqstats(&ifp->if_snd, ifqr_slot, + ifqr->ifqr_buf, &ifqr_len); + if (error != 0) + ifqr_len = 0; + bcopy(&ifqr_len, &ifqr->ifqr_len, sizeof (ifqr_len)); + break; + } + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +static __attribute__((noinline)) int +ifioctl_throttle(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) +{ + struct if_throttlereq *ifthr = (struct if_throttlereq *)(void *)data; + u_int32_t ifthr_level; + int error = 0; + + VERIFY(ifp != NULL); + + switch (cmd) { + case SIOCSIFTHROTTLE: { /* struct if_throttlereq */ + /* + * XXX: Use priv_check_cred() instead of root check? + */ + if ((error = proc_suser(p)) != 0) + break; + + bcopy(&ifthr->ifthr_level, &ifthr_level, sizeof (ifthr_level)); + error = ifnet_set_throttle(ifp, ifthr_level); + if (error == EALREADY) + error = 0; + break; + } + + case SIOCGIFTHROTTLE: { /* struct if_throttlereq */ + if ((error = ifnet_get_throttle(ifp, &ifthr_level)) == 0) { + bcopy(&ifthr_level, &ifthr->ifthr_level, + sizeof (ifthr_level)); + } + break; + } + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +static int +ifioctl_getnetagents(struct ifnet *ifp, u_int32_t *count, user_addr_t uuid_p) +{ + int error = 0; + int index = 0; + u_int32_t valid_netagent_count = 0; + *count = 0; + for (index = 0; index < IF_MAXAGENTS; index++) { + uuid_t *netagent_uuid = &(ifp->if_agentids[index]); + if (!uuid_is_null(*netagent_uuid)) { + if (uuid_p != USER_ADDR_NULL) { + if ((error = copyout(netagent_uuid, + uuid_p + sizeof(uuid_t) * valid_netagent_count, + sizeof(uuid_t))) != 0) { + return (error); + } + } + valid_netagent_count++; + } + } + *count = valid_netagent_count; + + return (0); +} + +static __attribute__((noinline)) int +ifioctl_netagent(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) +{ + struct if_agentidreq *ifar = (struct if_agentidreq *)(void *)data; + union { + struct if_agentidsreq32 s32; + struct if_agentidsreq64 s64; + } u; + int error = 0; + int index = 0; + + VERIFY(ifp != NULL); + + switch (cmd) { + case SIOCAIFAGENTID: { /* struct if_agentidreq */ + uuid_t *first_empty_slot = NULL; + // TODO: Use priv_check_cred() instead of root check + if ((error = proc_suser(p)) != 0) { + break; + } + for (index = 0; index < IF_MAXAGENTS; index++) { + uuid_t *netagent_uuid = &(ifp->if_agentids[index]); + if (uuid_compare(*netagent_uuid, ifar->ifar_uuid) == 0) { + /* Already present, ignore */ + break; + } + if (first_empty_slot == NULL && + uuid_is_null(*netagent_uuid)) { + first_empty_slot = netagent_uuid; + } + } + if (first_empty_slot == NULL) { + error = ENOMEM; /* No empty slot for a netagent UUID, bail */ + break; + } + uuid_copy(*first_empty_slot, ifar->ifar_uuid); + netagent_post_updated_interfaces(ifar->ifar_uuid); + break; + } + case SIOCDIFAGENTID: { /* struct if_agentidreq */ + bool removed_agent_id = FALSE; + // TODO: Use priv_check_cred() instead of root check + if ((error = proc_suser(p)) != 0) { + break; + } + for (index = 0; index < IF_MAXAGENTS; index++) { + uuid_t *netagent_uuid = &(ifp->if_agentids[index]); + if (uuid_compare(*netagent_uuid, ifar->ifar_uuid) == 0) { + uuid_clear(*netagent_uuid); + removed_agent_id = TRUE; + break; + } + } + if (removed_agent_id) { + netagent_post_updated_interfaces(ifar->ifar_uuid); + } + break; + } + case SIOCGIFAGENTIDS32: { /* struct if_agentidsreq32 */ + bcopy(data, &u.s32, sizeof(u.s32)); + error = ifioctl_getnetagents(ifp, &u.s32.ifar_count, u.s32.ifar_uuids); + if (error == 0) { + bcopy(&u.s32, data, sizeof(u.s32)); + } + break; + } + case SIOCGIFAGENTIDS64: { /* struct if_agentidsreq64 */ + bcopy(data, &u.s64, sizeof(u.s64)); + error = ifioctl_getnetagents(ifp, &u.s64.ifar_count, u.s64.ifar_uuids); + if (error == 0) { + bcopy(&u.s64, data, sizeof(u.s64)); + } + break; + } + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} + +void +ifnet_clear_netagent(uuid_t netagent_uuid) +{ + struct ifnet *ifp = NULL; + int index = 0; + bool removed_agent_id = FALSE; + + ifnet_head_lock_shared(); + + TAILQ_FOREACH(ifp, &ifnet_head, if_link) { + for (index = 0; index < IF_MAXAGENTS; index++) { + uuid_t *ifp_netagent_uuid = &(ifp->if_agentids[index]); + if (uuid_compare(*ifp_netagent_uuid, netagent_uuid) == 0) { + uuid_clear(*ifp_netagent_uuid); + removed_agent_id = TRUE; + } + } + } + + ifnet_head_done(); +} + +static __attribute__((noinline)) int +ifioctl_netsignature(struct ifnet *ifp, u_long cmd, caddr_t data) +{ + struct if_nsreq *ifnsr = (struct if_nsreq *)(void *)data; + u_int16_t flags; + int error = 0; + + VERIFY(ifp != NULL); + + switch (cmd) { + case SIOCSIFNETSIGNATURE: /* struct if_nsreq */ + if (ifnsr->ifnsr_len > sizeof (ifnsr->ifnsr_data)) { + error = EINVAL; + break; + } + bcopy(&ifnsr->ifnsr_flags, &flags, sizeof (flags)); + error = ifnet_set_netsignature(ifp, ifnsr->ifnsr_family, + ifnsr->ifnsr_len, flags, ifnsr->ifnsr_data); + break; + + case SIOCGIFNETSIGNATURE: /* struct if_nsreq */ + ifnsr->ifnsr_len = sizeof (ifnsr->ifnsr_data); + error = ifnet_get_netsignature(ifp, ifnsr->ifnsr_family, + &ifnsr->ifnsr_len, &flags, ifnsr->ifnsr_data); + if (error == 0) + bcopy(&flags, &ifnsr->ifnsr_flags, sizeof (flags)); + else + ifnsr->ifnsr_len = 0; + break; + + default: + VERIFY(0); + /* NOTREACHED */ + } + + return (error); +} /* * Interface ioctls. + * + * Most of the routines called to handle the ioctls would end up being + * tail-call optimized, which unfortunately causes this routine to + * consume too much stack space; this is the reason for the "noinline" + * attribute used on those routines. */ int ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) { - struct ifnet *ifp; - struct ifreq *ifr; - struct ifstat *ifs; + char ifname[IFNAMSIZ + 1]; + struct ifnet *ifp = NULL; + struct ifstat *ifs = NULL; int error = 0; - short oif_flags; - struct kev_msg ev_msg; - struct net_event_data ev_data; - bzero(&ev_data, sizeof(struct net_event_data)); - bzero(&ev_msg, sizeof(struct kev_msg)); + bzero(ifname, sizeof (ifname)); + + /* + * ioctls which don't require ifp, or ifreq ioctls + */ switch (cmd) { - case OSIOCGIFCONF32: - case SIOCGIFCONF32: { - struct ifconf32 *ifc = (struct ifconf32 *)data; - return (ifconf(cmd, CAST_USER_ADDR_T(ifc->ifc_req), - &ifc->ifc_len)); - /* NOTREACHED */ + case OSIOCGIFCONF32: /* struct ifconf32 */ + case SIOCGIFCONF32: /* struct ifconf32 */ + case SIOCGIFCONF64: /* struct ifconf64 */ + case OSIOCGIFCONF64: /* struct ifconf64 */ + error = ifioctl_ifconf(cmd, data); + goto done; + + case SIOCIFGCLONERS32: /* struct if_clonereq32 */ + case SIOCIFGCLONERS64: /* struct if_clonereq64 */ + error = ifioctl_ifclone(cmd, data); + goto done; + + case SIOCGIFAGENTDATA32: /* struct netagent_req32 */ + case SIOCGIFAGENTDATA64: /* struct netagent_req64 */ + error = netagent_ioctl(cmd, data); + goto done; + + case SIOCSIFDSTADDR: /* struct ifreq */ + case SIOCSIFADDR: /* struct ifreq */ + case SIOCSIFBRDADDR: /* struct ifreq */ + case SIOCSIFNETMASK: /* struct ifreq */ + case OSIOCGIFADDR: /* struct ifreq */ + case OSIOCGIFDSTADDR: /* struct ifreq */ + case OSIOCGIFBRDADDR: /* struct ifreq */ + case OSIOCGIFNETMASK: /* struct ifreq */ + case SIOCSIFKPI: /* struct ifreq */ + if (so->so_proto == NULL) { + error = EOPNOTSUPP; + goto done; + } + /* FALLTHRU */ + case SIOCIFCREATE: /* struct ifreq */ + case SIOCIFCREATE2: /* struct ifreq */ + case SIOCIFDESTROY: /* struct ifreq */ + case SIOCGIFFLAGS: /* struct ifreq */ + case SIOCGIFEFLAGS: /* struct ifreq */ + case SIOCGIFCAP: /* struct ifreq */ +#if CONFIG_MACF_NET + case SIOCGIFMAC: /* struct ifreq */ + case SIOCSIFMAC: /* struct ifreq */ +#endif /* CONFIG_MACF_NET */ + case SIOCGIFMETRIC: /* struct ifreq */ + case SIOCGIFMTU: /* struct ifreq */ + case SIOCGIFPHYS: /* struct ifreq */ + case SIOCSIFFLAGS: /* struct ifreq */ + case SIOCSIFCAP: /* struct ifreq */ + case SIOCSIFMETRIC: /* struct ifreq */ + case SIOCSIFPHYS: /* struct ifreq */ + case SIOCSIFMTU: /* struct ifreq */ + case SIOCADDMULTI: /* struct ifreq */ + case SIOCDELMULTI: /* struct ifreq */ + case SIOCDIFPHYADDR: /* struct ifreq */ + case SIOCSIFMEDIA: /* struct ifreq */ + case SIOCSIFGENERIC: /* struct ifreq */ + case SIOCSIFLLADDR: /* struct ifreq */ + case SIOCSIFALTMTU: /* struct ifreq */ + case SIOCSIFVLAN: /* struct ifreq */ + case SIOCSIFBOND: /* struct ifreq */ + case SIOCGIFLLADDR: /* struct ifreq */ + case SIOCGIFTYPE: /* struct ifreq */ + case SIOCGIFFUNCTIONALTYPE: /* struct ifreq */ + case SIOCGIFPSRCADDR: /* struct ifreq */ + case SIOCGIFPDSTADDR: /* struct ifreq */ + case SIOCGIFGENERIC: /* struct ifreq */ + case SIOCGIFDEVMTU: /* struct ifreq */ + case SIOCGIFVLAN: /* struct ifreq */ + case SIOCGIFBOND: /* struct ifreq */ + case SIOCGIFWAKEFLAGS: /* struct ifreq */ + case SIOCGIFGETRTREFCNT: /* struct ifreq */ + case SIOCSIFOPPORTUNISTIC: /* struct ifreq */ + case SIOCGIFOPPORTUNISTIC: /* struct ifreq */ + case SIOCGIFLINKQUALITYMETRIC: /* struct ifreq */ + case SIOCSIFLOG: /* struct ifreq */ + case SIOCGIFLOG: /* struct ifreq */ + case SIOCGIFDELEGATE: /* struct ifreq */ + case SIOCGIFEXPENSIVE: /* struct ifreq */ + case SIOCSIFEXPENSIVE: /* struct ifreq */ + case SIOCSIF2KCL: /* struct ifreq */ + case SIOCGIF2KCL: /* struct ifreq */ + case SIOCSIFINTERFACESTATE: /* struct ifreq */ + case SIOCGIFINTERFACESTATE: /* struct ifreq */ + case SIOCSIFPROBECONNECTIVITY: /* struct ifreq */ + case SIOCGIFPROBECONNECTIVITY: /* struct ifreq */ + case SIOCGSTARTDELAY: /* struct ifreq */ + case SIOCGECNMODE: /* struct ifreq */ + case SIOCSECNMODE: { /* struct ifreq */ + struct ifreq ifr; + bcopy(data, &ifr, sizeof (ifr)); + ifr.ifr_name[IFNAMSIZ - 1] = '\0'; + bcopy(&ifr.ifr_name, ifname, IFNAMSIZ); + error = ifioctl_ifreq(so, cmd, &ifr, p); + bcopy(&ifr, data, sizeof (ifr)); + goto done; } - case SIOCGIFCONF64: - case OSIOCGIFCONF64: { - struct ifconf64 *ifc = (struct ifconf64 *)data; - return (ifconf(cmd, ifc->ifc_req, &ifc->ifc_len)); - /* NOTREACHED */ } + + /* + * ioctls which require ifp. Note that we acquire dlil_ifnet_lock + * here to ensure that the ifnet, if found, has been fully attached. + */ + dlil_if_lock(); + switch (cmd) { + case SIOCSIFPHYADDR: /* struct {if,in_}aliasreq */ + bcopy(((struct in_aliasreq *)(void *)data)->ifra_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + +#if INET6 + case SIOCSIFPHYADDR_IN6_32: /* struct in6_aliasreq_32 */ + bcopy(((struct in6_aliasreq_32 *)(void *)data)->ifra_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCSIFPHYADDR_IN6_64: /* struct in6_aliasreq_64 */ + bcopy(((struct in6_aliasreq_64 *)(void *)data)->ifra_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; +#endif /* INET6 */ + + case SIOCGIFSTATUS: /* struct ifstat */ + ifs = _MALLOC(sizeof (*ifs), M_DEVBUF, M_WAITOK); + if (ifs == NULL) { + error = ENOMEM; + dlil_if_unlock(); + goto done; + } + bcopy(data, ifs, sizeof (*ifs)); + ifs->ifs_name[IFNAMSIZ - 1] = '\0'; + bcopy(ifs->ifs_name, ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCGIFMEDIA32: /* struct ifmediareq32 */ + bcopy(((struct ifmediareq32 *)(void *)data)->ifm_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCGIFMEDIA64: /* struct ifmediareq64 */ + bcopy(((struct ifmediareq64 *)(void *)data)->ifm_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCSIFDESC: /* struct if_descreq */ + case SIOCGIFDESC: /* struct if_descreq */ + bcopy(((struct if_descreq *)(void *)data)->ifdr_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCSIFLINKPARAMS: /* struct if_linkparamsreq */ + case SIOCGIFLINKPARAMS: /* struct if_linkparamsreq */ + bcopy(((struct if_linkparamsreq *)(void *)data)->iflpr_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCGIFQUEUESTATS: /* struct if_qstatsreq */ + bcopy(((struct if_qstatsreq *)(void *)data)->ifqr_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCSIFTHROTTLE: /* struct if_throttlereq */ + case SIOCGIFTHROTTLE: /* struct if_throttlereq */ + bcopy(((struct if_throttlereq *)(void *)data)->ifthr_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCAIFAGENTID: /* struct if_agentidreq */ + case SIOCDIFAGENTID: /* struct if_agentidreq */ + case SIOCGIFAGENTIDS32: /* struct if_agentidsreq32 */ + case SIOCGIFAGENTIDS64: /* struct if_agentidsreq64 */ + bcopy(((struct if_agentidreq *)(void *)data)->ifar_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + case SIOCSIFNETSIGNATURE: /* struct if_nsreq */ + case SIOCGIFNETSIGNATURE: /* struct if_nsreq */ + bcopy(((struct if_nsreq *)(void *)data)->ifnsr_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; + + default: + /* + * This is a bad assumption, but the code seems to + * have been doing this in the past; caveat emptor. + */ + bcopy(((struct ifreq *)(void *)data)->ifr_name, + ifname, IFNAMSIZ); + ifp = ifunit(ifname); + break; } - ifr = (struct ifreq *)data; + dlil_if_unlock(); + + if (ifp == NULL) { + error = ENXIO; + goto done; + } + + switch (cmd) { + case SIOCSIFPHYADDR: /* struct {if,in_}aliasreq */ +#if INET6 + case SIOCSIFPHYADDR_IN6_32: /* struct in6_aliasreq_32 */ + case SIOCSIFPHYADDR_IN6_64: /* struct in6_aliasreq_64 */ +#endif /* INET6 */ + error = proc_suser(p); + if (error != 0) + break; + + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, data); + if (error != 0) + break; + + ifnet_touch_lastchange(ifp); + break; + + case SIOCGIFSTATUS: /* struct ifstat */ + VERIFY(ifs != NULL); + ifs->ascii[0] = '\0'; + + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifs); + + bcopy(ifs, data, sizeof (*ifs)); + break; + + case SIOCGIFMEDIA32: /* struct ifmediareq32 */ + case SIOCGIFMEDIA64: /* struct ifmediareq64 */ + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, data); + break; + + case SIOCSIFDESC: /* struct if_descreq */ + case SIOCGIFDESC: /* struct if_descreq */ + error = ifioctl_ifdesc(ifp, cmd, data, p); + break; + + case SIOCSIFLINKPARAMS: /* struct if_linkparamsreq */ + case SIOCGIFLINKPARAMS: /* struct if_linkparamsreq */ + error = ifioctl_linkparams(ifp, cmd, data, p); + break; + + case SIOCGIFQUEUESTATS: /* struct if_qstatsreq */ + error = ifioctl_qstats(ifp, cmd, data); + break; + + case SIOCSIFTHROTTLE: /* struct if_throttlereq */ + case SIOCGIFTHROTTLE: /* struct if_throttlereq */ + error = ifioctl_throttle(ifp, cmd, data, p); + break; + + case SIOCAIFAGENTID: /* struct if_agentidreq */ + case SIOCDIFAGENTID: /* struct if_agentidreq */ + case SIOCGIFAGENTIDS32: /* struct if_agentidsreq32 */ + case SIOCGIFAGENTIDS64: /* struct if_agentidsreq64 */ + error = ifioctl_netagent(ifp, cmd, data, p); + break; + + case SIOCSIFNETSIGNATURE: /* struct if_nsreq */ + case SIOCGIFNETSIGNATURE: /* struct if_nsreq */ + error = ifioctl_netsignature(ifp, cmd, data); + break; + + default: + if (so->so_proto == NULL) { + error = EOPNOTSUPP; + break; + } + + socket_lock(so, 1); + error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, + data, ifp, p)); + socket_unlock(so, 1); + + if (error == EOPNOTSUPP || error == ENOTSUP) { + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, data); + } + break; + } + +done: + if (ifs != NULL) + _FREE(ifs, M_DEVBUF); + + if (if_verbose) { + if (ifname[0] == '\0') + (void) snprintf(ifname, sizeof (ifname), "%s", + "NULL"); + else if (ifp != NULL) + (void) snprintf(ifname, sizeof (ifname), "%s", + if_name(ifp)); + + if (error != 0) { + printf("%s[%s,%d]: ifp %s cmd 0x%08lx (%c%c [%lu] " + "%c %lu) error %d\n", __func__, + proc_name_address(p), proc_pid(p), + ifname, cmd, (cmd & IOC_IN) ? 'I' : ' ', + (cmd & IOC_OUT) ? 'O' : ' ', IOCPARM_LEN(cmd), + (char)IOCGROUP(cmd), cmd & 0xff, error); + } else if (if_verbose > 1) { + printf("%s[%s,%d]: ifp %s cmd 0x%08lx (%c%c [%lu] " + "%c %lu) OK\n", __func__, + proc_name_address(p), proc_pid(p), + ifname, cmd, (cmd & IOC_IN) ? 'I' : ' ', + (cmd & IOC_OUT) ? 'O' : ' ', IOCPARM_LEN(cmd), + (char)IOCGROUP(cmd), cmd & 0xff); + } + } + + return (error); +} + +static __attribute__((noinline)) int +ifioctl_ifreq(struct socket *so, u_long cmd, struct ifreq *ifr, struct proc *p) +{ + struct ifnet *ifp; + u_long ocmd = cmd; + int error = 0; + struct kev_msg ev_msg; + struct net_event_data ev_data; + + bzero(&ev_data, sizeof (struct net_event_data)); + bzero(&ev_msg, sizeof (struct kev_msg)); + switch (cmd) { case SIOCIFCREATE: case SIOCIFCREATE2: error = proc_suser(p); if (error) return (error); - return if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name), - cmd == SIOCIFCREATE2 ? ifr->ifr_data : NULL); + return (if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name), + cmd == SIOCIFCREATE2 ? ifr->ifr_data : NULL)); case SIOCIFDESTROY: error = proc_suser(p); if (error) return (error); - return if_clone_destroy(ifr->ifr_name); -#if IF_CLONE_LIST - case SIOCIFGCLONERS32: { - struct if_clonereq32 *ifcr = (struct if_clonereq32 *)data; - return (if_clone_list(ifcr->ifcr_count, &ifcr->ifcr_total, - CAST_USER_ADDR_T(ifcr->ifcru_buffer))); - /* NOTREACHED */ - - } - case SIOCIFGCLONERS64: { - struct if_clonereq64 *ifcr = (struct if_clonereq64 *)data; - return (if_clone_list(ifcr->ifcr_count, &ifcr->ifcr_total, - ifcr->ifcru_buffer)); - /* NOTREACHED */ - } -#endif /* IF_CLONE_LIST */ + return (if_clone_destroy(ifr->ifr_name)); } + /* + * ioctls which require ifp. Note that we acquire dlil_ifnet_lock + * here to ensure that the ifnet, if found, has been fully attached. + */ + dlil_if_lock(); ifp = ifunit(ifr->ifr_name); + dlil_if_unlock(); + if (ifp == NULL) return (ENXIO); @@ -1463,6 +2272,12 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) ifnet_lock_done(ifp); break; + case SIOCGIFEFLAGS: + ifnet_lock_shared(ifp); + ifr->ifr_eflags = ifp->if_eflags; + ifnet_lock_done(ifp); + break; + case SIOCGIFCAP: ifnet_lock_shared(ifp); ifr->ifr_reqcap = ifp->if_capabilities; @@ -1474,7 +2289,12 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) case SIOCGIFMAC: error = mac_ifnet_label_get(kauth_cred_get(), ifr, ifp); break; -#endif + + case SIOCSIFMAC: + error = mac_ifnet_label_set(kauth_cred_get(), ifr, ifp); + break; +#endif /* CONFIG_MACF_NET */ + case SIOCGIFMETRIC: ifnet_lock_shared(ifp); ifr->ifr_metric = ifp->if_metric; @@ -1505,8 +2325,7 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) * Note that we intentionally ignore any error from below * for the SIOCSIFFLAGS case. */ - (void) ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); + (void) ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); /* * Send the event even upon error from the driver because @@ -1537,17 +2356,11 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) error = EINVAL; break; } - error = ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); ifnet_touch_lastchange(ifp); break; -#if CONFIG_MACF_NET - case SIOCSIFMAC: - error = mac_ifnet_label_set(kauth_cred_get(), ifr, ifp); - break; -#endif case SIOCSIFMETRIC: error = proc_suser(p); if (error != 0) @@ -1577,8 +2390,7 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) if (error != 0) break; - error = ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); if (error != 0) break; @@ -1598,9 +2410,9 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) ifnet_touch_lastchange(ifp); break; - case SIOCSIFMTU: - { + case SIOCSIFMTU: { u_int32_t oldmtu = ifp->if_mtu; + struct ifclassq *ifq = &ifp->if_snd; error = proc_suser(p); if (error != 0) @@ -1614,8 +2426,7 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) error = EINVAL; break; } - error = ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); if (error != 0) break; @@ -1644,7 +2455,11 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) if_rtmtu_update(ifp); #if INET6 nd6_setmtu(ifp); -#endif +#endif /* INET6 */ + /* Inform all transmit queues about the new MTU */ + IFCQ_LOCK(ifq); + ifnet_update_sndq(ifq, CLASSQ_EV_LINK_MTU); + IFCQ_UNLOCK(ifq); } break; } @@ -1704,13 +2519,7 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) ifnet_touch_lastchange(ifp); break; - case SIOCSIFPHYADDR: case SIOCDIFPHYADDR: -#if INET6 - case SIOCSIFPHYADDR_IN6_32: - case SIOCSIFPHYADDR_IN6_64: -#endif - case SIOCSLIFPHYADDR: case SIOCSIFMEDIA: case SIOCSIFGENERIC: case SIOCSIFLLADDR: @@ -1721,33 +2530,51 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) if (error != 0) break; - error = ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); if (error != 0) break; ifnet_touch_lastchange(ifp); break; - case SIOCGIFSTATUS: - ifs = (struct ifstat *)data; - ifs->ascii[0] = '\0'; + case SIOCGIFLLADDR: { + struct sockaddr_dl *sdl = SDL(ifp->if_lladdr->ifa_addr); + + if (sdl->sdl_alen == 0) { + error = EADDRNOTAVAIL; + break; + } + /* If larger than 14-bytes we'll need another mechanism */ + if (sdl->sdl_alen > sizeof (ifr->ifr_addr.sa_data)) { + error = EMSGSIZE; + break; + } + /* Follow the same convention used by SIOCSIFLLADDR */ + bzero(&ifr->ifr_addr, sizeof (ifr->ifr_addr)); + ifr->ifr_addr.sa_family = AF_LINK; + ifr->ifr_addr.sa_len = sdl->sdl_alen; + error = ifnet_guarded_lladdr_copy_bytes(ifp, + &ifr->ifr_addr.sa_data, sdl->sdl_alen); + break; + } + + case SIOCGIFTYPE: + ifr->ifr_type.ift_type = ifp->if_type; + ifr->ifr_type.ift_family = ifp->if_family; + ifr->ifr_type.ift_subfamily = ifp->if_subfamily; + break; + + case SIOCGIFFUNCTIONALTYPE: + ifr->ifr_functional_type = if_functional_type(ifp); + break; case SIOCGIFPSRCADDR: case SIOCGIFPDSTADDR: - case SIOCGLIFPHYADDR: - case SIOCGIFMEDIA32: - case SIOCGIFMEDIA64: case SIOCGIFGENERIC: case SIOCGIFDEVMTU: - error = ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); - break; - case SIOCGIFVLAN: case SIOCGIFBOND: - error = ifnet_ioctl(ifp, so->so_proto->pr_domain->dom_family, - cmd, data); + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); break; case SIOCGIFWAKEFLAGS: @@ -1762,20 +2589,125 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) ifnet_lock_done(ifp); break; - default: - oif_flags = ifp->if_flags; - if (so->so_proto == NULL) { - error = EOPNOTSUPP; - break; + case SIOCSIFOPPORTUNISTIC: + case SIOCGIFOPPORTUNISTIC: + error = ifnet_getset_opportunistic(ifp, cmd, ifr, p); + break; + + case SIOCGIFLINKQUALITYMETRIC: + ifnet_lock_shared(ifp); + if ((ifp->if_interface_state.valid_bitmask & + IF_INTERFACE_STATE_LQM_STATE_VALID)) + ifr->ifr_link_quality_metric = + ifp->if_interface_state.lqm_state; + else if ((ifp->if_refflags & IFRF_ATTACHED)) { + ifr->ifr_link_quality_metric = + IFNET_LQM_THRESH_UNKNOWN; + } else { + ifr->ifr_link_quality_metric = + IFNET_LQM_THRESH_OFF; + } + ifnet_lock_done(ifp); + break; + + case SIOCSIFLOG: + case SIOCGIFLOG: + error = ifnet_getset_log(ifp, cmd, ifr, p); + break; + + case SIOCGIFDELEGATE: + ifnet_lock_shared(ifp); + ifr->ifr_delegated = ((ifp->if_delegated.ifp != NULL) ? + ifp->if_delegated.ifp->if_index : 0); + ifnet_lock_done(ifp); + break; + + case SIOCGIFEXPENSIVE: + ifnet_lock_shared(ifp); + if (ifp->if_eflags & IFEF_EXPENSIVE) + ifr->ifr_expensive = 1; + else + ifr->ifr_expensive = 0; + ifnet_lock_done(ifp); + break; + + case SIOCSIFEXPENSIVE: + { + struct ifnet *difp; + + if ((error = priv_check_cred(kauth_cred_get(), + PRIV_NET_INTERFACE_CONTROL, 0)) != 0) + return (error); + ifnet_lock_exclusive(ifp); + if (ifr->ifr_expensive) + ifp->if_eflags |= IFEF_EXPENSIVE; + else + ifp->if_eflags &= ~IFEF_EXPENSIVE; + ifnet_lock_done(ifp); + /* + * Update the expensive bit in the delegated interface + * structure. + */ + ifnet_head_lock_shared(); + TAILQ_FOREACH(difp, &ifnet_head, if_link) { + ifnet_lock_exclusive(difp); + if (difp->if_delegated.ifp == ifp) { + difp->if_delegated.expensive = + ifp->if_eflags & IFEF_EXPENSIVE ? 1 : 0; + + } + ifnet_lock_done(difp); } - { - u_long ocmd = cmd; + ifnet_head_done(); + break; + } + + case SIOCGIF2KCL: + ifnet_lock_shared(ifp); + if (ifp->if_eflags & IFEF_2KCL) + ifr->ifr_2kcl = 1; + else + ifr->ifr_2kcl = 0; + ifnet_lock_done(ifp); + break; - switch (cmd) { - case SIOCSIFDSTADDR: - case SIOCSIFADDR: - case SIOCSIFBRDADDR: - case SIOCSIFNETMASK: + case SIOCSIF2KCL: + if ((error = priv_check_cred(kauth_cred_get(), + PRIV_NET_INTERFACE_CONTROL, 0)) != 0) + return (error); + ifnet_lock_exclusive(ifp); + if (ifr->ifr_2kcl) + ifp->if_eflags |= IFEF_2KCL; + else + ifp->if_eflags &= ~IFEF_2KCL; + ifnet_lock_done(ifp); + break; + case SIOCGSTARTDELAY: + ifnet_lock_shared(ifp); + if (ifp->if_eflags & IFEF_ENQUEUE_MULTI) { + ifr->ifr_start_delay_qlen = + ifp->if_start_delay_qlen; + ifr->ifr_start_delay_timeout = + ifp->if_start_delay_timeout; + } else { + ifr->ifr_start_delay_qlen = 0; + ifr->ifr_start_delay_timeout = 0; + } + ifnet_lock_done(ifp); + break; + case SIOCSIFDSTADDR: + case SIOCSIFADDR: + case SIOCSIFBRDADDR: + case SIOCSIFNETMASK: + case OSIOCGIFADDR: + case OSIOCGIFDSTADDR: + case OSIOCGIFBRDADDR: + case OSIOCGIFNETMASK: + case SIOCSIFKPI: + VERIFY(so->so_proto != NULL); + + if (cmd == SIOCSIFDSTADDR || cmd == SIOCSIFADDR || + cmd == SIOCSIFBRDADDR || cmd == SIOCSIFNETMASK) { #if BYTE_ORDER != BIG_ENDIAN if (ifr->ifr_addr.sa_family == 0 && ifr->ifr_addr.sa_len < 16) { @@ -1786,27 +2718,19 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) if (ifr->ifr_addr.sa_len == 0) ifr->ifr_addr.sa_len = 16; #endif - break; - - case OSIOCGIFADDR: - cmd = SIOCGIFADDR; - break; - - case OSIOCGIFDSTADDR: - cmd = SIOCGIFDSTADDR; - break; - - case OSIOCGIFBRDADDR: - cmd = SIOCGIFBRDADDR; - break; - - case OSIOCGIFNETMASK: - cmd = SIOCGIFNETMASK; + } else if (cmd == OSIOCGIFADDR) { + cmd = SIOCGIFADDR; /* struct ifreq */ + } else if (cmd == OSIOCGIFDSTADDR) { + cmd = SIOCGIFDSTADDR; /* struct ifreq */ + } else if (cmd == OSIOCGIFBRDADDR) { + cmd = SIOCGIFBRDADDR; /* struct ifreq */ + } else if (cmd == OSIOCGIFNETMASK) { + cmd = SIOCGIFNETMASK; /* struct ifreq */ } socket_lock(so, 1); error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, - data, ifp, p)); + (caddr_t)ifr, ifp, p)); socket_unlock(so, 1); switch (ocmd) { @@ -1814,22 +2738,77 @@ ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) case OSIOCGIFDSTADDR: case OSIOCGIFBRDADDR: case OSIOCGIFNETMASK: - *(u_short *)&ifr->ifr_addr = ifr->ifr_addr.sa_family; - + bcopy(&ifr->ifr_addr.sa_family, &ifr->ifr_addr, + sizeof (u_short)); } - } + if (cmd == SIOCSIFKPI) { int temperr = proc_suser(p); if (temperr != 0) error = temperr; } - if (error == EOPNOTSUPP || error == ENOTSUP) - error = ifnet_ioctl(ifp, - so->so_proto->pr_domain->dom_family, cmd, data); + if (error == EOPNOTSUPP || error == ENOTSUP) { + error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, + (caddr_t)ifr); + } + break; + + case SIOCGIFINTERFACESTATE: + if_get_state(ifp, &ifr->ifr_interface_state); + + break; + case SIOCSIFINTERFACESTATE: + if ((error = priv_check_cred(kauth_cred_get(), + PRIV_NET_INTERFACE_CONTROL, 0)) != 0) + return (error); + + error = if_state_update(ifp, &ifr->ifr_interface_state); break; + case SIOCSIFPROBECONNECTIVITY: + if ((error = priv_check_cred(kauth_cred_get(), + PRIV_NET_INTERFACE_CONTROL, 0)) != 0) + return (error); + error = if_probe_connectivity(ifp, + ifr->ifr_probe_connectivity); + break; + case SIOCGIFPROBECONNECTIVITY: + if ((error = priv_check_cred(kauth_cred_get(), + PRIV_NET_INTERFACE_CONTROL, 0)) != 0) + return (error); + if (ifp->if_eflags & IFEF_PROBE_CONNECTIVITY) + ifr->ifr_probe_connectivity = 1; + else + ifr->ifr_probe_connectivity = 0; + break; + case SIOCGECNMODE: + if ((ifp->if_eflags & (IFEF_ECN_ENABLE|IFEF_ECN_DISABLE)) == + IFEF_ECN_ENABLE) + ifr->ifr_ecn_mode = IFRTYPE_ECN_ENABLE; + else if ((ifp->if_eflags & (IFEF_ECN_ENABLE|IFEF_ECN_DISABLE)) == + IFEF_ECN_DISABLE) + ifr->ifr_ecn_mode = IFRTYPE_ECN_DISABLE; + else + ifr->ifr_ecn_mode = IFRTYPE_ECN_DEFAULT; + break; + case SIOCSECNMODE: + if (ifr->ifr_ecn_mode == IFRTYPE_ECN_DEFAULT) { + ifp->if_eflags &= ~(IFEF_ECN_ENABLE|IFEF_ECN_DISABLE); + } else if (ifr->ifr_ecn_mode == IFRTYPE_ECN_ENABLE) { + ifp->if_eflags |= IFEF_ECN_ENABLE; + ifp->if_eflags &= ~IFEF_ECN_DISABLE; + } else if (ifr->ifr_ecn_mode == IFRTYPE_ECN_DISABLE) { + ifp->if_eflags |= IFEF_ECN_DISABLE; + ifp->if_eflags &= ~IFEF_ECN_ENABLE; + } else + error = EINVAL; + break; + default: + VERIFY(0); + /* NOTREACHED */ } + return (error); } @@ -1888,8 +2867,8 @@ ifnet_set_promiscuous( } if (newflags != oldflags) { - log(LOG_INFO, "%s%d: promiscuous mode %s%s\n", - ifp->if_name, ifp->if_unit, + log(LOG_INFO, "%s: promiscuous mode %s%s\n", + if_name(ifp), (newflags & IFF_PROMISC) != 0 ? "enable" : "disable", error != 0 ? " failed" : " succeeded"); } @@ -1904,30 +2883,33 @@ ifnet_set_promiscuous( */ /*ARGSUSED*/ static int -ifconf(u_long cmd, user_addr_t ifrp, int * ret_space) +ifconf(u_long cmd, user_addr_t ifrp, int *ret_space) { struct ifnet *ifp = NULL; struct ifaddr *ifa; struct ifreq ifr; int error = 0; size_t space; + net_thread_marks_t marks; + + marks = net_thread_marks_push(NET_THREAD_CKREQ_LLADDR); /* * Zero the ifr buffer to make sure we don't * disclose the contents of the stack. */ - bzero(&ifr, sizeof(struct ifreq)); + bzero(&ifr, sizeof (struct ifreq)); space = *ret_space; ifnet_head_lock_shared(); - for (ifp = ifnet_head.tqh_first; space > sizeof(ifr) && + for (ifp = ifnet_head.tqh_first; space > sizeof (ifr) && ifp; ifp = ifp->if_link.tqe_next) { char workbuf[64]; size_t ifnlen, addrs; - ifnlen = snprintf(workbuf, sizeof(workbuf), - "%s%d", ifp->if_name, ifp->if_unit); - if(ifnlen + 1 > sizeof ifr.ifr_name) { + ifnlen = snprintf(workbuf, sizeof (workbuf), + "%s", if_name(ifp)); + if (ifnlen + 1 > sizeof (ifr.ifr_name)) { error = ENAMETOOLONG; break; } else { @@ -1938,45 +2920,61 @@ ifconf(u_long cmd, user_addr_t ifrp, int * ret_space) addrs = 0; ifa = ifp->if_addrhead.tqh_first; - for ( ; space > sizeof (ifr) && ifa; + for (; space > sizeof (ifr) && ifa; ifa = ifa->ifa_link.tqe_next) { struct sockaddr *sa; + union { + struct sockaddr sa; + struct sockaddr_dl sdl; + uint8_t buf[SOCK_MAXADDRLEN + 1]; + } u; + + /* + * Make sure to accomodate the largest possible + * size of SA(if_lladdr)->sa_len. + */ + _CASSERT(sizeof (u) == (SOCK_MAXADDRLEN + 1)); IFA_LOCK(ifa); sa = ifa->ifa_addr; -#ifndef __APPLE__ - if (curproc->p_prison && prison_if(curproc, sa)) { + addrs++; + + if (ifa == ifp->if_lladdr) { + VERIFY(sa->sa_family == AF_LINK); + bcopy(sa, &u, sa->sa_len); IFA_UNLOCK(ifa); - continue; + ifnet_guarded_lladdr_copy_bytes(ifp, + LLADDR(&u.sdl), u.sdl.sdl_alen); + IFA_LOCK(ifa); + sa = &u.sa; } -#endif - addrs++; + if (cmd == OSIOCGIFCONF32 || cmd == OSIOCGIFCONF64) { struct osockaddr *osa = - (struct osockaddr *)&ifr.ifr_addr; + (struct osockaddr *)(void *)&ifr.ifr_addr; ifr.ifr_addr = *sa; osa->sa_family = sa->sa_family; error = copyout((caddr_t)&ifr, ifrp, sizeof (ifr)); - ifrp += sizeof(struct ifreq); - } else if (sa->sa_len <= sizeof(*sa)) { + ifrp += sizeof (struct ifreq); + } else if (sa->sa_len <= sizeof (*sa)) { ifr.ifr_addr = *sa; error = copyout((caddr_t)&ifr, ifrp, sizeof (ifr)); - ifrp += sizeof(struct ifreq); + ifrp += sizeof (struct ifreq); } else { if (space < - sizeof (ifr) + sa->sa_len - sizeof(*sa)) { + sizeof (ifr) + sa->sa_len - sizeof (*sa)) { IFA_UNLOCK(ifa); break; } - space -= sa->sa_len - sizeof(*sa); + space -= sa->sa_len - sizeof (*sa); error = copyout((caddr_t)&ifr, ifrp, sizeof (ifr.ifr_name)); if (error == 0) { - error = copyout((caddr_t)sa, (ifrp + - offsetof(struct ifreq, ifr_addr)), - sa->sa_len); + error = copyout((caddr_t)sa, (ifrp + + offsetof(struct ifreq, ifr_addr)), + sa->sa_len); } ifrp += (sa->sa_len + offsetof(struct ifreq, ifr_addr)); @@ -1991,16 +2989,17 @@ ifconf(u_long cmd, user_addr_t ifrp, int * ret_space) if (error) break; if (!addrs) { - bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr)); + bzero((caddr_t)&ifr.ifr_addr, sizeof (ifr.ifr_addr)); error = copyout((caddr_t)&ifr, ifrp, sizeof (ifr)); if (error) break; space -= sizeof (ifr); - ifrp += sizeof(struct ifreq); + ifrp += sizeof (struct ifreq); } } ifnet_head_done(); *ret_space -= space; + net_thread_marks_pop(marks); return (error); } @@ -2012,7 +3011,7 @@ if_allmulti(struct ifnet *ifp, int onswitch) { int error = 0; int modified = 0; - + ifnet_lock_exclusive(ifp); if (onswitch) { @@ -2030,7 +3029,7 @@ if_allmulti(struct ifnet *ifp, int onswitch) } } ifnet_lock_done(ifp); - + if (modified) error = ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL); @@ -2339,56 +3338,58 @@ if_addmulti_doesexist(struct ifnet *ifp, const struct sockaddr *sa, * Radar 3642395, make sure all multicasts are in a standard format. */ static struct sockaddr* -copy_and_normalize( - const struct sockaddr *original) +copy_and_normalize(const struct sockaddr *original) { - int alen = 0; + int alen = 0; const u_char *aptr = NULL; struct sockaddr *copy = NULL; struct sockaddr_dl *sdl_new = NULL; - int len = 0; - + int len = 0; + if (original->sa_family != AF_LINK && - original->sa_family != AF_UNSPEC) { + original->sa_family != AF_UNSPEC) { /* Just make a copy */ - MALLOC(copy, struct sockaddr*, original->sa_len, M_IFADDR, M_WAITOK); + MALLOC(copy, struct sockaddr*, original->sa_len, + M_IFADDR, M_WAITOK); if (copy != NULL) bcopy(original, copy, original->sa_len); - return copy; + return (copy); } - + switch (original->sa_family) { case AF_LINK: { - const struct sockaddr_dl *sdl_original = - (const struct sockaddr_dl*)original; - - if (sdl_original->sdl_nlen + sdl_original->sdl_alen + sdl_original->sdl_slen + - offsetof(struct sockaddr_dl, sdl_data) > sdl_original->sdl_len) - return NULL; - + const struct sockaddr_dl *sdl_original = + (struct sockaddr_dl*)(uintptr_t)(size_t)original; + + if (sdl_original->sdl_nlen + sdl_original->sdl_alen + + sdl_original->sdl_slen + + offsetof(struct sockaddr_dl, sdl_data) > + sdl_original->sdl_len) + return (NULL); + alen = sdl_original->sdl_alen; aptr = CONST_LLADDR(sdl_original); } break; - + case AF_UNSPEC: { if (original->sa_len < ETHER_ADDR_LEN + - offsetof(struct sockaddr, sa_data)) { - return NULL; + offsetof(struct sockaddr, sa_data)) { + return (NULL); } - + alen = ETHER_ADDR_LEN; aptr = (const u_char*)original->sa_data; } break; } - + if (alen == 0 || aptr == NULL) - return NULL; - + return (NULL); + len = alen + offsetof(struct sockaddr_dl, sdl_data); MALLOC(sdl_new, struct sockaddr_dl*, len, M_IFADDR, M_WAITOK); - + if (sdl_new != NULL) { bzero(sdl_new, len); sdl_new->sdl_len = len; @@ -2396,8 +3397,8 @@ copy_and_normalize( sdl_new->sdl_alen = alen; bcopy(aptr, LLADDR(sdl_new), alen); } - - return (struct sockaddr*)sdl_new; + + return ((struct sockaddr*)sdl_new); } /* @@ -2414,7 +3415,7 @@ if_addmulti(struct ifnet *ifp, const struct sockaddr *sa, /* * Anything other than network-layer protocol domains which hold references * to the underlying link-layer record must use this routine: SIOCADDMULTI - * ioctl, ifnet_add_multicast(), AppleTalk, if_bond. + * ioctl, ifnet_add_multicast(), if_bond. */ int if_addmulti_anon(struct ifnet *ifp, const struct sockaddr *sa, @@ -2624,7 +3625,7 @@ if_delmulti_ifma(struct ifmultiaddr *ifma) /* * Anything other than network-layer protocol domains which hold references * to the underlying link-layer record must use this routine: SIOCDELMULTI - * ioctl, ifnet_remove_multicast(), AppleTalk, if_bond. + * ioctl, ifnet_remove_multicast(), if_bond. */ int if_delmulti_anon(struct ifnet *ifp, const struct sockaddr *sa) @@ -2725,22 +3726,6 @@ if_delmulti_common(struct ifmultiaddr *ifma, struct ifnet *ifp, return (0); } -/* - * We don't use if_setlladdr, our interfaces are responsible for - * handling the SIOCSIFLLADDR ioctl. - */ -#ifndef __APPLE__ -int -if_setlladdr(struct ifnet *ifp, const u_char *lladdr, int len) -{ - ... -} -#endif - -SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Link layers"); -SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Generic link-management"); - - /* * Shutdown all network activity. Used boot() when halting * system. @@ -2819,8 +3804,6 @@ if_rtproto_del(struct ifnet *ifp, int protocol) { struct radix_node_head *rnh; - if (use_routegenid) - routegenid_update(); if ((protocol <= AF_MAX) && (protocol >= 0) && ((rnh = rt_tables[protocol]) != NULL) && (ifp != NULL)) { lck_mtx_lock(rnh_lock); @@ -2869,9 +3852,7 @@ void if_rtmtu_update(struct ifnet *ifp) (void) rnh->rnh_walktree(rnh, if_rtmtu, ifp); lck_mtx_unlock(rnh_lock); } - - if (use_routegenid) - routegenid_update(); + routegenid_update(); } __private_extern__ void @@ -2882,9 +3863,9 @@ if_data_internal_to_if_data(struct ifnet *ifp, #define COPYFIELD(fld) if_data->fld = if_data_int->fld #define COPYFIELD32(fld) if_data->fld = (u_int32_t)(if_data_int->fld) /* compiler will cast down to 32-bit */ -#define COPYFIELD32_ATOMIC(fld) do { \ - atomic_get_64(if_data->fld, \ - (u_int64_t *)(void *)(uintptr_t)&if_data_int->fld); \ +#define COPYFIELD32_ATOMIC(fld) do { \ + atomic_get_64(if_data->fld, \ + (u_int64_t *)(void *)(uintptr_t)&if_data_int->fld); \ } while (0) COPYFIELD(ifi_type); @@ -2917,13 +3898,11 @@ if_data_internal_to_if_data(struct ifnet *ifp, COPYFIELD(ifi_recvtiming); COPYFIELD(ifi_xmittiming); - + if_data->ifi_lastchange.tv_sec = if_data_int->ifi_lastchange.tv_sec; if_data->ifi_lastchange.tv_usec = if_data_int->ifi_lastchange.tv_usec; -#if IF_LASTCHANGEUPTIME if_data->ifi_lastchange.tv_sec += boottime_sec(); -#endif if_data->ifi_unused2 = 0; COPYFIELD(ifi_hwassist); @@ -2941,9 +3920,9 @@ if_data_internal_to_if_data64(struct ifnet *ifp, { #pragma unused(ifp) #define COPYFIELD64(fld) if_data64->fld = if_data_int->fld -#define COPYFIELD64_ATOMIC(fld) do { \ - atomic_get_64(if_data64->fld, \ - (u_int64_t *)(void *)(uintptr_t)&if_data_int->fld); \ +#define COPYFIELD64_ATOMIC(fld) do { \ + atomic_get_64(if_data64->fld, \ + (u_int64_t *)(void *)(uintptr_t)&if_data_int->fld); \ } while (0) COPYFIELD64(ifi_type); @@ -2979,9 +3958,7 @@ if_data_internal_to_if_data64(struct ifnet *ifp, if_data64->ifi_lastchange.tv_sec = if_data_int->ifi_lastchange.tv_sec; if_data64->ifi_lastchange.tv_usec = if_data_int->ifi_lastchange.tv_usec; -#if IF_LASTCHANGEUPTIME if_data64->ifi_lastchange.tv_sec += boottime_sec(); -#endif #undef COPYFIELD64 } @@ -2990,11 +3967,16 @@ __private_extern__ void if_copy_traffic_class(struct ifnet *ifp, struct if_traffic_class *if_tc) { -#define COPY_IF_TC_FIELD64_ATOMIC(fld) do { \ - atomic_get_64(if_tc->fld, \ - (u_int64_t *)(void *)(uintptr_t)&ifp->if_tc.fld); \ +#define COPY_IF_TC_FIELD64_ATOMIC(fld) do { \ + atomic_get_64(if_tc->fld, \ + (u_int64_t *)(void *)(uintptr_t)&ifp->if_tc.fld); \ } while (0) + bzero(if_tc, sizeof (*if_tc)); + COPY_IF_TC_FIELD64_ATOMIC(ifi_ibepackets); + COPY_IF_TC_FIELD64_ATOMIC(ifi_ibebytes); + COPY_IF_TC_FIELD64_ATOMIC(ifi_obepackets); + COPY_IF_TC_FIELD64_ATOMIC(ifi_obebytes); COPY_IF_TC_FIELD64_ATOMIC(ifi_ibkpackets); COPY_IF_TC_FIELD64_ATOMIC(ifi_ibkbytes); COPY_IF_TC_FIELD64_ATOMIC(ifi_obkpackets); @@ -3007,10 +3989,86 @@ if_copy_traffic_class(struct ifnet *ifp, COPY_IF_TC_FIELD64_ATOMIC(ifi_ivobytes); COPY_IF_TC_FIELD64_ATOMIC(ifi_ovopackets); COPY_IF_TC_FIELD64_ATOMIC(ifi_ovobytes); + COPY_IF_TC_FIELD64_ATOMIC(ifi_ipvpackets); + COPY_IF_TC_FIELD64_ATOMIC(ifi_ipvbytes); + COPY_IF_TC_FIELD64_ATOMIC(ifi_opvpackets); + COPY_IF_TC_FIELD64_ATOMIC(ifi_opvbytes); #undef COPY_IF_TC_FIELD64_ATOMIC } +void +if_copy_data_extended(struct ifnet *ifp, struct if_data_extended *if_de) +{ +#define COPY_IF_DE_FIELD64_ATOMIC(fld) do { \ + atomic_get_64(if_de->fld, \ + (u_int64_t *)(void *)(uintptr_t)&ifp->if_data.fld); \ +} while (0) + + bzero(if_de, sizeof (*if_de)); + COPY_IF_DE_FIELD64_ATOMIC(ifi_alignerrs); + COPY_IF_DE_FIELD64_ATOMIC(ifi_dt_bytes); + COPY_IF_DE_FIELD64_ATOMIC(ifi_fpackets); + COPY_IF_DE_FIELD64_ATOMIC(ifi_fbytes); + +#undef COPY_IF_DE_FIELD64_ATOMIC +} + +void +if_copy_packet_stats(struct ifnet *ifp, struct if_packet_stats *if_ps) +{ +#define COPY_IF_PS_TCP_FIELD64_ATOMIC(fld) do { \ + atomic_get_64(if_ps->ifi_tcp_##fld, \ + (u_int64_t *)(void *)(uintptr_t)&ifp->if_tcp_stat->fld); \ +} while (0) + +#define COPY_IF_PS_UDP_FIELD64_ATOMIC(fld) do { \ + atomic_get_64(if_ps->ifi_udp_##fld, \ + (u_int64_t *)(void *)(uintptr_t)&ifp->if_udp_stat->fld); \ +} while (0) + + COPY_IF_PS_TCP_FIELD64_ATOMIC(badformat); + COPY_IF_PS_TCP_FIELD64_ATOMIC(unspecv6); + COPY_IF_PS_TCP_FIELD64_ATOMIC(synfin); + COPY_IF_PS_TCP_FIELD64_ATOMIC(badformatipsec); + COPY_IF_PS_TCP_FIELD64_ATOMIC(noconnnolist); + COPY_IF_PS_TCP_FIELD64_ATOMIC(noconnlist); + COPY_IF_PS_TCP_FIELD64_ATOMIC(listbadsyn); + COPY_IF_PS_TCP_FIELD64_ATOMIC(icmp6unreach); + COPY_IF_PS_TCP_FIELD64_ATOMIC(deprecate6); + COPY_IF_PS_TCP_FIELD64_ATOMIC(ooopacket); + COPY_IF_PS_TCP_FIELD64_ATOMIC(rstinsynrcv); + COPY_IF_PS_TCP_FIELD64_ATOMIC(dospacket); + COPY_IF_PS_TCP_FIELD64_ATOMIC(cleanup); + COPY_IF_PS_TCP_FIELD64_ATOMIC(synwindow); + + COPY_IF_PS_UDP_FIELD64_ATOMIC(port_unreach); + COPY_IF_PS_UDP_FIELD64_ATOMIC(faithprefix); + COPY_IF_PS_UDP_FIELD64_ATOMIC(port0); + COPY_IF_PS_UDP_FIELD64_ATOMIC(badlength); + COPY_IF_PS_UDP_FIELD64_ATOMIC(badchksum); + COPY_IF_PS_UDP_FIELD64_ATOMIC(badmcast); + COPY_IF_PS_UDP_FIELD64_ATOMIC(cleanup); + COPY_IF_PS_UDP_FIELD64_ATOMIC(badipsec); + +#undef COPY_IF_PS_TCP_FIELD64_ATOMIC +#undef COPY_IF_PS_UDP_FIELD64_ATOMIC +} + +void +if_copy_rxpoll_stats(struct ifnet *ifp, struct if_rxpoll_stats *if_rs) +{ + bzero(if_rs, sizeof (*if_rs)); + if (!(ifp->if_eflags & IFEF_RXPOLL) || !ifnet_is_attached(ifp, 1)) + return; + + /* by now, ifnet will stay attached so if_inp must be valid */ + VERIFY(ifp->if_inp != NULL); + bcopy(&ifp->if_inp->pstats, if_rs, sizeof (*if_rs)); + + /* Release the IO refcnt */ + ifnet_decr_iorefcnt(ifp); +} struct ifaddr * ifa_remref(struct ifaddr *ifa, int locked) @@ -3029,10 +4087,9 @@ ifa_remref(struct ifaddr *ifa, int locked) panic("ifa %p attached to ifp is being freed\n", ifa); /* * Some interface addresses are allocated either statically - * or carved out of a larger block; e.g. AppleTalk addresses. - * Only free it if it was allocated via MALLOC or via the - * corresponding per-address family allocator. Otherwise, - * leave it alone. + * or carved out of a larger block. Only free it if it was + * allocated via MALLOC or via the corresponding per-address + * family allocator. Otherwise, leave it alone. */ if (ifa->ifa_debug & IFD_ALLOC) { if (ifa->ifa_free == NULL) { @@ -3086,3 +4143,194 @@ ifa_lock_destroy(struct ifaddr *ifa) IFA_LOCK_ASSERT_NOTHELD(ifa); lck_mtx_destroy(&ifa->ifa_lock, ifa_mtx_grp); } + +/* + * 'i' group ioctls. + * + * The switch statement below does nothing at runtime, as it serves as a + * compile time check to ensure that all of the socket 'i' ioctls (those + * in the 'i' group going thru soo_ioctl) that are made available by the + * networking stack is unique. This works as long as this routine gets + * updated each time a new interface ioctl gets added. + * + * Any failures at compile time indicates duplicated ioctl values. + */ +static __attribute__((unused)) void +ifioctl_cassert(void) +{ + /* + * This is equivalent to _CASSERT() and the compiler wouldn't + * generate any instructions, thus for compile time only. + */ + switch ((u_long)0) { + case 0: + + /* bsd/net/if_ppp.h */ + case SIOCGPPPSTATS: + case SIOCGPPPCSTATS: + +#if INET6 + /* bsd/netinet6/in6_var.h */ + case SIOCSIFADDR_IN6: + case SIOCGIFADDR_IN6: + case SIOCSIFDSTADDR_IN6: + case SIOCSIFNETMASK_IN6: + case SIOCGIFDSTADDR_IN6: + case SIOCGIFNETMASK_IN6: + case SIOCDIFADDR_IN6: + case SIOCAIFADDR_IN6_32: + case SIOCAIFADDR_IN6_64: + case SIOCSIFPHYADDR_IN6_32: + case SIOCSIFPHYADDR_IN6_64: + case SIOCGIFPSRCADDR_IN6: + case SIOCGIFPDSTADDR_IN6: + case SIOCGIFAFLAG_IN6: + case SIOCGDRLST_IN6_32: + case SIOCGDRLST_IN6_64: + case SIOCGPRLST_IN6_32: + case SIOCGPRLST_IN6_64: + case OSIOCGIFINFO_IN6: + case SIOCGIFINFO_IN6: + case SIOCSNDFLUSH_IN6: + case SIOCGNBRINFO_IN6_32: + case SIOCGNBRINFO_IN6_64: + case SIOCSPFXFLUSH_IN6: + case SIOCSRTRFLUSH_IN6: + case SIOCGIFALIFETIME_IN6: + case SIOCSIFALIFETIME_IN6: + case SIOCGIFSTAT_IN6: + case SIOCGIFSTAT_ICMP6: + case SIOCSDEFIFACE_IN6_32: + case SIOCSDEFIFACE_IN6_64: + case SIOCGDEFIFACE_IN6_32: + case SIOCGDEFIFACE_IN6_64: + case SIOCSIFINFO_FLAGS: + case SIOCSSCOPE6: + case SIOCGSCOPE6: + case SIOCGSCOPE6DEF: + case SIOCSIFPREFIX_IN6: + case SIOCGIFPREFIX_IN6: + case SIOCDIFPREFIX_IN6: + case SIOCAIFPREFIX_IN6: + case SIOCCIFPREFIX_IN6: + case SIOCSGIFPREFIX_IN6: + case SIOCPROTOATTACH_IN6_32: + case SIOCPROTOATTACH_IN6_64: + case SIOCPROTODETACH_IN6: + case SIOCLL_START_32: + case SIOCLL_START_64: + case SIOCLL_STOP: + case SIOCAUTOCONF_START: + case SIOCAUTOCONF_STOP: + case SIOCSETROUTERMODE_IN6: + case SIOCLL_CGASTART_32: + case SIOCLL_CGASTART_64: +#endif /* INET6 */ + + /* bsd/sys/sockio.h */ + case SIOCSIFADDR: + case OSIOCGIFADDR: + case SIOCSIFDSTADDR: + case OSIOCGIFDSTADDR: + case SIOCSIFFLAGS: + case SIOCGIFFLAGS: + case OSIOCGIFBRDADDR: + case SIOCSIFBRDADDR: + case OSIOCGIFCONF32: + case OSIOCGIFCONF64: + case OSIOCGIFNETMASK: + case SIOCSIFNETMASK: + case SIOCGIFMETRIC: + case SIOCSIFMETRIC: + case SIOCDIFADDR: + case SIOCAIFADDR: + case SIOCGIFADDR: + case SIOCGIFDSTADDR: + case SIOCGIFBRDADDR: + case SIOCGIFCONF32: + case SIOCGIFCONF64: + case SIOCGIFNETMASK: + case SIOCAUTOADDR: + case SIOCAUTONETMASK: + case SIOCARPIPLL: + case SIOCADDMULTI: + case SIOCDELMULTI: + case SIOCGIFMTU: + case SIOCSIFMTU: + case SIOCGIFPHYS: + case SIOCSIFPHYS: + case SIOCSIFMEDIA: + case SIOCGIFMEDIA32: + case SIOCGIFMEDIA64: + case SIOCSIFGENERIC: + case SIOCGIFGENERIC: + case SIOCRSLVMULTI: + case SIOCSIFLLADDR: + case SIOCGIFSTATUS: + case SIOCSIFPHYADDR: + case SIOCGIFPSRCADDR: + case SIOCGIFPDSTADDR: + case SIOCDIFPHYADDR: + case SIOCGIFDEVMTU: + case SIOCSIFALTMTU: + case SIOCGIFALTMTU: + case SIOCSIFBOND: + case SIOCGIFBOND: + case SIOCPROTOATTACH: + case SIOCPROTODETACH: + case SIOCSIFCAP: + case SIOCGIFCAP: + case SIOCIFCREATE: + case SIOCIFDESTROY: + case SIOCIFCREATE2: + case SIOCSDRVSPEC32: + case SIOCGDRVSPEC32: + case SIOCSDRVSPEC64: + case SIOCGDRVSPEC64: + case SIOCSIFVLAN: + case SIOCGIFVLAN: + case SIOCIFGCLONERS32: + case SIOCIFGCLONERS64: + case SIOCGIFASYNCMAP: + case SIOCSIFASYNCMAP: +#if CONFIG_MACF_NET + case SIOCGIFMAC: + case SIOCSIFMAC: +#endif /* CONFIG_MACF_NET */ + case SIOCSIFKPI: + case SIOCGIFKPI: + case SIOCGIFWAKEFLAGS: + case SIOCGIFGETRTREFCNT: + case SIOCGIFLINKQUALITYMETRIC: + case SIOCSIFOPPORTUNISTIC: + case SIOCGIFOPPORTUNISTIC: + case SIOCSETROUTERMODE: + case SIOCGIFEFLAGS: + case SIOCSIFDESC: + case SIOCGIFDESC: + case SIOCSIFLINKPARAMS: + case SIOCGIFLINKPARAMS: + case SIOCGIFQUEUESTATS: + case SIOCSIFTHROTTLE: + case SIOCGIFTHROTTLE: + case SIOCSIFLOG: + case SIOCGIFLOG: + case SIOCGIFDELEGATE: + case SIOCGIFLLADDR: + case SIOCGIFTYPE: + case SIOCGIFFUNCTIONALTYPE: + case SIOCAIFAGENTID: + case SIOCDIFAGENTID: + case SIOCGIFAGENTIDS32: + case SIOCGIFAGENTIDS64: + case SIOCGIFAGENTDATA32: + case SIOCGIFAGENTDATA64: + case SIOCSIFINTERFACESTATE: + case SIOCGIFINTERFACESTATE: + case SIOCSIFPROBECONNECTIVITY: + case SIOCGIFPROBECONNECTIVITY: + case SIOCGECNMODE: + case SIOCSECNMODE: + ; + } +}