+ len = cp - src + 1;
+ bcopy(src, dst, len);
+ dst[len] = '\0';
+ *unit = u;
+
+ return (0);
+}
+
+/*
+ * Map interface name to
+ * interface structure pointer.
+ */
+static struct ifnet *
+ifunit_common(const char *name, boolean_t hold)
+{
+ char namebuf[IFNAMSIZ + 1];
+ struct ifnet *ifp;
+ int unit;
+
+ if (ifunit_extract(name, namebuf, sizeof (namebuf), &unit) < 0)
+ return (NULL);
+
+ /* for safety, since we use strcmp() below */
+ namebuf[sizeof (namebuf) - 1] = '\0';
+
+ /*
+ * Now search all the interfaces for this name/number
+ */
+ ifnet_head_lock_shared();
+ TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
+ /*
+ * Use strcmp() rather than strncmp() here,
+ * since we want to match the entire string.
+ */
+ if (strcmp(ifp->if_name, namebuf))
+ continue;
+ if (unit == ifp->if_unit)
+ break;
+ }
+
+ /* if called from ifunit_ref() and ifnet is not attached, bail */
+ if (hold && ifp != NULL && !ifnet_is_attached(ifp, 1))
+ ifp = NULL;
+
+ ifnet_head_done();
+ return (ifp);
+}
+
+struct ifnet *
+ifunit(const char *name)
+{
+ return (ifunit_common(name, FALSE));
+}
+
+/*
+ * Similar to ifunit(), except that we hold an I/O reference count on an
+ * attached interface, which must later be released via ifnet_decr_iorefcnt().
+ * Will return NULL unless interface exists and is fully attached.
+ */
+struct ifnet *
+ifunit_ref(const char *name)
+{
+ return (ifunit_common(name, TRUE));
+}
+
+/*
+ * Map interface name in a sockaddr_dl to
+ * interface structure pointer.
+ */
+struct ifnet *
+if_withname(struct sockaddr *sa)
+{
+ char ifname[IFNAMSIZ+1];
+ struct sockaddr_dl *sdl = (struct sockaddr_dl *)(void *)sa;
+
+ if ((sa->sa_family != AF_LINK) || (sdl->sdl_nlen == 0) ||
+ (sdl->sdl_nlen > IFNAMSIZ))
+ return (NULL);
+
+ /*
+ * ifunit wants a null-terminated name. It may not be null-terminated
+ * in the sockaddr. We don't want to change the caller's sockaddr,
+ * and there might not be room to put the trailing null anyway, so we
+ * make a local copy that we know we can null terminate safely.
+ */
+
+ bcopy(sdl->sdl_data, ifname, sdl->sdl_nlen);
+ ifname[sdl->sdl_nlen] = '\0';
+ 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;
+ u_int32_t index = 0;
+ u_int32_t valid_netagent_count = 0;
+ *count = 0;
+
+ ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_SHARED);
+
+ if (ifp->if_agentids != NULL) {
+ for (index = 0; index < ifp->if_agentcount; index++) {
+ uuid_t *netagent_uuid = &(ifp->if_agentids[index]);
+ if (!uuid_is_null(*netagent_uuid)) {
+ if (uuid_p != USER_ADDR_NULL) {
+ error = copyout(netagent_uuid,
+ uuid_p + sizeof(uuid_t) * valid_netagent_count,
+ sizeof(uuid_t));
+ if (error != 0) {
+ return (error);
+ }
+ }
+ valid_netagent_count++;
+ }
+ }
+ }
+ *count = valid_netagent_count;
+
+ return (0);
+}
+
+#define IF_MAXAGENTS 64
+#define IF_AGENT_INCREMENT 8
+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;
+ u_int32_t index = 0;
+
+ VERIFY(ifp != NULL);
+
+ /* Get an io ref count if the interface is attached */
+ if (!ifnet_is_attached(ifp, 1)) {
+ return (EOPNOTSUPP);
+ }
+
+ if (cmd == SIOCAIFAGENTID ||
+ cmd == SIOCDIFAGENTID) {
+ ifnet_lock_exclusive(ifp);
+ } else {
+ ifnet_lock_shared(ifp);
+ }
+
+ 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;
+ }
+ bool already_added = FALSE;
+ if (ifp->if_agentids != NULL) {
+ for (index = 0; index < ifp->if_agentcount; index++) {
+ uuid_t *netagent_uuid = &(ifp->if_agentids[index]);
+ if (uuid_compare(*netagent_uuid, ifar->ifar_uuid) == 0) {
+ /* Already present, ignore */
+ already_added = TRUE;
+ break;
+ }
+ if (first_empty_slot == NULL &&
+ uuid_is_null(*netagent_uuid)) {
+ first_empty_slot = netagent_uuid;
+ }
+ }
+ }
+ if (already_added) {
+ /* Already added agent, don't return an error */
+ break;
+ }
+ if (first_empty_slot == NULL) {
+ if (ifp->if_agentcount >= IF_MAXAGENTS) {
+ /* No room for another netagent UUID, bail */
+ error = ENOMEM;
+ break;
+ } else {
+ /* Calculate new array size */
+ u_int32_t new_agent_count =
+ MIN(ifp->if_agentcount + IF_AGENT_INCREMENT, IF_MAXAGENTS);
+
+ /* Reallocate array */
+ uuid_t *new_agent_array = _REALLOC(ifp->if_agentids,
+ sizeof(uuid_t) * new_agent_count, M_NETAGENT,
+ M_WAITOK | M_ZERO);
+ if (new_agent_array == NULL) {
+ error = ENOMEM;
+ break;
+ }
+
+ /* Save new array */
+ ifp->if_agentids = new_agent_array;
+
+ /* Set first empty slot */
+ first_empty_slot = &(ifp->if_agentids[ifp->if_agentcount]);
+
+ /* Save new array length */
+ ifp->if_agentcount = new_agent_count;
+ }
+ }
+ 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;
+ }
+ if (ifp->if_agentids != NULL) {
+ for (index = 0; index < ifp->if_agentcount; 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 */
+ }
+
+ ifnet_lock_done(ifp);
+ ifnet_decr_iorefcnt(ifp);
+
+ return (error);
+}
+
+void
+ifnet_clear_netagent(uuid_t netagent_uuid)
+{
+ struct ifnet *ifp = NULL;
+ u_int32_t index = 0;
+
+ ifnet_head_lock_shared();
+
+ TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
+ ifnet_lock_shared(ifp);
+ if (ifp->if_agentids != NULL) {
+ for (index = 0; index < ifp->if_agentcount; index++) {
+ uuid_t *ifp_netagent_uuid = &(ifp->if_agentids[index]);
+ if (uuid_compare(*ifp_netagent_uuid, netagent_uuid) == 0) {
+ uuid_clear(*ifp_netagent_uuid);
+ }
+ }
+ }
+ ifnet_lock_done(ifp);
+ }
+
+ ifnet_head_done();
+}
+
+void
+ifnet_increment_generation(ifnet_t interface)
+{
+ OSIncrementAtomic(&interface->if_generation);
+}
+
+u_int32_t
+ifnet_get_generation(ifnet_t interface)
+{
+ return (interface->if_generation);
+}
+
+void
+ifnet_remove_from_ordered_list(struct ifnet *ifp)
+{
+ ifnet_head_assert_exclusive();
+
+ // Remove from list
+ TAILQ_REMOVE(&ifnet_ordered_head, ifp, if_ordered_link);
+ ifp->if_ordered_link.tqe_next = NULL;
+ ifp->if_ordered_link.tqe_prev = NULL;
+
+ // Update ordered count
+ VERIFY(if_ordered_count > 0);
+ if_ordered_count--;
+}
+
+static int
+ifnet_reset_order(u_int32_t *ordered_indices, u_int32_t count)
+{
+ struct ifnet *ifp = NULL;
+ int error = 0;
+
+ ifnet_head_lock_exclusive();
+
+ // Flush current ordered list
+ for (ifp = TAILQ_FIRST(&ifnet_ordered_head); ifp != NULL;
+ ifp = TAILQ_FIRST(&ifnet_ordered_head)) {
+ ifnet_lock_exclusive(ifp);
+ ifnet_remove_from_ordered_list(ifp);
+ ifnet_lock_done(ifp);
+ }
+
+ VERIFY(if_ordered_count == 0);
+
+ for (u_int32_t order_index = 0; order_index < count; order_index++) {
+ u_int32_t interface_index = ordered_indices[order_index];
+ if (interface_index == IFSCOPE_NONE ||
+ (int)interface_index > if_index) {
+ break;
+ }
+ ifp = ifindex2ifnet[interface_index];
+ if (ifp == NULL) {
+ continue;
+ }
+ ifnet_lock_exclusive(ifp);
+ TAILQ_INSERT_TAIL(&ifnet_ordered_head, ifp, if_ordered_link);
+ ifnet_lock_done(ifp);
+ if_ordered_count++;
+ }
+
+ ifnet_head_done();
+
+ necp_update_all_clients();
+
+ return (error);
+}
+
+int
+if_set_qosmarking_mode(struct ifnet *ifp, u_int32_t mode)
+{
+ int error = 0;
+ u_int32_t old_mode = ifp->if_qosmarking_mode;
+
+ switch (mode) {
+ case IFRTYPE_QOSMARKING_MODE_NONE:
+ ifp->if_qosmarking_mode = IFRTYPE_QOSMARKING_MODE_NONE;
+ ifp->if_eflags &= ~IFEF_QOSMARKING_CAPABLE;
+ break;
+ case IFRTYPE_QOSMARKING_FASTLANE:
+ ifp->if_qosmarking_mode = IFRTYPE_QOSMARKING_FASTLANE;
+ ifp->if_eflags |= IFEF_QOSMARKING_CAPABLE;
+ if (net_qos_policy_capable_enabled != 0)
+ ifp->if_eflags |= IFEF_QOSMARKING_ENABLED;
+ break;
+ default:
+ error = EINVAL;
+ break;
+ }
+ if (error == 0 && old_mode != ifp->if_qosmarking_mode) {
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_QOS_MODE_CHANGED,
+ NULL, sizeof(struct kev_dl_rrc_state));
+
+ }
+ return (error);
+}
+
+static __attribute__((noinline)) int
+ifioctl_iforder(u_long cmd, caddr_t data)
+{
+ int error = 0;
+ u_int32_t *ordered_indices = NULL;
+
+ if (data == NULL) {
+ return (EINVAL);
+ }
+
+ switch (cmd) {
+ case SIOCSIFORDER: { /* struct if_order */
+ struct if_order *ifo = (struct if_order *)(void *)data;
+
+ if ((int)ifo->ifo_count > if_index) {
+ error = EINVAL;
+ break;
+ }
+
+ size_t length = (ifo->ifo_count * sizeof(u_int32_t));
+ if (length > 0) {
+ if (ifo->ifo_ordered_indices == USER_ADDR_NULL) {
+ error = EINVAL;
+ break;
+ }
+ ordered_indices = _MALLOC(length, M_NECP, M_WAITOK);
+ if (ordered_indices == NULL) {
+ error = ENOMEM;
+ break;
+ }
+
+ error = copyin(ifo->ifo_ordered_indices,
+ ordered_indices, length);
+ if (error != 0) {
+ break;
+ }
+ }
+
+ error = ifnet_reset_order(ordered_indices, ifo->ifo_count);
+ break;
+ }
+
+ case SIOCGIFORDER: { /* struct if_order */
+ struct if_order *ifo = (struct if_order *)(void *)data;
+
+ u_int32_t ordered_count = if_ordered_count;
+
+ if (ifo->ifo_count == 0 ||
+ ordered_count == 0) {
+ ifo->ifo_count = ordered_count;
+ } else if (ifo->ifo_ordered_indices != USER_ADDR_NULL) {
+ u_int32_t count_to_copy =
+ MIN(ordered_count, ifo->ifo_count);
+ size_t length = (count_to_copy * sizeof(u_int32_t));
+ struct ifnet *ifp = NULL;
+ u_int32_t cursor = 0;
+
+ ordered_indices = _MALLOC(length, M_NECP, M_WAITOK);
+ if (ordered_indices == NULL) {
+ error = ENOMEM;
+ break;
+ }
+
+ ifnet_head_lock_shared();
+ TAILQ_FOREACH(ifp, &ifnet_ordered_head, if_ordered_link) {
+ if (cursor > count_to_copy) {
+ break;
+ }
+ ordered_indices[cursor] = ifp->if_index;
+ cursor++;
+ }
+ ifnet_head_done();
+
+ ifo->ifo_count = count_to_copy;
+ error = copyout(ordered_indices,
+ ifo->ifo_ordered_indices, length);
+ } else {
+ error = EINVAL;
+ }
+ break;
+ }
+
+ default: {
+ VERIFY(0);
+ /* NOTREACHED */
+ }
+ }
+
+ if (ordered_indices != NULL) {
+ _FREE(ordered_indices, M_NECP);
+ }
+
+ return (error);
+}
+
+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)
+{
+ char ifname[IFNAMSIZ + 1];
+ struct ifnet *ifp = NULL;
+ struct ifstat *ifs = NULL;
+ int error = 0;
+
+ bzero(ifname, sizeof (ifname));
+
+ /*
+ * ioctls which don't require ifp, or ifreq ioctls
+ */
+ switch (cmd) {
+ 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 */
+ case SIOCGIFAGENTLIST32: /* struct netagentlist_req32 */
+ case SIOCGIFAGENTLIST64: /* struct netagentlist_req64 */
+ error = netagent_ioctl(cmd, data);
+ goto done;
+
+ case SIOCSIFORDER: /* struct if_order */
+ case SIOCGIFORDER: /* struct if_order */
+ error = ifioctl_iforder(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 SIOCSIFTIMESTAMPENABLE: /* struct ifreq */
+ case SIOCSIFTIMESTAMPDISABLE: /* struct ifreq */
+ case SIOCGIFTIMESTAMPENABLED: /* struct ifreq */
+#if (DEBUG || DEVELOPMENT)
+ case SIOCSIFDISABLEOUTPUT: /* struct ifreq */
+#endif /* (DEBUG || DEVELOPMENT) */
+ 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 SIOCSQOSMARKINGMODE: /* struct ifreq */
+ case SIOCSQOSMARKINGENABLED: /* struct ifreq */
+ case SIOCGQOSMARKINGMODE: /* struct ifreq */
+ case SIOCGQOSMARKINGENABLED: /* struct ifreq */
+ { /* 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;
+ }
+ }
+
projects / apple / xnu.git / blobdiff