1 | /* |
2 | * Copyright (c) 2000-2018 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | /* |
29 | * Copyright (c) 1980, 1986, 1993 |
30 | * The Regents of the University of California. All rights reserved. |
31 | * |
32 | * Redistribution and use in source and binary forms, with or without |
33 | * modification, are permitted provided that the following conditions |
34 | * are met: |
35 | * 1. Redistributions of source code must retain the above copyright |
36 | * notice, this list of conditions and the following disclaimer. |
37 | * 2. Redistributions in binary form must reproduce the above copyright |
38 | * notice, this list of conditions and the following disclaimer in the |
39 | * documentation and/or other materials provided with the distribution. |
40 | * 3. All advertising materials mentioning features or use of this software |
41 | * must display the following acknowledgement: |
42 | * This product includes software developed by the University of |
43 | * California, Berkeley and its contributors. |
44 | * 4. Neither the name of the University nor the names of its contributors |
45 | * may be used to endorse or promote products derived from this software |
46 | * without specific prior written permission. |
47 | * |
48 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
49 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
50 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
51 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
52 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
53 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
54 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
55 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
56 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
57 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
58 | * SUCH DAMAGE. |
59 | * |
60 | * @(#)if.c 8.3 (Berkeley) 1/4/94 |
61 | * $FreeBSD: src/sys/net/if.c,v 1.85.2.9 2001/07/24 19:10:17 brooks Exp $ |
62 | */ |
63 | /* |
64 | * NOTICE: This file was modified by SPARTA, Inc. in 2006 to introduce |
65 | * support for mandatory and extensible security protections. This notice |
66 | * is included in support of clause 2.2 (b) of the Apple Public License, |
67 | * Version 2.0. |
68 | */ |
69 | |
70 | #include <kern/locks.h> |
71 | |
72 | #include <sys/param.h> |
73 | #include <sys/malloc.h> |
74 | #include <sys/mbuf.h> |
75 | #include <sys/systm.h> |
76 | #include <sys/proc.h> |
77 | #include <sys/socket.h> |
78 | #include <sys/socketvar.h> |
79 | #include <sys/protosw.h> |
80 | #include <sys/kernel.h> |
81 | #include <sys/sockio.h> |
82 | #include <sys/syslog.h> |
83 | #include <sys/sysctl.h> |
84 | #include <sys/mcache.h> |
85 | #include <sys/kauth.h> |
86 | #include <sys/priv.h> |
87 | #include <kern/zalloc.h> |
88 | #include <mach/boolean.h> |
89 | |
90 | #include <machine/endian.h> |
91 | |
92 | #include <pexpert/pexpert.h> |
93 | |
94 | #include <net/if.h> |
95 | #include <net/if_arp.h> |
96 | #include <net/if_dl.h> |
97 | #include <net/if_types.h> |
98 | #include <net/if_var.h> |
99 | #include <net/if_ppp.h> |
100 | #include <net/ethernet.h> |
101 | #include <net/network_agent.h> |
102 | #include <net/radix.h> |
103 | #include <net/route.h> |
104 | #include <net/dlil.h> |
105 | #include <net/nwk_wq.h> |
106 | |
107 | #include <sys/domain.h> |
108 | #include <libkern/OSAtomic.h> |
109 | |
110 | #if INET || INET6 |
111 | #include <netinet/in.h> |
112 | #include <netinet/in_var.h> |
113 | #include <netinet/in_tclass.h> |
114 | #include <netinet/ip_var.h> |
115 | #include <netinet/ip.h> |
116 | #include <netinet/ip6.h> |
117 | #include <netinet/ip_var.h> |
118 | #include <netinet/tcp.h> |
119 | #include <netinet/tcp_var.h> |
120 | #include <netinet/udp.h> |
121 | #include <netinet/udp_var.h> |
122 | #if INET6 |
123 | #include <netinet6/in6_var.h> |
124 | #include <netinet6/in6_ifattach.h> |
125 | #include <netinet6/ip6_var.h> |
126 | #include <netinet6/nd6.h> |
127 | #endif /* INET6 */ |
128 | #endif /* INET || INET6 */ |
129 | |
130 | #if CONFIG_MACF_NET |
131 | #include <security/mac_framework.h> |
132 | #endif |
133 | |
134 | /* |
135 | * System initialization |
136 | */ |
137 | |
138 | extern char *proc_name_address(void *); |
139 | |
140 | /* Lock group and attribute for ifaddr lock */ |
141 | lck_attr_t *ifa_mtx_attr; |
142 | lck_grp_t *ifa_mtx_grp; |
143 | static lck_grp_attr_t *ifa_mtx_grp_attr; |
144 | |
145 | static int ifioctl_ifreq(struct socket *, u_long, struct ifreq *, |
146 | struct proc *); |
147 | static int ifioctl_ifconf(u_long, caddr_t); |
148 | static int ifioctl_ifclone(u_long, caddr_t); |
149 | static int ifioctl_iforder(u_long, caddr_t); |
150 | static int ifioctl_ifdesc(struct ifnet *, u_long, caddr_t, struct proc *); |
151 | static int ifioctl_linkparams(struct ifnet *, u_long, caddr_t, struct proc *); |
152 | static int ifioctl_qstats(struct ifnet *, u_long, caddr_t); |
153 | static int ifioctl_throttle(struct ifnet *, u_long, caddr_t, struct proc *); |
154 | static int ifioctl_netsignature(struct ifnet *, u_long, caddr_t); |
155 | static int ifconf(u_long cmd, user_addr_t ifrp, int * ret_space); |
156 | __private_extern__ void link_rtrequest(int, struct rtentry *, struct sockaddr *); |
157 | void if_rtproto_del(struct ifnet *ifp, int protocol); |
158 | |
159 | static int if_addmulti_common(struct ifnet *, const struct sockaddr *, |
160 | struct ifmultiaddr **, int); |
161 | static int if_delmulti_common(struct ifmultiaddr *, struct ifnet *, |
162 | const struct sockaddr *, int); |
163 | static struct ifnet *ifunit_common(const char *, boolean_t); |
164 | |
165 | static int if_rtmtu(struct radix_node *, void *); |
166 | static void if_rtmtu_update(struct ifnet *); |
167 | |
168 | static int if_clone_list(int, int *, user_addr_t); |
169 | |
170 | MALLOC_DEFINE(M_IFADDR, "ifaddr" , "interface address" ); |
171 | |
172 | struct ifnethead ifnet_head = TAILQ_HEAD_INITIALIZER(ifnet_head); |
173 | |
174 | /* ifnet_ordered_head and if_ordered_count are protected by the ifnet_head lock */ |
175 | struct ifnethead ifnet_ordered_head = TAILQ_HEAD_INITIALIZER(ifnet_ordered_head); |
176 | static u_int32_t if_ordered_count = 0; |
177 | |
178 | static int if_cloners_count; |
179 | LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners); |
180 | |
181 | static struct ifaddr *ifa_ifwithnet_common(const struct sockaddr *, |
182 | unsigned int); |
183 | static void if_attach_ifa_common(struct ifnet *, struct ifaddr *, int); |
184 | static void if_detach_ifa_common(struct ifnet *, struct ifaddr *, int); |
185 | |
186 | static void if_attach_ifma(struct ifnet *, struct ifmultiaddr *, int); |
187 | static int if_detach_ifma(struct ifnet *, struct ifmultiaddr *, int); |
188 | |
189 | static struct ifmultiaddr *ifma_alloc(int); |
190 | static void ifma_free(struct ifmultiaddr *); |
191 | static void ifma_trace(struct ifmultiaddr *, int); |
192 | |
193 | #if DEBUG |
194 | static unsigned int ifma_debug = 1; /* debugging (enabled) */ |
195 | #else |
196 | static unsigned int ifma_debug; /* debugging (disabled) */ |
197 | #endif /* !DEBUG */ |
198 | static unsigned int ifma_size; /* size of zone element */ |
199 | static struct zone *ifma_zone; /* zone for ifmultiaddr */ |
200 | |
201 | #define IFMA_TRACE_HIST_SIZE 32 /* size of trace history */ |
202 | |
203 | /* For gdb */ |
204 | __private_extern__ unsigned int ifma_trace_hist_size = IFMA_TRACE_HIST_SIZE; |
205 | |
206 | struct ifmultiaddr_dbg { |
207 | struct ifmultiaddr ifma; /* ifmultiaddr */ |
208 | u_int16_t ifma_refhold_cnt; /* # of ref */ |
209 | u_int16_t ifma_refrele_cnt; /* # of rele */ |
210 | /* |
211 | * Circular lists of IFA_ADDREF and IFA_REMREF callers. |
212 | */ |
213 | ctrace_t ifma_refhold[IFMA_TRACE_HIST_SIZE]; |
214 | ctrace_t ifma_refrele[IFMA_TRACE_HIST_SIZE]; |
215 | /* |
216 | * Trash list linkage |
217 | */ |
218 | TAILQ_ENTRY(ifmultiaddr_dbg) ifma_trash_link; |
219 | }; |
220 | |
221 | /* List of trash ifmultiaddr entries protected by ifma_trash_lock */ |
222 | static TAILQ_HEAD(, ifmultiaddr_dbg) ifma_trash_head; |
223 | static decl_lck_mtx_data(, ifma_trash_lock); |
224 | |
225 | #define IFMA_ZONE_MAX 64 /* maximum elements in zone */ |
226 | #define IFMA_ZONE_NAME "ifmultiaddr" /* zone name */ |
227 | |
228 | #if INET6 |
229 | /* |
230 | * XXX: declare here to avoid to include many inet6 related files.. |
231 | * should be more generalized? |
232 | */ |
233 | extern void nd6_setmtu(struct ifnet *); |
234 | extern lck_mtx_t *nd6_mutex; |
235 | #endif |
236 | |
237 | SYSCTL_NODE(_net, PF_LINK, link, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Link layers" ); |
238 | SYSCTL_NODE(_net_link, 0, generic, CTLFLAG_RW|CTLFLAG_LOCKED, 0, |
239 | "Generic link-management" ); |
240 | |
241 | SYSCTL_DECL(_net_link_generic_system); |
242 | |
243 | static uint32_t if_verbose = 0; |
244 | SYSCTL_INT(_net_link_generic_system, OID_AUTO, if_verbose, |
245 | CTLFLAG_RW | CTLFLAG_LOCKED, &if_verbose, 0, "" ); |
246 | |
247 | boolean_t intcoproc_unrestricted; |
248 | |
249 | /* Eventhandler context for interface events */ |
250 | struct eventhandler_lists_ctxt ifnet_evhdlr_ctxt; |
251 | |
252 | void |
253 | ifa_init(void) |
254 | { |
255 | /* Setup lock group and attribute for ifaddr */ |
256 | ifa_mtx_grp_attr = lck_grp_attr_alloc_init(); |
257 | ifa_mtx_grp = lck_grp_alloc_init("ifaddr" , ifa_mtx_grp_attr); |
258 | ifa_mtx_attr = lck_attr_alloc_init(); |
259 | |
260 | PE_parse_boot_argn("ifa_debug" , &ifma_debug, sizeof (ifma_debug)); |
261 | |
262 | ifma_size = (ifma_debug == 0) ? sizeof (struct ifmultiaddr) : |
263 | sizeof (struct ifmultiaddr_dbg); |
264 | |
265 | ifma_zone = zinit(ifma_size, IFMA_ZONE_MAX * ifma_size, 0, |
266 | IFMA_ZONE_NAME); |
267 | if (ifma_zone == NULL) { |
268 | panic("%s: failed allocating %s" , __func__, IFMA_ZONE_NAME); |
269 | /* NOTREACHED */ |
270 | } |
271 | zone_change(ifma_zone, Z_EXPAND, TRUE); |
272 | zone_change(ifma_zone, Z_CALLERACCT, FALSE); |
273 | |
274 | lck_mtx_init(&ifma_trash_lock, ifa_mtx_grp, ifa_mtx_attr); |
275 | TAILQ_INIT(&ifma_trash_head); |
276 | |
277 | PE_parse_boot_argn("intcoproc_unrestricted" , &intcoproc_unrestricted, |
278 | sizeof (intcoproc_unrestricted)); |
279 | } |
280 | |
281 | /* |
282 | * Network interface utility routines. |
283 | * |
284 | * Routines with ifa_ifwith* names take sockaddr *'s as |
285 | * parameters. |
286 | */ |
287 | |
288 | int if_index; |
289 | struct ifaddr **ifnet_addrs; |
290 | struct ifnet **ifindex2ifnet; |
291 | |
292 | __private_extern__ void |
293 | if_attach_ifa(struct ifnet *ifp, struct ifaddr *ifa) |
294 | { |
295 | if_attach_ifa_common(ifp, ifa, 0); |
296 | } |
297 | |
298 | __private_extern__ void |
299 | if_attach_link_ifa(struct ifnet *ifp, struct ifaddr *ifa) |
300 | { |
301 | if_attach_ifa_common(ifp, ifa, 1); |
302 | } |
303 | |
304 | static void |
305 | if_attach_ifa_common(struct ifnet *ifp, struct ifaddr *ifa, int link) |
306 | { |
307 | ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_EXCLUSIVE); |
308 | IFA_LOCK_ASSERT_HELD(ifa); |
309 | |
310 | if (ifa->ifa_ifp != ifp) { |
311 | panic("%s: Mismatch ifa_ifp=%p != ifp=%p" , __func__, |
312 | ifa->ifa_ifp, ifp); |
313 | /* NOTREACHED */ |
314 | } else if (ifa->ifa_debug & IFD_ATTACHED) { |
315 | panic("%s: Attempt to attach an already attached ifa=%p" , |
316 | __func__, ifa); |
317 | /* NOTREACHED */ |
318 | } else if (link && !(ifa->ifa_debug & IFD_LINK)) { |
319 | panic("%s: Unexpected non-link address ifa=%p" , __func__, ifa); |
320 | /* NOTREACHED */ |
321 | } else if (!link && (ifa->ifa_debug & IFD_LINK)) { |
322 | panic("%s: Unexpected link address ifa=%p" , __func__, ifa); |
323 | /* NOTREACHED */ |
324 | } |
325 | IFA_ADDREF_LOCKED(ifa); |
326 | ifa->ifa_debug |= IFD_ATTACHED; |
327 | if (link) |
328 | TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link); |
329 | else |
330 | TAILQ_INSERT_TAIL(&ifp->if_addrhead, ifa, ifa_link); |
331 | |
332 | if (ifa->ifa_attached != NULL) |
333 | (*ifa->ifa_attached)(ifa); |
334 | |
335 | } |
336 | |
337 | __private_extern__ void |
338 | if_detach_ifa(struct ifnet *ifp, struct ifaddr *ifa) |
339 | { |
340 | if_detach_ifa_common(ifp, ifa, 0); |
341 | } |
342 | |
343 | __private_extern__ void |
344 | if_detach_link_ifa(struct ifnet *ifp, struct ifaddr *ifa) |
345 | { |
346 | if_detach_ifa_common(ifp, ifa, 1); |
347 | } |
348 | |
349 | static void |
350 | if_detach_ifa_common(struct ifnet *ifp, struct ifaddr *ifa, int link) |
351 | { |
352 | ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_EXCLUSIVE); |
353 | IFA_LOCK_ASSERT_HELD(ifa); |
354 | |
355 | if (link && !(ifa->ifa_debug & IFD_LINK)) { |
356 | panic("%s: Unexpected non-link address ifa=%p" , __func__, ifa); |
357 | /* NOTREACHED */ |
358 | } else if (link && ifa != TAILQ_FIRST(&ifp->if_addrhead)) { |
359 | panic("%s: Link address ifa=%p not first" , __func__, ifa); |
360 | /* NOTREACHED */ |
361 | } else if (!link && (ifa->ifa_debug & IFD_LINK)) { |
362 | panic("%s: Unexpected link address ifa=%p" , __func__, ifa); |
363 | /* NOTREACHED */ |
364 | } else if (!(ifa->ifa_debug & IFD_ATTACHED)) { |
365 | panic("%s: Attempt to detach an unattached address ifa=%p" , |
366 | __func__, ifa); |
367 | /* NOTREACHED */ |
368 | } else if (ifa->ifa_ifp != ifp) { |
369 | panic("%s: Mismatch ifa_ifp=%p, ifp=%p" , __func__, |
370 | ifa->ifa_ifp, ifp); |
371 | /* NOTREACHED */ |
372 | } else if (ifa->ifa_debug & IFD_DEBUG) { |
373 | struct ifaddr *ifa2; |
374 | TAILQ_FOREACH(ifa2, &ifp->if_addrhead, ifa_link) { |
375 | if (ifa2 == ifa) |
376 | break; |
377 | } |
378 | if (ifa2 != ifa) { |
379 | panic("%s: Attempt to detach a stray address ifa=%p" , |
380 | __func__, ifa); |
381 | /* NOTREACHED */ |
382 | } |
383 | } |
384 | TAILQ_REMOVE(&ifp->if_addrhead, ifa, ifa_link); |
385 | /* This must not be the last reference to the ifaddr */ |
386 | if (IFA_REMREF_LOCKED(ifa) == NULL) { |
387 | panic("%s: unexpected (missing) refcnt ifa=%p" , __func__, ifa); |
388 | /* NOTREACHED */ |
389 | } |
390 | ifa->ifa_debug &= ~(IFD_ATTACHED | IFD_DETACHING); |
391 | |
392 | if (ifa->ifa_detached != NULL) |
393 | (*ifa->ifa_detached)(ifa); |
394 | |
395 | } |
396 | |
397 | #define INITIAL_IF_INDEXLIM 8 |
398 | |
399 | /* |
400 | * Function: if_next_index |
401 | * Purpose: |
402 | * Return the next available interface index. |
403 | * Grow the ifnet_addrs[] and ifindex2ifnet[] arrays to accomodate the |
404 | * added entry when necessary. |
405 | * |
406 | * Note: |
407 | * ifnet_addrs[] is indexed by (if_index - 1), whereas |
408 | * ifindex2ifnet[] is indexed by ifp->if_index. That requires us to |
409 | * always allocate one extra element to hold ifindex2ifnet[0], which |
410 | * is unused. |
411 | */ |
412 | int if_next_index(void); |
413 | |
414 | __private_extern__ int |
415 | if_next_index(void) |
416 | { |
417 | static int if_indexlim = 0; |
418 | int new_index; |
419 | |
420 | new_index = ++if_index; |
421 | if (if_index > if_indexlim) { |
422 | unsigned n; |
423 | int new_if_indexlim; |
424 | caddr_t new_ifnet_addrs; |
425 | caddr_t new_ifindex2ifnet; |
426 | caddr_t old_ifnet_addrs; |
427 | |
428 | old_ifnet_addrs = (caddr_t)ifnet_addrs; |
429 | if (ifnet_addrs == NULL) { |
430 | new_if_indexlim = INITIAL_IF_INDEXLIM; |
431 | } else { |
432 | new_if_indexlim = if_indexlim << 1; |
433 | } |
434 | |
435 | /* allocate space for the larger arrays */ |
436 | n = (2 * new_if_indexlim + 1) * sizeof(caddr_t); |
437 | new_ifnet_addrs = _MALLOC(n, M_IFADDR, M_WAITOK | M_ZERO); |
438 | if (new_ifnet_addrs == NULL) { |
439 | --if_index; |
440 | return (-1); |
441 | } |
442 | |
443 | new_ifindex2ifnet = new_ifnet_addrs |
444 | + new_if_indexlim * sizeof(caddr_t); |
445 | if (ifnet_addrs != NULL) { |
446 | /* copy the existing data */ |
447 | bcopy((caddr_t)ifnet_addrs, new_ifnet_addrs, |
448 | if_indexlim * sizeof(caddr_t)); |
449 | bcopy((caddr_t)ifindex2ifnet, |
450 | new_ifindex2ifnet, |
451 | (if_indexlim + 1) * sizeof(caddr_t)); |
452 | } |
453 | |
454 | /* switch to the new tables and size */ |
455 | ifnet_addrs = (struct ifaddr **)(void *)new_ifnet_addrs; |
456 | ifindex2ifnet = (struct ifnet **)(void *)new_ifindex2ifnet; |
457 | if_indexlim = new_if_indexlim; |
458 | |
459 | /* release the old data */ |
460 | if (old_ifnet_addrs != NULL) { |
461 | _FREE((caddr_t)old_ifnet_addrs, M_IFADDR); |
462 | } |
463 | } |
464 | return (new_index); |
465 | } |
466 | |
467 | /* |
468 | * Create a clone network interface. |
469 | */ |
470 | static int |
471 | if_clone_create(char *name, int len, void *params) |
472 | { |
473 | struct if_clone *ifc; |
474 | char *dp; |
475 | int wildcard; |
476 | u_int32_t bytoff, bitoff; |
477 | u_int32_t unit; |
478 | int err; |
479 | |
480 | ifc = if_clone_lookup(name, &unit); |
481 | if (ifc == NULL) |
482 | return (EINVAL); |
483 | |
484 | if (ifunit(name) != NULL) |
485 | return (EEXIST); |
486 | |
487 | bytoff = bitoff = 0; |
488 | wildcard = (unit == UINT32_MAX); |
489 | /* |
490 | * Find a free unit if none was given. |
491 | */ |
492 | if (wildcard) { |
493 | while ((bytoff < ifc->ifc_bmlen) && |
494 | (ifc->ifc_units[bytoff] == 0xff)) |
495 | bytoff++; |
496 | if (bytoff >= ifc->ifc_bmlen) |
497 | return (ENOSPC); |
498 | while ((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0) |
499 | bitoff++; |
500 | unit = (bytoff << 3) + bitoff; |
501 | } |
502 | |
503 | if (unit > ifc->ifc_maxunit) |
504 | return (ENXIO); |
505 | |
506 | lck_mtx_lock(&ifc->ifc_mutex); |
507 | err = (*ifc->ifc_create)(ifc, unit, params); |
508 | if (err != 0) { |
509 | lck_mtx_unlock(&ifc->ifc_mutex); |
510 | return (err); |
511 | } |
512 | |
513 | if (!wildcard) { |
514 | bytoff = unit >> 3; |
515 | bitoff = unit - (bytoff << 3); |
516 | } |
517 | |
518 | /* |
519 | * Allocate the unit in the bitmap. |
520 | */ |
521 | KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) == 0, |
522 | ("%s: bit is already set" , __func__)); |
523 | ifc->ifc_units[bytoff] |= (1 << bitoff); |
524 | |
525 | /* In the wildcard case, we need to update the name. */ |
526 | if (wildcard) { |
527 | for (dp = name; *dp != '\0'; dp++); |
528 | if (snprintf(dp, len - (dp-name), "%d" , unit) > |
529 | len - (dp-name) - 1) { |
530 | /* |
531 | * This can only be a programmer error and |
532 | * there's no straightforward way to recover if |
533 | * it happens. |
534 | */ |
535 | panic("%s: interface name too long" , __func__); |
536 | /* NOTREACHED */ |
537 | } |
538 | |
539 | } |
540 | lck_mtx_unlock(&ifc->ifc_mutex); |
541 | |
542 | return (0); |
543 | } |
544 | |
545 | /* |
546 | * Destroy a clone network interface. |
547 | */ |
548 | static int |
549 | if_clone_destroy(const char *name) |
550 | { |
551 | struct if_clone *ifc = NULL; |
552 | struct ifnet *ifp = NULL; |
553 | int bytoff, bitoff; |
554 | u_int32_t unit; |
555 | int error = 0; |
556 | |
557 | ifc = if_clone_lookup(name, &unit); |
558 | |
559 | if (ifc == NULL) { |
560 | error = EINVAL; |
561 | goto done; |
562 | } |
563 | |
564 | if (unit < ifc->ifc_minifs) { |
565 | error = EINVAL; |
566 | goto done; |
567 | } |
568 | |
569 | ifp = ifunit_ref(name); |
570 | if (ifp == NULL) { |
571 | error = ENXIO; |
572 | goto done; |
573 | } |
574 | |
575 | if (ifc->ifc_destroy == NULL) { |
576 | error = EOPNOTSUPP; |
577 | goto done; |
578 | } |
579 | |
580 | lck_mtx_lock(&ifc->ifc_mutex); |
581 | error = (*ifc->ifc_destroy)(ifp); |
582 | |
583 | if (error) { |
584 | lck_mtx_unlock(&ifc->ifc_mutex); |
585 | goto done; |
586 | } |
587 | |
588 | /* Compute offset in the bitmap and deallocate the unit. */ |
589 | bytoff = unit >> 3; |
590 | bitoff = unit - (bytoff << 3); |
591 | KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0, |
592 | ("%s: bit is already cleared" , __func__)); |
593 | ifc->ifc_units[bytoff] &= ~(1 << bitoff); |
594 | lck_mtx_unlock(&ifc->ifc_mutex); |
595 | |
596 | done: |
597 | if (ifp != NULL) |
598 | ifnet_decr_iorefcnt(ifp); |
599 | return (error); |
600 | } |
601 | |
602 | /* |
603 | * Look up a network interface cloner. |
604 | */ |
605 | |
606 | __private_extern__ struct if_clone * |
607 | if_clone_lookup(const char *name, u_int32_t *unitp) |
608 | { |
609 | struct if_clone *ifc; |
610 | const char *cp; |
611 | u_int32_t i; |
612 | |
613 | for (ifc = LIST_FIRST(&if_cloners); ifc != NULL; ) { |
614 | for (cp = name, i = 0; i < ifc->ifc_namelen; i++, cp++) { |
615 | if (ifc->ifc_name[i] != *cp) |
616 | goto next_ifc; |
617 | } |
618 | goto found_name; |
619 | next_ifc: |
620 | ifc = LIST_NEXT(ifc, ifc_list); |
621 | } |
622 | |
623 | /* No match. */ |
624 | return ((struct if_clone *)NULL); |
625 | |
626 | found_name: |
627 | if (*cp == '\0') { |
628 | i = UINT32_MAX; |
629 | } else { |
630 | for (i = 0; *cp != '\0'; cp++) { |
631 | if (*cp < '0' || *cp > '9') { |
632 | /* Bogus unit number. */ |
633 | return (NULL); |
634 | } |
635 | i = (i * 10) + (*cp - '0'); |
636 | } |
637 | } |
638 | |
639 | if (unitp != NULL) |
640 | *unitp = i; |
641 | return (ifc); |
642 | } |
643 | |
644 | void * |
645 | if_clone_softc_allocate(const struct if_clone *ifc) |
646 | { |
647 | void *p_clone = NULL; |
648 | |
649 | VERIFY(ifc != NULL); |
650 | |
651 | p_clone = zalloc(ifc->ifc_zone); |
652 | if (p_clone != NULL) |
653 | bzero(p_clone, ifc->ifc_softc_size); |
654 | |
655 | return (p_clone); |
656 | } |
657 | |
658 | void |
659 | if_clone_softc_deallocate(const struct if_clone *ifc, void *p_softc) |
660 | { |
661 | VERIFY(ifc != NULL && p_softc != NULL); |
662 | bzero(p_softc, ifc->ifc_softc_size); |
663 | zfree(ifc->ifc_zone, p_softc); |
664 | } |
665 | |
666 | /* |
667 | * Register a network interface cloner. |
668 | */ |
669 | int |
670 | if_clone_attach(struct if_clone *ifc) |
671 | { |
672 | int bytoff, bitoff; |
673 | int err; |
674 | int len, maxclone; |
675 | u_int32_t unit; |
676 | |
677 | KASSERT(ifc->ifc_minifs - 1 <= ifc->ifc_maxunit, |
678 | ("%s: %s requested more units then allowed (%d > %d)" , |
679 | __func__, ifc->ifc_name, ifc->ifc_minifs, |
680 | ifc->ifc_maxunit + 1)); |
681 | /* |
682 | * Compute bitmap size and allocate it. |
683 | */ |
684 | maxclone = ifc->ifc_maxunit + 1; |
685 | len = maxclone >> 3; |
686 | if ((len << 3) < maxclone) |
687 | len++; |
688 | ifc->ifc_units = _MALLOC(len, M_CLONE, M_WAITOK | M_ZERO); |
689 | if (ifc->ifc_units == NULL) |
690 | return (ENOBUFS); |
691 | ifc->ifc_bmlen = len; |
692 | lck_mtx_init(&ifc->ifc_mutex, ifnet_lock_group, ifnet_lock_attr); |
693 | |
694 | if (ifc->ifc_softc_size != 0) { |
695 | ifc->ifc_zone = zinit(ifc->ifc_softc_size, |
696 | ifc->ifc_zone_max_elem * ifc->ifc_softc_size, 0, ifc->ifc_name); |
697 | if (ifc->ifc_zone == NULL) { |
698 | FREE(ifc->ifc_units, M_CLONE); |
699 | return (ENOBUFS); |
700 | } |
701 | zone_change(ifc->ifc_zone, Z_EXPAND, TRUE); |
702 | zone_change(ifc->ifc_zone, Z_CALLERACCT, FALSE); |
703 | } |
704 | |
705 | LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list); |
706 | if_cloners_count++; |
707 | |
708 | for (unit = 0; unit < ifc->ifc_minifs; unit++) { |
709 | err = (*ifc->ifc_create)(ifc, unit, NULL); |
710 | KASSERT(err == 0, |
711 | ("%s: failed to create required interface %s%d" , |
712 | __func__, ifc->ifc_name, unit)); |
713 | |
714 | /* Allocate the unit in the bitmap. */ |
715 | bytoff = unit >> 3; |
716 | bitoff = unit - (bytoff << 3); |
717 | ifc->ifc_units[bytoff] |= (1 << bitoff); |
718 | } |
719 | |
720 | return (0); |
721 | } |
722 | |
723 | /* |
724 | * Unregister a network interface cloner. |
725 | */ |
726 | void |
727 | if_clone_detach(struct if_clone *ifc) |
728 | { |
729 | LIST_REMOVE(ifc, ifc_list); |
730 | FREE(ifc->ifc_units, M_CLONE); |
731 | if (ifc->ifc_softc_size != 0) |
732 | zdestroy(ifc->ifc_zone); |
733 | |
734 | lck_mtx_destroy(&ifc->ifc_mutex, ifnet_lock_group); |
735 | if_cloners_count--; |
736 | } |
737 | |
738 | /* |
739 | * Provide list of interface cloners to userspace. |
740 | */ |
741 | static int |
742 | if_clone_list(int count, int *ret_total, user_addr_t dst) |
743 | { |
744 | char outbuf[IFNAMSIZ]; |
745 | struct if_clone *ifc; |
746 | int error = 0; |
747 | |
748 | *ret_total = if_cloners_count; |
749 | if (dst == USER_ADDR_NULL) { |
750 | /* Just asking how many there are. */ |
751 | return (0); |
752 | } |
753 | |
754 | if (count < 0) |
755 | return (EINVAL); |
756 | |
757 | count = (if_cloners_count < count) ? if_cloners_count : count; |
758 | |
759 | for (ifc = LIST_FIRST(&if_cloners); ifc != NULL && count != 0; |
760 | ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) { |
761 | bzero(outbuf, sizeof(outbuf)); |
762 | strlcpy(outbuf, ifc->ifc_name, IFNAMSIZ); |
763 | error = copyout(outbuf, dst, IFNAMSIZ); |
764 | if (error) |
765 | break; |
766 | } |
767 | |
768 | return (error); |
769 | } |
770 | |
771 | u_int32_t |
772 | if_functional_type(struct ifnet *ifp, bool exclude_delegate) |
773 | { |
774 | u_int32_t ret = IFRTYPE_FUNCTIONAL_UNKNOWN; |
775 | if (ifp != NULL) { |
776 | if (ifp->if_flags & IFF_LOOPBACK) { |
777 | ret = IFRTYPE_FUNCTIONAL_LOOPBACK; |
778 | } else if ((exclude_delegate && |
779 | (ifp->if_subfamily == IFNET_SUBFAMILY_WIFI)) || |
780 | (!exclude_delegate && IFNET_IS_WIFI(ifp))) { |
781 | if (ifp->if_eflags & IFEF_AWDL) |
782 | ret = IFRTYPE_FUNCTIONAL_WIFI_AWDL; |
783 | else |
784 | ret = IFRTYPE_FUNCTIONAL_WIFI_INFRA; |
785 | } else if ((exclude_delegate && |
786 | (ifp->if_type == IFT_CELLULAR)) || |
787 | (!exclude_delegate && IFNET_IS_CELLULAR(ifp))) { |
788 | ret = IFRTYPE_FUNCTIONAL_CELLULAR; |
789 | } else if (IFNET_IS_INTCOPROC(ifp)) { |
790 | ret = IFRTYPE_FUNCTIONAL_INTCOPROC; |
791 | } else if ((exclude_delegate && |
792 | (ifp->if_family == IFNET_FAMILY_ETHERNET || |
793 | ifp->if_family == IFNET_FAMILY_BOND || |
794 | ifp->if_family == IFNET_FAMILY_VLAN || |
795 | ifp->if_family == IFNET_FAMILY_FIREWIRE)) || |
796 | (!exclude_delegate && IFNET_IS_WIRED(ifp))) { |
797 | ret = IFRTYPE_FUNCTIONAL_WIRED; |
798 | } |
799 | } |
800 | |
801 | return (ret); |
802 | } |
803 | |
804 | /* |
805 | * Similar to ifa_ifwithaddr, except that this is IPv4 specific |
806 | * and that it matches only the local (not broadcast) address. |
807 | */ |
808 | __private_extern__ struct in_ifaddr * |
809 | ifa_foraddr(unsigned int addr) |
810 | { |
811 | return (ifa_foraddr_scoped(addr, IFSCOPE_NONE)); |
812 | } |
813 | |
814 | /* |
815 | * Similar to ifa_foraddr, except with the added interface scope |
816 | * constraint (unless the caller passes in IFSCOPE_NONE in which |
817 | * case there is no scope restriction). |
818 | */ |
819 | __private_extern__ struct in_ifaddr * |
820 | ifa_foraddr_scoped(unsigned int addr, unsigned int scope) |
821 | { |
822 | struct in_ifaddr *ia = NULL; |
823 | |
824 | lck_rw_lock_shared(in_ifaddr_rwlock); |
825 | TAILQ_FOREACH(ia, INADDR_HASH(addr), ia_hash) { |
826 | IFA_LOCK_SPIN(&ia->ia_ifa); |
827 | if (ia->ia_addr.sin_addr.s_addr == addr && |
828 | (scope == IFSCOPE_NONE || ia->ia_ifp->if_index == scope)) { |
829 | IFA_ADDREF_LOCKED(&ia->ia_ifa); /* for caller */ |
830 | IFA_UNLOCK(&ia->ia_ifa); |
831 | break; |
832 | } |
833 | IFA_UNLOCK(&ia->ia_ifa); |
834 | } |
835 | lck_rw_done(in_ifaddr_rwlock); |
836 | return (ia); |
837 | } |
838 | |
839 | #if INET6 |
840 | /* |
841 | * Similar to ifa_foraddr, except that this for IPv6. |
842 | */ |
843 | __private_extern__ struct in6_ifaddr * |
844 | ifa_foraddr6(struct in6_addr *addr6) |
845 | { |
846 | return (ifa_foraddr6_scoped(addr6, IFSCOPE_NONE)); |
847 | } |
848 | |
849 | __private_extern__ struct in6_ifaddr * |
850 | ifa_foraddr6_scoped(struct in6_addr *addr6, unsigned int scope) |
851 | { |
852 | struct in6_ifaddr *ia = NULL; |
853 | |
854 | lck_rw_lock_shared(&in6_ifaddr_rwlock); |
855 | for (ia = in6_ifaddrs; ia; ia = ia->ia_next) { |
856 | IFA_LOCK(&ia->ia_ifa); |
857 | if (IN6_ARE_ADDR_EQUAL(&ia->ia_addr.sin6_addr, addr6) && |
858 | (scope == IFSCOPE_NONE || ia->ia_ifp->if_index == scope)) { |
859 | IFA_ADDREF_LOCKED(&ia->ia_ifa); /* for caller */ |
860 | IFA_UNLOCK(&ia->ia_ifa); |
861 | break; |
862 | } |
863 | IFA_UNLOCK(&ia->ia_ifa); |
864 | } |
865 | lck_rw_done(&in6_ifaddr_rwlock); |
866 | |
867 | return (ia); |
868 | } |
869 | #endif /* INET6 */ |
870 | |
871 | /* |
872 | * Return the first (primary) address of a given family on an interface. |
873 | */ |
874 | __private_extern__ struct ifaddr * |
875 | ifa_ifpgetprimary(struct ifnet *ifp, int family) |
876 | { |
877 | struct ifaddr *ifa; |
878 | |
879 | ifnet_lock_shared(ifp); |
880 | TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { |
881 | IFA_LOCK_SPIN(ifa); |
882 | if (ifa->ifa_addr->sa_family == family) { |
883 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
884 | IFA_UNLOCK(ifa); |
885 | break; |
886 | } |
887 | IFA_UNLOCK(ifa); |
888 | } |
889 | ifnet_lock_done(ifp); |
890 | |
891 | return (ifa); |
892 | } |
893 | |
894 | static inline int |
895 | ifa_equal(const struct sockaddr *sa1, const struct sockaddr *sa2) |
896 | { |
897 | |
898 | if (!sa1 || !sa2) |
899 | return 0; |
900 | if (sa1->sa_len != sa2->sa_len) |
901 | return 0; |
902 | |
903 | return (bcmp(sa1, sa2, sa1->sa_len) == 0); |
904 | } |
905 | |
906 | /* |
907 | * Locate an interface based on a complete address. |
908 | */ |
909 | struct ifaddr * |
910 | ifa_ifwithaddr_locked(const struct sockaddr *addr) |
911 | { |
912 | struct ifnet *ifp; |
913 | struct ifaddr *ifa; |
914 | struct ifaddr *result = NULL; |
915 | |
916 | for (ifp = ifnet_head.tqh_first; ifp && !result; |
917 | ifp = ifp->if_link.tqe_next) { |
918 | ifnet_lock_shared(ifp); |
919 | for (ifa = ifp->if_addrhead.tqh_first; ifa; |
920 | ifa = ifa->ifa_link.tqe_next) { |
921 | IFA_LOCK_SPIN(ifa); |
922 | if (ifa->ifa_addr->sa_family != addr->sa_family) { |
923 | IFA_UNLOCK(ifa); |
924 | continue; |
925 | } |
926 | if (ifa_equal(addr, ifa->ifa_addr)) { |
927 | result = ifa; |
928 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
929 | IFA_UNLOCK(ifa); |
930 | break; |
931 | } |
932 | if ((ifp->if_flags & IFF_BROADCAST) && |
933 | ifa->ifa_broadaddr != NULL && |
934 | /* IP6 doesn't have broadcast */ |
935 | ifa->ifa_broadaddr->sa_len != 0 && |
936 | ifa_equal(ifa->ifa_broadaddr, addr)) { |
937 | result = ifa; |
938 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
939 | IFA_UNLOCK(ifa); |
940 | break; |
941 | } |
942 | IFA_UNLOCK(ifa); |
943 | } |
944 | ifnet_lock_done(ifp); |
945 | } |
946 | |
947 | return (result); |
948 | } |
949 | |
950 | struct ifaddr * |
951 | ifa_ifwithaddr(const struct sockaddr *addr) |
952 | { |
953 | struct ifaddr *result = NULL; |
954 | |
955 | ifnet_head_lock_shared(); |
956 | |
957 | result = ifa_ifwithaddr_locked(addr); |
958 | |
959 | ifnet_head_done(); |
960 | |
961 | return (result); |
962 | } |
963 | /* |
964 | * Locate the point to point interface with a given destination address. |
965 | */ |
966 | /*ARGSUSED*/ |
967 | struct ifaddr * |
968 | ifa_ifwithdstaddr(const struct sockaddr *addr) |
969 | { |
970 | struct ifnet *ifp; |
971 | struct ifaddr *ifa; |
972 | struct ifaddr *result = NULL; |
973 | |
974 | ifnet_head_lock_shared(); |
975 | for (ifp = ifnet_head.tqh_first; ifp && !result; |
976 | ifp = ifp->if_link.tqe_next) { |
977 | if ((ifp->if_flags & IFF_POINTOPOINT)) { |
978 | ifnet_lock_shared(ifp); |
979 | for (ifa = ifp->if_addrhead.tqh_first; ifa; |
980 | ifa = ifa->ifa_link.tqe_next) { |
981 | IFA_LOCK_SPIN(ifa); |
982 | if (ifa->ifa_addr->sa_family != |
983 | addr->sa_family) { |
984 | IFA_UNLOCK(ifa); |
985 | continue; |
986 | } |
987 | if (ifa_equal(addr, ifa->ifa_dstaddr)) { |
988 | result = ifa; |
989 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
990 | IFA_UNLOCK(ifa); |
991 | break; |
992 | } |
993 | IFA_UNLOCK(ifa); |
994 | } |
995 | ifnet_lock_done(ifp); |
996 | } |
997 | } |
998 | ifnet_head_done(); |
999 | return (result); |
1000 | } |
1001 | |
1002 | /* |
1003 | * Locate the source address of an interface based on a complete address. |
1004 | */ |
1005 | struct ifaddr * |
1006 | ifa_ifwithaddr_scoped_locked(const struct sockaddr *addr, unsigned int ifscope) |
1007 | { |
1008 | struct ifaddr *result = NULL; |
1009 | struct ifnet *ifp; |
1010 | |
1011 | if (ifscope == IFSCOPE_NONE) |
1012 | return (ifa_ifwithaddr_locked(addr)); |
1013 | |
1014 | if (ifscope > (unsigned int)if_index) { |
1015 | return (NULL); |
1016 | } |
1017 | |
1018 | ifp = ifindex2ifnet[ifscope]; |
1019 | if (ifp != NULL) { |
1020 | struct ifaddr *ifa = NULL; |
1021 | |
1022 | /* |
1023 | * This is suboptimal; there should be a better way |
1024 | * to search for a given address of an interface |
1025 | * for any given address family. |
1026 | */ |
1027 | ifnet_lock_shared(ifp); |
1028 | for (ifa = ifp->if_addrhead.tqh_first; ifa != NULL; |
1029 | ifa = ifa->ifa_link.tqe_next) { |
1030 | IFA_LOCK_SPIN(ifa); |
1031 | if (ifa->ifa_addr->sa_family != addr->sa_family) { |
1032 | IFA_UNLOCK(ifa); |
1033 | continue; |
1034 | } |
1035 | if (ifa_equal(addr, ifa->ifa_addr)) { |
1036 | result = ifa; |
1037 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
1038 | IFA_UNLOCK(ifa); |
1039 | break; |
1040 | } |
1041 | if ((ifp->if_flags & IFF_BROADCAST) && |
1042 | ifa->ifa_broadaddr != NULL && |
1043 | /* IP6 doesn't have broadcast */ |
1044 | ifa->ifa_broadaddr->sa_len != 0 && |
1045 | ifa_equal(ifa->ifa_broadaddr, addr)) { |
1046 | result = ifa; |
1047 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
1048 | IFA_UNLOCK(ifa); |
1049 | break; |
1050 | } |
1051 | IFA_UNLOCK(ifa); |
1052 | } |
1053 | ifnet_lock_done(ifp); |
1054 | } |
1055 | |
1056 | return (result); |
1057 | } |
1058 | |
1059 | struct ifaddr * |
1060 | ifa_ifwithaddr_scoped(const struct sockaddr *addr, unsigned int ifscope) |
1061 | { |
1062 | struct ifaddr *result = NULL; |
1063 | |
1064 | ifnet_head_lock_shared(); |
1065 | |
1066 | result = ifa_ifwithaddr_scoped_locked(addr, ifscope); |
1067 | |
1068 | ifnet_head_done(); |
1069 | |
1070 | return (result); |
1071 | } |
1072 | |
1073 | struct ifaddr * |
1074 | ifa_ifwithnet(const struct sockaddr *addr) |
1075 | { |
1076 | return (ifa_ifwithnet_common(addr, IFSCOPE_NONE)); |
1077 | } |
1078 | |
1079 | struct ifaddr * |
1080 | ifa_ifwithnet_scoped(const struct sockaddr *addr, unsigned int ifscope) |
1081 | { |
1082 | return (ifa_ifwithnet_common(addr, ifscope)); |
1083 | } |
1084 | |
1085 | /* |
1086 | * Find an interface on a specific network. If many, choice |
1087 | * is most specific found. |
1088 | */ |
1089 | static struct ifaddr * |
1090 | ifa_ifwithnet_common(const struct sockaddr *addr, unsigned int ifscope) |
1091 | { |
1092 | struct ifnet *ifp; |
1093 | struct ifaddr *ifa = NULL; |
1094 | struct ifaddr *ifa_maybe = NULL; |
1095 | u_int af = addr->sa_family; |
1096 | const char *addr_data = addr->sa_data, *cplim; |
1097 | |
1098 | #if INET6 |
1099 | if (af != AF_INET && af != AF_INET6) |
1100 | #else |
1101 | if (af != AF_INET) |
1102 | #endif /* !INET6 */ |
1103 | ifscope = IFSCOPE_NONE; |
1104 | |
1105 | ifnet_head_lock_shared(); |
1106 | /* |
1107 | * AF_LINK addresses can be looked up directly by their index number, |
1108 | * so do that if we can. |
1109 | */ |
1110 | if (af == AF_LINK) { |
1111 | const struct sockaddr_dl *sdl = |
1112 | (const struct sockaddr_dl *)(uintptr_t)(size_t)addr; |
1113 | if (sdl->sdl_index && sdl->sdl_index <= if_index) { |
1114 | ifa = ifnet_addrs[sdl->sdl_index - 1]; |
1115 | if (ifa != NULL) |
1116 | IFA_ADDREF(ifa); |
1117 | |
1118 | ifnet_head_done(); |
1119 | return (ifa); |
1120 | } |
1121 | } |
1122 | |
1123 | /* |
1124 | * Scan though each interface, looking for ones that have |
1125 | * addresses in this address family. |
1126 | */ |
1127 | for (ifp = ifnet_head.tqh_first; ifp; ifp = ifp->if_link.tqe_next) { |
1128 | ifnet_lock_shared(ifp); |
1129 | for (ifa = ifp->if_addrhead.tqh_first; ifa; |
1130 | ifa = ifa->ifa_link.tqe_next) { |
1131 | const char *cp, *cp2, *cp3; |
1132 | |
1133 | IFA_LOCK(ifa); |
1134 | if (ifa->ifa_addr == NULL || |
1135 | ifa->ifa_addr->sa_family != af) { |
1136 | next: |
1137 | IFA_UNLOCK(ifa); |
1138 | continue; |
1139 | } |
1140 | /* |
1141 | * If we're looking up with a scope, |
1142 | * find using a matching interface. |
1143 | */ |
1144 | if (ifscope != IFSCOPE_NONE && |
1145 | ifp->if_index != ifscope) { |
1146 | IFA_UNLOCK(ifa); |
1147 | continue; |
1148 | } |
1149 | |
1150 | /* |
1151 | * Scan all the bits in the ifa's address. |
1152 | * If a bit dissagrees with what we are |
1153 | * looking for, mask it with the netmask |
1154 | * to see if it really matters. |
1155 | * (A byte at a time) |
1156 | */ |
1157 | if (ifa->ifa_netmask == 0) { |
1158 | IFA_UNLOCK(ifa); |
1159 | continue; |
1160 | } |
1161 | cp = addr_data; |
1162 | cp2 = ifa->ifa_addr->sa_data; |
1163 | cp3 = ifa->ifa_netmask->sa_data; |
1164 | cplim = ifa->ifa_netmask->sa_len + |
1165 | (char *)ifa->ifa_netmask; |
1166 | while (cp3 < cplim) |
1167 | if ((*cp++ ^ *cp2++) & *cp3++) |
1168 | goto next; /* next address! */ |
1169 | /* |
1170 | * If the netmask of what we just found |
1171 | * is more specific than what we had before |
1172 | * (if we had one) then remember the new one |
1173 | * before continuing to search |
1174 | * for an even better one. |
1175 | */ |
1176 | if (ifa_maybe == NULL || |
1177 | rn_refines((caddr_t)ifa->ifa_netmask, |
1178 | (caddr_t)ifa_maybe->ifa_netmask)) { |
1179 | IFA_ADDREF_LOCKED(ifa); /* ifa_maybe */ |
1180 | IFA_UNLOCK(ifa); |
1181 | if (ifa_maybe != NULL) |
1182 | IFA_REMREF(ifa_maybe); |
1183 | ifa_maybe = ifa; |
1184 | } else { |
1185 | IFA_UNLOCK(ifa); |
1186 | } |
1187 | IFA_LOCK_ASSERT_NOTHELD(ifa); |
1188 | } |
1189 | ifnet_lock_done(ifp); |
1190 | |
1191 | if (ifa != NULL) |
1192 | break; |
1193 | } |
1194 | ifnet_head_done(); |
1195 | |
1196 | if (ifa == NULL) |
1197 | ifa = ifa_maybe; |
1198 | else if (ifa_maybe != NULL) |
1199 | IFA_REMREF(ifa_maybe); |
1200 | |
1201 | return (ifa); |
1202 | } |
1203 | |
1204 | /* |
1205 | * Find an interface address specific to an interface best matching |
1206 | * a given address applying same source address selection rules |
1207 | * as done in the kernel for implicit source address binding |
1208 | */ |
1209 | struct ifaddr * |
1210 | ifaof_ifpforaddr_select(const struct sockaddr *addr, struct ifnet *ifp) |
1211 | { |
1212 | u_int af = addr->sa_family; |
1213 | |
1214 | if (af == AF_INET6) |
1215 | return (in6_selectsrc_core_ifa(__DECONST(struct sockaddr_in6 *, addr), ifp, 0)); |
1216 | |
1217 | return (ifaof_ifpforaddr(addr, ifp)); |
1218 | } |
1219 | |
1220 | /* |
1221 | * Find an interface address specific to an interface best matching |
1222 | * a given address without regards to source address selection. |
1223 | * |
1224 | * This is appropriate for use-cases where we just want to update/init |
1225 | * some data structure like routing table entries. |
1226 | */ |
1227 | struct ifaddr * |
1228 | ifaof_ifpforaddr(const struct sockaddr *addr, struct ifnet *ifp) |
1229 | { |
1230 | struct ifaddr *ifa = NULL; |
1231 | const char *cp, *cp2, *cp3; |
1232 | char *cplim; |
1233 | struct ifaddr *ifa_maybe = NULL; |
1234 | struct ifaddr *better_ifa_maybe = NULL; |
1235 | u_int af = addr->sa_family; |
1236 | |
1237 | if (af >= AF_MAX) |
1238 | return (NULL); |
1239 | |
1240 | ifnet_lock_shared(ifp); |
1241 | for (ifa = ifp->if_addrhead.tqh_first; ifa; |
1242 | ifa = ifa->ifa_link.tqe_next) { |
1243 | IFA_LOCK(ifa); |
1244 | if (ifa->ifa_addr->sa_family != af) { |
1245 | IFA_UNLOCK(ifa); |
1246 | continue; |
1247 | } |
1248 | if (ifa_maybe == NULL) { |
1249 | IFA_ADDREF_LOCKED(ifa); /* for ifa_maybe */ |
1250 | ifa_maybe = ifa; |
1251 | } |
1252 | if (ifa->ifa_netmask == 0) { |
1253 | if (ifa_equal(addr, ifa->ifa_addr) || |
1254 | ifa_equal(addr, ifa->ifa_dstaddr)) { |
1255 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
1256 | IFA_UNLOCK(ifa); |
1257 | break; |
1258 | } |
1259 | IFA_UNLOCK(ifa); |
1260 | continue; |
1261 | } |
1262 | if (ifp->if_flags & IFF_POINTOPOINT) { |
1263 | if (ifa_equal(addr, ifa->ifa_dstaddr)) { |
1264 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
1265 | IFA_UNLOCK(ifa); |
1266 | break; |
1267 | } |
1268 | } else { |
1269 | if (ifa_equal(addr, ifa->ifa_addr)) { |
1270 | /* exact match */ |
1271 | IFA_ADDREF_LOCKED(ifa); /* for caller */ |
1272 | IFA_UNLOCK(ifa); |
1273 | break; |
1274 | } |
1275 | cp = addr->sa_data; |
1276 | cp2 = ifa->ifa_addr->sa_data; |
1277 | cp3 = ifa->ifa_netmask->sa_data; |
1278 | cplim = ifa->ifa_netmask->sa_len + |
1279 | (char *)ifa->ifa_netmask; |
1280 | for (; cp3 < cplim; cp3++) |
1281 | if ((*cp++ ^ *cp2++) & *cp3) |
1282 | break; |
1283 | if (cp3 == cplim) { |
1284 | /* subnet match */ |
1285 | if (better_ifa_maybe == NULL) { |
1286 | /* for better_ifa_maybe */ |
1287 | IFA_ADDREF_LOCKED(ifa); |
1288 | better_ifa_maybe = ifa; |
1289 | } |
1290 | } |
1291 | } |
1292 | IFA_UNLOCK(ifa); |
1293 | } |
1294 | |
1295 | if (ifa == NULL) { |
1296 | if (better_ifa_maybe != NULL) { |
1297 | ifa = better_ifa_maybe; |
1298 | better_ifa_maybe = NULL; |
1299 | } else { |
1300 | ifa = ifa_maybe; |
1301 | ifa_maybe = NULL; |
1302 | } |
1303 | } |
1304 | |
1305 | ifnet_lock_done(ifp); |
1306 | |
1307 | if (better_ifa_maybe != NULL) |
1308 | IFA_REMREF(better_ifa_maybe); |
1309 | if (ifa_maybe != NULL) |
1310 | IFA_REMREF(ifa_maybe); |
1311 | |
1312 | return (ifa); |
1313 | } |
1314 | |
1315 | #include <net/route.h> |
1316 | |
1317 | /* |
1318 | * Default action when installing a route with a Link Level gateway. |
1319 | * Lookup an appropriate real ifa to point to. |
1320 | * This should be moved to /sys/net/link.c eventually. |
1321 | */ |
1322 | void |
1323 | link_rtrequest(int cmd, struct rtentry *rt, struct sockaddr *sa) |
1324 | { |
1325 | struct ifaddr *ifa; |
1326 | struct sockaddr *dst; |
1327 | struct ifnet *ifp; |
1328 | void (*ifa_rtrequest)(int, struct rtentry *, struct sockaddr *); |
1329 | |
1330 | LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED); |
1331 | RT_LOCK_ASSERT_HELD(rt); |
1332 | |
1333 | if (cmd != RTM_ADD || ((ifa = rt->rt_ifa) == 0) || |
1334 | ((ifp = ifa->ifa_ifp) == 0) || ((dst = rt_key(rt)) == 0)) |
1335 | return; |
1336 | |
1337 | /* Become a regular mutex, just in case */ |
1338 | RT_CONVERT_LOCK(rt); |
1339 | |
1340 | ifa = ifaof_ifpforaddr(dst, ifp); |
1341 | if (ifa) { |
1342 | rtsetifa(rt, ifa); |
1343 | IFA_LOCK_SPIN(ifa); |
1344 | ifa_rtrequest = ifa->ifa_rtrequest; |
1345 | IFA_UNLOCK(ifa); |
1346 | if (ifa_rtrequest != NULL && ifa_rtrequest != link_rtrequest) |
1347 | ifa_rtrequest(cmd, rt, sa); |
1348 | IFA_REMREF(ifa); |
1349 | } |
1350 | } |
1351 | |
1352 | /* |
1353 | * if_updown will set the interface up or down. It will |
1354 | * prevent other up/down events from occurring until this |
1355 | * up/down event has completed. |
1356 | * |
1357 | * Caller must lock ifnet. This function will drop the |
1358 | * lock. This allows ifnet_set_flags to set the rest of |
1359 | * the flags after we change the up/down state without |
1360 | * dropping the interface lock between setting the |
1361 | * up/down state and updating the rest of the flags. |
1362 | */ |
1363 | __private_extern__ void |
1364 | if_updown( struct ifnet *ifp, int up) |
1365 | { |
1366 | int i; |
1367 | struct ifaddr **ifa; |
1368 | struct timespec tv; |
1369 | struct ifclassq *ifq = &ifp->if_snd; |
1370 | |
1371 | /* Wait until no one else is changing the up/down state */ |
1372 | while ((ifp->if_eflags & IFEF_UPDOWNCHANGE) != 0) { |
1373 | tv.tv_sec = 0; |
1374 | tv.tv_nsec = NSEC_PER_SEC / 10; |
1375 | ifnet_lock_done(ifp); |
1376 | msleep(&ifp->if_eflags, NULL, 0, "if_updown" , &tv); |
1377 | ifnet_lock_exclusive(ifp); |
1378 | } |
1379 | |
1380 | /* Verify that the interface isn't already in the right state */ |
1381 | if ((!up && (ifp->if_flags & IFF_UP) == 0) || |
1382 | (up && (ifp->if_flags & IFF_UP) == IFF_UP)) { |
1383 | return; |
1384 | } |
1385 | |
1386 | /* Indicate that the up/down state is changing */ |
1387 | ifp->if_eflags |= IFEF_UPDOWNCHANGE; |
1388 | |
1389 | /* Mark interface up or down */ |
1390 | if (up) { |
1391 | ifp->if_flags |= IFF_UP; |
1392 | } else { |
1393 | ifp->if_flags &= ~IFF_UP; |
1394 | } |
1395 | |
1396 | ifnet_touch_lastchange(ifp); |
1397 | ifnet_touch_lastupdown(ifp); |
1398 | |
1399 | /* Drop the lock to notify addresses and route */ |
1400 | ifnet_lock_done(ifp); |
1401 | |
1402 | IFCQ_LOCK(ifq); |
1403 | if_qflush(ifp, 1); |
1404 | |
1405 | /* Inform all transmit queues about the new link state */ |
1406 | ifnet_update_sndq(ifq, up ? CLASSQ_EV_LINK_UP : CLASSQ_EV_LINK_DOWN); |
1407 | IFCQ_UNLOCK(ifq); |
1408 | |
1409 | if (ifnet_get_address_list(ifp, &ifa) == 0) { |
1410 | for (i = 0; ifa[i] != 0; i++) { |
1411 | pfctlinput(up ? PRC_IFUP : PRC_IFDOWN, ifa[i]->ifa_addr); |
1412 | } |
1413 | ifnet_free_address_list(ifa); |
1414 | } |
1415 | rt_ifmsg(ifp); |
1416 | |
1417 | /* Aquire the lock to clear the changing flag */ |
1418 | ifnet_lock_exclusive(ifp); |
1419 | ifp->if_eflags &= ~IFEF_UPDOWNCHANGE; |
1420 | wakeup(&ifp->if_eflags); |
1421 | } |
1422 | |
1423 | /* |
1424 | * Mark an interface down and notify protocols of |
1425 | * the transition. |
1426 | */ |
1427 | void |
1428 | if_down( |
1429 | struct ifnet *ifp) |
1430 | { |
1431 | ifnet_lock_exclusive(ifp); |
1432 | if_updown(ifp, 0); |
1433 | ifnet_lock_done(ifp); |
1434 | } |
1435 | |
1436 | /* |
1437 | * Mark an interface up and notify protocols of |
1438 | * the transition. |
1439 | */ |
1440 | void |
1441 | if_up( |
1442 | struct ifnet *ifp) |
1443 | { |
1444 | ifnet_lock_exclusive(ifp); |
1445 | if_updown(ifp, 1); |
1446 | ifnet_lock_done(ifp); |
1447 | } |
1448 | |
1449 | /* |
1450 | * Flush an interface queue. |
1451 | */ |
1452 | void |
1453 | if_qflush(struct ifnet *ifp, int ifq_locked) |
1454 | { |
1455 | struct ifclassq *ifq = &ifp->if_snd; |
1456 | |
1457 | if (!ifq_locked) |
1458 | IFCQ_LOCK(ifq); |
1459 | |
1460 | if (IFCQ_IS_ENABLED(ifq)) |
1461 | IFCQ_PURGE(ifq); |
1462 | |
1463 | VERIFY(IFCQ_IS_EMPTY(ifq)); |
1464 | |
1465 | if (!ifq_locked) |
1466 | IFCQ_UNLOCK(ifq); |
1467 | } |
1468 | |
1469 | void |
1470 | if_qflush_sc(struct ifnet *ifp, mbuf_svc_class_t sc, u_int32_t flow, |
1471 | u_int32_t *packets, u_int32_t *bytes, int ifq_locked) |
1472 | { |
1473 | struct ifclassq *ifq = &ifp->if_snd; |
1474 | u_int32_t cnt = 0, len = 0; |
1475 | u_int32_t a_cnt = 0, a_len = 0; |
1476 | |
1477 | VERIFY(sc == MBUF_SC_UNSPEC || MBUF_VALID_SC(sc)); |
1478 | VERIFY(flow != 0); |
1479 | |
1480 | if (!ifq_locked) |
1481 | IFCQ_LOCK(ifq); |
1482 | |
1483 | if (IFCQ_IS_ENABLED(ifq)) |
1484 | IFCQ_PURGE_SC(ifq, sc, flow, cnt, len); |
1485 | |
1486 | if (!ifq_locked) |
1487 | IFCQ_UNLOCK(ifq); |
1488 | |
1489 | if (packets != NULL) |
1490 | *packets = cnt + a_cnt; |
1491 | if (bytes != NULL) |
1492 | *bytes = len + a_len; |
1493 | } |
1494 | |
1495 | /* |
1496 | * Extracts interface unit number and name from string, returns -1 upon failure. |
1497 | * Upon success, returns extracted unit number, and interface name in dst. |
1498 | */ |
1499 | int |
1500 | (const char *src, char *dst, size_t dstlen, int *unit) |
1501 | { |
1502 | const char *cp; |
1503 | size_t len, m; |
1504 | char c; |
1505 | int u; |
1506 | |
1507 | if (src == NULL || dst == NULL || dstlen == 0 || unit == NULL) |
1508 | return (-1); |
1509 | |
1510 | len = strlen(src); |
1511 | if (len < 2 || len > dstlen) |
1512 | return (-1); |
1513 | cp = src + len - 1; |
1514 | c = *cp; |
1515 | if (c < '0' || c > '9') |
1516 | return (-1); /* trailing garbage */ |
1517 | u = 0; |
1518 | m = 1; |
1519 | do { |
1520 | if (cp == src) |
1521 | return (-1); /* no interface name */ |
1522 | u += (c - '0') * m; |
1523 | if (u > 1000000) |
1524 | return (-1); /* number is unreasonable */ |
1525 | m *= 10; |
1526 | c = *--cp; |
1527 | } while (c >= '0' && c <= '9'); |
1528 | len = cp - src + 1; |
1529 | bcopy(src, dst, len); |
1530 | dst[len] = '\0'; |
1531 | *unit = u; |
1532 | |
1533 | return (0); |
1534 | } |
1535 | |
1536 | /* |
1537 | * Map interface name to |
1538 | * interface structure pointer. |
1539 | */ |
1540 | static struct ifnet * |
1541 | ifunit_common(const char *name, boolean_t hold) |
1542 | { |
1543 | char namebuf[IFNAMSIZ + 1]; |
1544 | struct ifnet *ifp; |
1545 | int unit; |
1546 | |
1547 | if (ifunit_extract(name, namebuf, sizeof (namebuf), &unit) < 0) |
1548 | return (NULL); |
1549 | |
1550 | /* for safety, since we use strcmp() below */ |
1551 | namebuf[sizeof (namebuf) - 1] = '\0'; |
1552 | |
1553 | /* |
1554 | * Now search all the interfaces for this name/number |
1555 | */ |
1556 | ifnet_head_lock_shared(); |
1557 | TAILQ_FOREACH(ifp, &ifnet_head, if_link) { |
1558 | /* |
1559 | * Use strcmp() rather than strncmp() here, |
1560 | * since we want to match the entire string. |
1561 | */ |
1562 | if (strcmp(ifp->if_name, namebuf)) |
1563 | continue; |
1564 | if (unit == ifp->if_unit) |
1565 | break; |
1566 | } |
1567 | |
1568 | /* if called from ifunit_ref() and ifnet is not attached, bail */ |
1569 | if (hold && ifp != NULL && !ifnet_is_attached(ifp, 1)) |
1570 | ifp = NULL; |
1571 | |
1572 | ifnet_head_done(); |
1573 | return (ifp); |
1574 | } |
1575 | |
1576 | struct ifnet * |
1577 | ifunit(const char *name) |
1578 | { |
1579 | return (ifunit_common(name, FALSE)); |
1580 | } |
1581 | |
1582 | /* |
1583 | * Similar to ifunit(), except that we hold an I/O reference count on an |
1584 | * attached interface, which must later be released via ifnet_decr_iorefcnt(). |
1585 | * Will return NULL unless interface exists and is fully attached. |
1586 | */ |
1587 | struct ifnet * |
1588 | ifunit_ref(const char *name) |
1589 | { |
1590 | return (ifunit_common(name, TRUE)); |
1591 | } |
1592 | |
1593 | /* |
1594 | * Map interface name in a sockaddr_dl to |
1595 | * interface structure pointer. |
1596 | */ |
1597 | struct ifnet * |
1598 | if_withname(struct sockaddr *sa) |
1599 | { |
1600 | char ifname[IFNAMSIZ+1]; |
1601 | struct sockaddr_dl *sdl = (struct sockaddr_dl *)(void *)sa; |
1602 | |
1603 | if ((sa->sa_family != AF_LINK) || (sdl->sdl_nlen == 0) || |
1604 | (sdl->sdl_nlen > IFNAMSIZ)) |
1605 | return (NULL); |
1606 | |
1607 | /* |
1608 | * ifunit wants a null-terminated name. It may not be null-terminated |
1609 | * in the sockaddr. We don't want to change the caller's sockaddr, |
1610 | * and there might not be room to put the trailing null anyway, so we |
1611 | * make a local copy that we know we can null terminate safely. |
1612 | */ |
1613 | |
1614 | bcopy(sdl->sdl_data, ifname, sdl->sdl_nlen); |
1615 | ifname[sdl->sdl_nlen] = '\0'; |
1616 | return (ifunit(ifname)); |
1617 | } |
1618 | |
1619 | static __attribute__((noinline)) int |
1620 | ifioctl_ifconf(u_long cmd, caddr_t data) |
1621 | { |
1622 | int error = 0; |
1623 | |
1624 | switch (cmd) { |
1625 | case OSIOCGIFCONF32: /* struct ifconf32 */ |
1626 | case SIOCGIFCONF32: { /* struct ifconf32 */ |
1627 | struct ifconf32 ifc; |
1628 | bcopy(data, &ifc, sizeof (ifc)); |
1629 | error = ifconf(cmd, CAST_USER_ADDR_T(ifc.ifc_req), |
1630 | &ifc.ifc_len); |
1631 | bcopy(&ifc, data, sizeof (ifc)); |
1632 | break; |
1633 | } |
1634 | |
1635 | case SIOCGIFCONF64: /* struct ifconf64 */ |
1636 | case OSIOCGIFCONF64: { /* struct ifconf64 */ |
1637 | struct ifconf64 ifc; |
1638 | bcopy(data, &ifc, sizeof (ifc)); |
1639 | error = ifconf(cmd, ifc.ifc_req, &ifc.ifc_len); |
1640 | bcopy(&ifc, data, sizeof (ifc)); |
1641 | break; |
1642 | } |
1643 | |
1644 | default: |
1645 | VERIFY(0); |
1646 | /* NOTREACHED */ |
1647 | } |
1648 | |
1649 | return (error); |
1650 | } |
1651 | |
1652 | static __attribute__((noinline)) int |
1653 | ifioctl_ifclone(u_long cmd, caddr_t data) |
1654 | { |
1655 | int error = 0; |
1656 | |
1657 | switch (cmd) { |
1658 | case SIOCIFGCLONERS32: { /* struct if_clonereq32 */ |
1659 | struct if_clonereq32 ifcr; |
1660 | bcopy(data, &ifcr, sizeof (ifcr)); |
1661 | error = if_clone_list(ifcr.ifcr_count, &ifcr.ifcr_total, |
1662 | CAST_USER_ADDR_T(ifcr.ifcru_buffer)); |
1663 | bcopy(&ifcr, data, sizeof (ifcr)); |
1664 | break; |
1665 | } |
1666 | |
1667 | case SIOCIFGCLONERS64: { /* struct if_clonereq64 */ |
1668 | struct if_clonereq64 ifcr; |
1669 | bcopy(data, &ifcr, sizeof (ifcr)); |
1670 | error = if_clone_list(ifcr.ifcr_count, &ifcr.ifcr_total, |
1671 | ifcr.ifcru_buffer); |
1672 | bcopy(&ifcr, data, sizeof (ifcr)); |
1673 | break; |
1674 | } |
1675 | |
1676 | default: |
1677 | VERIFY(0); |
1678 | /* NOTREACHED */ |
1679 | } |
1680 | |
1681 | return (error); |
1682 | } |
1683 | |
1684 | static __attribute__((noinline)) int |
1685 | ifioctl_ifdesc(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) |
1686 | { |
1687 | struct if_descreq *ifdr = (struct if_descreq *)(void *)data; |
1688 | u_int32_t ifdr_len; |
1689 | int error = 0; |
1690 | |
1691 | VERIFY(ifp != NULL); |
1692 | |
1693 | switch (cmd) { |
1694 | case SIOCSIFDESC: { /* struct if_descreq */ |
1695 | if ((error = proc_suser(p)) != 0) |
1696 | break; |
1697 | |
1698 | ifnet_lock_exclusive(ifp); |
1699 | bcopy(&ifdr->ifdr_len, &ifdr_len, sizeof (ifdr_len)); |
1700 | if (ifdr_len > sizeof (ifdr->ifdr_desc) || |
1701 | ifdr_len > ifp->if_desc.ifd_maxlen) { |
1702 | error = EINVAL; |
1703 | ifnet_lock_done(ifp); |
1704 | break; |
1705 | } |
1706 | |
1707 | bzero(ifp->if_desc.ifd_desc, ifp->if_desc.ifd_maxlen); |
1708 | if ((ifp->if_desc.ifd_len = ifdr_len) > 0) { |
1709 | bcopy(ifdr->ifdr_desc, ifp->if_desc.ifd_desc, |
1710 | MIN(ifdr_len, ifp->if_desc.ifd_maxlen)); |
1711 | } |
1712 | ifnet_lock_done(ifp); |
1713 | break; |
1714 | } |
1715 | |
1716 | case SIOCGIFDESC: { /* struct if_descreq */ |
1717 | ifnet_lock_shared(ifp); |
1718 | ifdr_len = MIN(ifp->if_desc.ifd_len, sizeof (ifdr->ifdr_desc)); |
1719 | bcopy(&ifdr_len, &ifdr->ifdr_len, sizeof (ifdr_len)); |
1720 | bzero(&ifdr->ifdr_desc, sizeof (ifdr->ifdr_desc)); |
1721 | if (ifdr_len > 0) { |
1722 | bcopy(ifp->if_desc.ifd_desc, ifdr->ifdr_desc, ifdr_len); |
1723 | } |
1724 | ifnet_lock_done(ifp); |
1725 | break; |
1726 | } |
1727 | |
1728 | default: |
1729 | VERIFY(0); |
1730 | /* NOTREACHED */ |
1731 | } |
1732 | |
1733 | return (error); |
1734 | } |
1735 | |
1736 | static __attribute__((noinline)) int |
1737 | ifioctl_linkparams(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) |
1738 | { |
1739 | struct if_linkparamsreq *iflpr = |
1740 | (struct if_linkparamsreq *)(void *)data; |
1741 | struct ifclassq *ifq; |
1742 | int error = 0; |
1743 | |
1744 | VERIFY(ifp != NULL); |
1745 | ifq = &ifp->if_snd; |
1746 | |
1747 | switch (cmd) { |
1748 | case SIOCSIFLINKPARAMS: { /* struct if_linkparamsreq */ |
1749 | struct tb_profile tb = { 0, 0, 0 }; |
1750 | |
1751 | if ((error = proc_suser(p)) != 0) |
1752 | break; |
1753 | |
1754 | |
1755 | IFCQ_LOCK(ifq); |
1756 | if (!IFCQ_IS_READY(ifq)) { |
1757 | error = ENXIO; |
1758 | IFCQ_UNLOCK(ifq); |
1759 | break; |
1760 | } |
1761 | bcopy(&iflpr->iflpr_output_tbr_rate, &tb.rate, |
1762 | sizeof (tb.rate)); |
1763 | bcopy(&iflpr->iflpr_output_tbr_percent, &tb.percent, |
1764 | sizeof (tb.percent)); |
1765 | error = ifclassq_tbr_set(ifq, &tb, TRUE); |
1766 | IFCQ_UNLOCK(ifq); |
1767 | break; |
1768 | } |
1769 | |
1770 | case SIOCGIFLINKPARAMS: { /* struct if_linkparamsreq */ |
1771 | u_int32_t sched_type = PKTSCHEDT_NONE, flags = 0; |
1772 | u_int64_t tbr_bw = 0, tbr_pct = 0; |
1773 | |
1774 | IFCQ_LOCK(ifq); |
1775 | |
1776 | if (IFCQ_IS_ENABLED(ifq)) |
1777 | sched_type = ifq->ifcq_type; |
1778 | |
1779 | bcopy(&sched_type, &iflpr->iflpr_output_sched, |
1780 | sizeof (iflpr->iflpr_output_sched)); |
1781 | |
1782 | if (IFCQ_TBR_IS_ENABLED(ifq)) { |
1783 | tbr_bw = ifq->ifcq_tbr.tbr_rate_raw; |
1784 | tbr_pct = ifq->ifcq_tbr.tbr_percent; |
1785 | } |
1786 | bcopy(&tbr_bw, &iflpr->iflpr_output_tbr_rate, |
1787 | sizeof (iflpr->iflpr_output_tbr_rate)); |
1788 | bcopy(&tbr_pct, &iflpr->iflpr_output_tbr_percent, |
1789 | sizeof (iflpr->iflpr_output_tbr_percent)); |
1790 | IFCQ_UNLOCK(ifq); |
1791 | |
1792 | if (ifp->if_output_sched_model == |
1793 | IFNET_SCHED_MODEL_DRIVER_MANAGED) |
1794 | flags |= IFLPRF_DRVMANAGED; |
1795 | bcopy(&flags, &iflpr->iflpr_flags, sizeof (iflpr->iflpr_flags)); |
1796 | bcopy(&ifp->if_output_bw, &iflpr->iflpr_output_bw, |
1797 | sizeof (iflpr->iflpr_output_bw)); |
1798 | bcopy(&ifp->if_input_bw, &iflpr->iflpr_input_bw, |
1799 | sizeof (iflpr->iflpr_input_bw)); |
1800 | bcopy(&ifp->if_output_lt, &iflpr->iflpr_output_lt, |
1801 | sizeof (iflpr->iflpr_output_lt)); |
1802 | bcopy(&ifp->if_input_lt, &iflpr->iflpr_input_lt, |
1803 | sizeof (iflpr->iflpr_input_lt)); |
1804 | break; |
1805 | } |
1806 | |
1807 | default: |
1808 | VERIFY(0); |
1809 | /* NOTREACHED */ |
1810 | } |
1811 | |
1812 | return (error); |
1813 | } |
1814 | |
1815 | static __attribute__((noinline)) int |
1816 | ifioctl_qstats(struct ifnet *ifp, u_long cmd, caddr_t data) |
1817 | { |
1818 | struct if_qstatsreq *ifqr = (struct if_qstatsreq *)(void *)data; |
1819 | u_int32_t ifqr_len, ifqr_slot; |
1820 | int error = 0; |
1821 | |
1822 | VERIFY(ifp != NULL); |
1823 | |
1824 | switch (cmd) { |
1825 | case SIOCGIFQUEUESTATS: { /* struct if_qstatsreq */ |
1826 | bcopy(&ifqr->ifqr_slot, &ifqr_slot, sizeof (ifqr_slot)); |
1827 | bcopy(&ifqr->ifqr_len, &ifqr_len, sizeof (ifqr_len)); |
1828 | error = ifclassq_getqstats(&ifp->if_snd, ifqr_slot, |
1829 | ifqr->ifqr_buf, &ifqr_len); |
1830 | if (error != 0) |
1831 | ifqr_len = 0; |
1832 | bcopy(&ifqr_len, &ifqr->ifqr_len, sizeof (ifqr_len)); |
1833 | break; |
1834 | } |
1835 | |
1836 | default: |
1837 | VERIFY(0); |
1838 | /* NOTREACHED */ |
1839 | } |
1840 | |
1841 | return (error); |
1842 | } |
1843 | |
1844 | static __attribute__((noinline)) int |
1845 | ifioctl_throttle(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) |
1846 | { |
1847 | struct if_throttlereq *ifthr = (struct if_throttlereq *)(void *)data; |
1848 | u_int32_t ifthr_level; |
1849 | int error = 0; |
1850 | |
1851 | VERIFY(ifp != NULL); |
1852 | |
1853 | switch (cmd) { |
1854 | case SIOCSIFTHROTTLE: { /* struct if_throttlereq */ |
1855 | /* |
1856 | * XXX: Use priv_check_cred() instead of root check? |
1857 | */ |
1858 | if ((error = proc_suser(p)) != 0) |
1859 | break; |
1860 | |
1861 | bcopy(&ifthr->ifthr_level, &ifthr_level, sizeof (ifthr_level)); |
1862 | error = ifnet_set_throttle(ifp, ifthr_level); |
1863 | if (error == EALREADY) |
1864 | error = 0; |
1865 | break; |
1866 | } |
1867 | |
1868 | case SIOCGIFTHROTTLE: { /* struct if_throttlereq */ |
1869 | if ((error = ifnet_get_throttle(ifp, &ifthr_level)) == 0) { |
1870 | bcopy(&ifthr_level, &ifthr->ifthr_level, |
1871 | sizeof (ifthr_level)); |
1872 | } |
1873 | break; |
1874 | } |
1875 | |
1876 | default: |
1877 | VERIFY(0); |
1878 | /* NOTREACHED */ |
1879 | } |
1880 | |
1881 | return (error); |
1882 | } |
1883 | |
1884 | static int |
1885 | ifioctl_getnetagents(struct ifnet *ifp, u_int32_t *count, user_addr_t uuid_p) |
1886 | { |
1887 | int error = 0; |
1888 | u_int32_t index = 0; |
1889 | u_int32_t valid_netagent_count = 0; |
1890 | *count = 0; |
1891 | |
1892 | ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_SHARED); |
1893 | |
1894 | if (ifp->if_agentids != NULL) { |
1895 | for (index = 0; index < ifp->if_agentcount; index++) { |
1896 | uuid_t *netagent_uuid = &(ifp->if_agentids[index]); |
1897 | if (!uuid_is_null(*netagent_uuid)) { |
1898 | if (uuid_p != USER_ADDR_NULL) { |
1899 | error = copyout(netagent_uuid, |
1900 | uuid_p + sizeof(uuid_t) * valid_netagent_count, |
1901 | sizeof(uuid_t)); |
1902 | if (error != 0) { |
1903 | return (error); |
1904 | } |
1905 | } |
1906 | valid_netagent_count++; |
1907 | } |
1908 | } |
1909 | } |
1910 | *count = valid_netagent_count; |
1911 | |
1912 | return (0); |
1913 | } |
1914 | |
1915 | #define IF_MAXAGENTS 64 |
1916 | #define IF_AGENT_INCREMENT 8 |
1917 | static int |
1918 | if_add_netagent_locked(struct ifnet *ifp, uuid_t new_agent_uuid) |
1919 | { |
1920 | uuid_t *first_empty_slot = NULL; |
1921 | u_int32_t index = 0; |
1922 | bool already_added = FALSE; |
1923 | |
1924 | if (ifp->if_agentids != NULL) { |
1925 | for (index = 0; index < ifp->if_agentcount; index++) { |
1926 | uuid_t *netagent_uuid = &(ifp->if_agentids[index]); |
1927 | if (uuid_compare(*netagent_uuid, new_agent_uuid) == 0) { |
1928 | /* Already present, ignore */ |
1929 | already_added = TRUE; |
1930 | break; |
1931 | } |
1932 | if (first_empty_slot == NULL && |
1933 | uuid_is_null(*netagent_uuid)) { |
1934 | first_empty_slot = netagent_uuid; |
1935 | } |
1936 | } |
1937 | } |
1938 | if (already_added) { |
1939 | /* Already added agent, don't return an error */ |
1940 | return (0); |
1941 | } |
1942 | if (first_empty_slot == NULL) { |
1943 | if (ifp->if_agentcount >= IF_MAXAGENTS) { |
1944 | /* No room for another netagent UUID, bail */ |
1945 | return (ENOMEM); |
1946 | } else { |
1947 | /* Calculate new array size */ |
1948 | u_int32_t new_agent_count = |
1949 | MIN(ifp->if_agentcount + IF_AGENT_INCREMENT, |
1950 | IF_MAXAGENTS); |
1951 | |
1952 | /* Reallocate array */ |
1953 | uuid_t *new_agent_array = _REALLOC(ifp->if_agentids, |
1954 | sizeof(uuid_t) * new_agent_count, M_NETAGENT, |
1955 | M_WAITOK | M_ZERO); |
1956 | if (new_agent_array == NULL) { |
1957 | return (ENOMEM); |
1958 | } |
1959 | |
1960 | /* Save new array */ |
1961 | ifp->if_agentids = new_agent_array; |
1962 | |
1963 | /* Set first empty slot */ |
1964 | first_empty_slot = |
1965 | &(ifp->if_agentids[ifp->if_agentcount]); |
1966 | |
1967 | /* Save new array length */ |
1968 | ifp->if_agentcount = new_agent_count; |
1969 | } |
1970 | } |
1971 | uuid_copy(*first_empty_slot, new_agent_uuid); |
1972 | netagent_post_updated_interfaces(new_agent_uuid); |
1973 | return (0); |
1974 | } |
1975 | |
1976 | int |
1977 | if_add_netagent(struct ifnet *ifp, uuid_t new_agent_uuid) |
1978 | { |
1979 | VERIFY(ifp != NULL); |
1980 | |
1981 | ifnet_lock_exclusive(ifp); |
1982 | |
1983 | int error = if_add_netagent_locked(ifp, new_agent_uuid); |
1984 | |
1985 | ifnet_lock_done(ifp); |
1986 | |
1987 | return (error); |
1988 | } |
1989 | |
1990 | static int |
1991 | if_delete_netagent_locked(struct ifnet *ifp, uuid_t remove_agent_uuid) |
1992 | { |
1993 | u_int32_t index = 0; |
1994 | bool removed_agent_id = FALSE; |
1995 | |
1996 | if (ifp->if_agentids != NULL) { |
1997 | for (index = 0; index < ifp->if_agentcount; index++) { |
1998 | uuid_t *netagent_uuid = &(ifp->if_agentids[index]); |
1999 | if (uuid_compare(*netagent_uuid, |
2000 | remove_agent_uuid) == 0) { |
2001 | uuid_clear(*netagent_uuid); |
2002 | removed_agent_id = TRUE; |
2003 | break; |
2004 | } |
2005 | } |
2006 | } |
2007 | if (removed_agent_id) |
2008 | netagent_post_updated_interfaces(remove_agent_uuid); |
2009 | |
2010 | return (0); |
2011 | } |
2012 | |
2013 | int |
2014 | if_delete_netagent(struct ifnet *ifp, uuid_t remove_agent_uuid) |
2015 | { |
2016 | VERIFY(ifp != NULL); |
2017 | |
2018 | ifnet_lock_exclusive(ifp); |
2019 | |
2020 | int error = if_delete_netagent_locked(ifp, remove_agent_uuid); |
2021 | |
2022 | ifnet_lock_done(ifp); |
2023 | |
2024 | return (error); |
2025 | } |
2026 | |
2027 | boolean_t |
2028 | if_check_netagent(struct ifnet *ifp, uuid_t find_agent_uuid) |
2029 | { |
2030 | boolean_t found = FALSE; |
2031 | |
2032 | if (!ifp || uuid_is_null(find_agent_uuid)) |
2033 | return FALSE; |
2034 | |
2035 | ifnet_lock_shared(ifp); |
2036 | |
2037 | if (ifp->if_agentids != NULL) { |
2038 | for (uint32_t index = 0; index < ifp->if_agentcount; index++) { |
2039 | if (uuid_compare(ifp->if_agentids[index], find_agent_uuid) == 0) { |
2040 | found = TRUE; |
2041 | break; |
2042 | } |
2043 | } |
2044 | } |
2045 | |
2046 | ifnet_lock_done(ifp); |
2047 | |
2048 | return found; |
2049 | } |
2050 | |
2051 | static __attribute__((noinline)) int |
2052 | ifioctl_netagent(struct ifnet *ifp, u_long cmd, caddr_t data, struct proc *p) |
2053 | { |
2054 | struct if_agentidreq *ifar = (struct if_agentidreq *)(void *)data; |
2055 | union { |
2056 | struct if_agentidsreq32 s32; |
2057 | struct if_agentidsreq64 s64; |
2058 | } u; |
2059 | int error = 0; |
2060 | |
2061 | VERIFY(ifp != NULL); |
2062 | |
2063 | /* Get an io ref count if the interface is attached */ |
2064 | if (!ifnet_is_attached(ifp, 1)) { |
2065 | return (EOPNOTSUPP); |
2066 | } |
2067 | |
2068 | if (cmd == SIOCAIFAGENTID || |
2069 | cmd == SIOCDIFAGENTID) { |
2070 | ifnet_lock_exclusive(ifp); |
2071 | } else { |
2072 | ifnet_lock_shared(ifp); |
2073 | } |
2074 | |
2075 | switch (cmd) { |
2076 | case SIOCAIFAGENTID: { /* struct if_agentidreq */ |
2077 | // TODO: Use priv_check_cred() instead of root check |
2078 | if ((error = proc_suser(p)) != 0) { |
2079 | break; |
2080 | } |
2081 | error = if_add_netagent_locked(ifp, ifar->ifar_uuid); |
2082 | break; |
2083 | } |
2084 | case SIOCDIFAGENTID: { /* struct if_agentidreq */ |
2085 | // TODO: Use priv_check_cred() instead of root check |
2086 | if ((error = proc_suser(p)) != 0) { |
2087 | break; |
2088 | } |
2089 | error = if_delete_netagent_locked(ifp, ifar->ifar_uuid); |
2090 | break; |
2091 | } |
2092 | case SIOCGIFAGENTIDS32: { /* struct if_agentidsreq32 */ |
2093 | bcopy(data, &u.s32, sizeof(u.s32)); |
2094 | error = ifioctl_getnetagents(ifp, &u.s32.ifar_count, |
2095 | u.s32.ifar_uuids); |
2096 | if (error == 0) { |
2097 | bcopy(&u.s32, data, sizeof(u.s32)); |
2098 | } |
2099 | break; |
2100 | } |
2101 | case SIOCGIFAGENTIDS64: { /* struct if_agentidsreq64 */ |
2102 | bcopy(data, &u.s64, sizeof(u.s64)); |
2103 | error = ifioctl_getnetagents(ifp, &u.s64.ifar_count, |
2104 | u.s64.ifar_uuids); |
2105 | if (error == 0) { |
2106 | bcopy(&u.s64, data, sizeof(u.s64)); |
2107 | } |
2108 | break; |
2109 | } |
2110 | default: |
2111 | VERIFY(0); |
2112 | /* NOTREACHED */ |
2113 | } |
2114 | |
2115 | ifnet_lock_done(ifp); |
2116 | ifnet_decr_iorefcnt(ifp); |
2117 | |
2118 | return (error); |
2119 | } |
2120 | |
2121 | void |
2122 | ifnet_clear_netagent(uuid_t netagent_uuid) |
2123 | { |
2124 | struct ifnet *ifp = NULL; |
2125 | u_int32_t index = 0; |
2126 | |
2127 | ifnet_head_lock_shared(); |
2128 | |
2129 | TAILQ_FOREACH(ifp, &ifnet_head, if_link) { |
2130 | ifnet_lock_shared(ifp); |
2131 | if (ifp->if_agentids != NULL) { |
2132 | for (index = 0; index < ifp->if_agentcount; index++) { |
2133 | uuid_t *ifp_netagent_uuid = &(ifp->if_agentids[index]); |
2134 | if (uuid_compare(*ifp_netagent_uuid, netagent_uuid) == 0) { |
2135 | uuid_clear(*ifp_netagent_uuid); |
2136 | } |
2137 | } |
2138 | } |
2139 | ifnet_lock_done(ifp); |
2140 | } |
2141 | |
2142 | ifnet_head_done(); |
2143 | } |
2144 | |
2145 | void |
2146 | ifnet_increment_generation(ifnet_t interface) |
2147 | { |
2148 | OSIncrementAtomic(&interface->if_generation); |
2149 | } |
2150 | |
2151 | u_int32_t |
2152 | ifnet_get_generation(ifnet_t interface) |
2153 | { |
2154 | return (interface->if_generation); |
2155 | } |
2156 | |
2157 | void |
2158 | ifnet_remove_from_ordered_list(struct ifnet *ifp) |
2159 | { |
2160 | ifnet_head_assert_exclusive(); |
2161 | |
2162 | // Remove from list |
2163 | TAILQ_REMOVE(&ifnet_ordered_head, ifp, if_ordered_link); |
2164 | ifp->if_ordered_link.tqe_next = NULL; |
2165 | ifp->if_ordered_link.tqe_prev = NULL; |
2166 | |
2167 | // Update ordered count |
2168 | VERIFY(if_ordered_count > 0); |
2169 | if_ordered_count--; |
2170 | } |
2171 | |
2172 | static int |
2173 | ifnet_reset_order(u_int32_t *ordered_indices, u_int32_t count) |
2174 | { |
2175 | struct ifnet *ifp = NULL; |
2176 | int error = 0; |
2177 | |
2178 | ifnet_head_lock_exclusive(); |
2179 | for (u_int32_t order_index = 0; order_index < count; order_index++) { |
2180 | if (ordered_indices[order_index] == IFSCOPE_NONE || |
2181 | ordered_indices[order_index] > (uint32_t)if_index) { |
2182 | error = EINVAL; |
2183 | ifnet_head_done(); |
2184 | return (error); |
2185 | } |
2186 | } |
2187 | // Flush current ordered list |
2188 | for (ifp = TAILQ_FIRST(&ifnet_ordered_head); ifp != NULL; |
2189 | ifp = TAILQ_FIRST(&ifnet_ordered_head)) { |
2190 | ifnet_lock_exclusive(ifp); |
2191 | ifnet_remove_from_ordered_list(ifp); |
2192 | ifnet_lock_done(ifp); |
2193 | } |
2194 | |
2195 | VERIFY(if_ordered_count == 0); |
2196 | |
2197 | for (u_int32_t order_index = 0; order_index < count; order_index++) { |
2198 | u_int32_t interface_index = ordered_indices[order_index]; |
2199 | ifp = ifindex2ifnet[interface_index]; |
2200 | if (ifp == NULL) { |
2201 | continue; |
2202 | } |
2203 | ifnet_lock_exclusive(ifp); |
2204 | TAILQ_INSERT_TAIL(&ifnet_ordered_head, ifp, if_ordered_link); |
2205 | ifnet_lock_done(ifp); |
2206 | if_ordered_count++; |
2207 | } |
2208 | |
2209 | ifnet_head_done(); |
2210 | |
2211 | necp_update_all_clients(); |
2212 | |
2213 | return (error); |
2214 | } |
2215 | |
2216 | int |
2217 | if_set_qosmarking_mode(struct ifnet *ifp, u_int32_t mode) |
2218 | { |
2219 | int error = 0; |
2220 | u_int32_t old_mode = ifp->if_qosmarking_mode; |
2221 | |
2222 | switch (mode) { |
2223 | case IFRTYPE_QOSMARKING_MODE_NONE: |
2224 | ifp->if_qosmarking_mode = IFRTYPE_QOSMARKING_MODE_NONE; |
2225 | ifp->if_eflags &= ~IFEF_QOSMARKING_CAPABLE; |
2226 | break; |
2227 | case IFRTYPE_QOSMARKING_FASTLANE: |
2228 | ifp->if_qosmarking_mode = IFRTYPE_QOSMARKING_FASTLANE; |
2229 | ifp->if_eflags |= IFEF_QOSMARKING_CAPABLE; |
2230 | if (net_qos_policy_capable_enabled != 0) |
2231 | ifp->if_eflags |= IFEF_QOSMARKING_ENABLED; |
2232 | break; |
2233 | default: |
2234 | error = EINVAL; |
2235 | break; |
2236 | } |
2237 | if (error == 0 && old_mode != ifp->if_qosmarking_mode) { |
2238 | dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_QOS_MODE_CHANGED, |
2239 | NULL, sizeof(struct kev_dl_rrc_state)); |
2240 | |
2241 | } |
2242 | return (error); |
2243 | } |
2244 | |
2245 | static __attribute__((noinline)) int |
2246 | ifioctl_iforder(u_long cmd, caddr_t data) |
2247 | { |
2248 | int error = 0; |
2249 | u_int32_t *ordered_indices = NULL; |
2250 | if (data == NULL) { |
2251 | return (EINVAL); |
2252 | } |
2253 | |
2254 | switch (cmd) { |
2255 | case SIOCSIFORDER: { /* struct if_order */ |
2256 | struct if_order *ifo = (struct if_order *)(void *)data; |
2257 | |
2258 | if (ifo->ifo_count > (u_int32_t)if_index) { |
2259 | error = EINVAL; |
2260 | break; |
2261 | } |
2262 | |
2263 | size_t length = (ifo->ifo_count * sizeof(u_int32_t)); |
2264 | if (length > 0) { |
2265 | if (ifo->ifo_ordered_indices == USER_ADDR_NULL) { |
2266 | error = EINVAL; |
2267 | break; |
2268 | } |
2269 | ordered_indices = _MALLOC(length, M_NECP, M_WAITOK); |
2270 | if (ordered_indices == NULL) { |
2271 | error = ENOMEM; |
2272 | break; |
2273 | } |
2274 | |
2275 | error = copyin(ifo->ifo_ordered_indices, |
2276 | ordered_indices, length); |
2277 | if (error != 0) { |
2278 | break; |
2279 | } |
2280 | |
2281 | /* ordered_indices should not contain duplicates */ |
2282 | bool found_duplicate = FALSE; |
2283 | for (uint32_t i = 0; i < (ifo->ifo_count - 1) && !found_duplicate ; i++){ |
2284 | for (uint32_t j = i + 1; j < ifo->ifo_count && !found_duplicate ; j++){ |
2285 | if (ordered_indices[j] == ordered_indices[i]){ |
2286 | error = EINVAL; |
2287 | found_duplicate = TRUE; |
2288 | break; |
2289 | } |
2290 | } |
2291 | } |
2292 | if (found_duplicate) { |
2293 | break; |
2294 | } |
2295 | } |
2296 | |
2297 | error = ifnet_reset_order(ordered_indices, ifo->ifo_count); |
2298 | |
2299 | break; |
2300 | } |
2301 | |
2302 | default: { |
2303 | VERIFY(0); |
2304 | /* NOTREACHED */ |
2305 | } |
2306 | } |
2307 | |
2308 | if (ordered_indices != NULL) { |
2309 | _FREE(ordered_indices, M_NECP); |
2310 | } |
2311 | |
2312 | return (error); |
2313 | } |
2314 | |
2315 | static __attribute__((noinline)) int |
2316 | ifioctl_netsignature(struct ifnet *ifp, u_long cmd, caddr_t data) |
2317 | { |
2318 | struct if_nsreq *ifnsr = (struct if_nsreq *)(void *)data; |
2319 | u_int16_t flags; |
2320 | int error = 0; |
2321 | |
2322 | VERIFY(ifp != NULL); |
2323 | |
2324 | switch (cmd) { |
2325 | case SIOCSIFNETSIGNATURE: /* struct if_nsreq */ |
2326 | if (ifnsr->ifnsr_len > sizeof (ifnsr->ifnsr_data)) { |
2327 | error = EINVAL; |
2328 | break; |
2329 | } |
2330 | bcopy(&ifnsr->ifnsr_flags, &flags, sizeof (flags)); |
2331 | error = ifnet_set_netsignature(ifp, ifnsr->ifnsr_family, |
2332 | ifnsr->ifnsr_len, flags, ifnsr->ifnsr_data); |
2333 | break; |
2334 | |
2335 | case SIOCGIFNETSIGNATURE: /* struct if_nsreq */ |
2336 | ifnsr->ifnsr_len = sizeof (ifnsr->ifnsr_data); |
2337 | error = ifnet_get_netsignature(ifp, ifnsr->ifnsr_family, |
2338 | &ifnsr->ifnsr_len, &flags, ifnsr->ifnsr_data); |
2339 | if (error == 0) |
2340 | bcopy(&flags, &ifnsr->ifnsr_flags, sizeof (flags)); |
2341 | else |
2342 | ifnsr->ifnsr_len = 0; |
2343 | break; |
2344 | |
2345 | default: |
2346 | VERIFY(0); |
2347 | /* NOTREACHED */ |
2348 | } |
2349 | |
2350 | return (error); |
2351 | } |
2352 | |
2353 | #if INET6 |
2354 | static __attribute__((noinline)) int |
2355 | ifioctl_nat64prefix(struct ifnet *ifp, u_long cmd, caddr_t data) |
2356 | { |
2357 | struct if_nat64req *ifnat64 = (struct if_nat64req *)(void *)data; |
2358 | int error = 0; |
2359 | |
2360 | VERIFY(ifp != NULL); |
2361 | |
2362 | switch (cmd) { |
2363 | case SIOCSIFNAT64PREFIX: /* struct if_nat64req */ |
2364 | error = ifnet_set_nat64prefix(ifp, ifnat64->ifnat64_prefixes); |
2365 | if (error != 0) |
2366 | ip6stat.ip6s_clat464_plat64_pfx_setfail++; |
2367 | break; |
2368 | |
2369 | case SIOCGIFNAT64PREFIX: /* struct if_nat64req */ |
2370 | error = ifnet_get_nat64prefix(ifp, ifnat64->ifnat64_prefixes); |
2371 | if (error != 0) |
2372 | ip6stat.ip6s_clat464_plat64_pfx_getfail++; |
2373 | break; |
2374 | |
2375 | default: |
2376 | VERIFY(0); |
2377 | /* NOTREACHED */ |
2378 | } |
2379 | |
2380 | return (error); |
2381 | } |
2382 | |
2383 | static __attribute__((noinline)) int |
2384 | ifioctl_clat46addr(struct ifnet *ifp, u_long cmd, caddr_t data) |
2385 | { |
2386 | struct if_clat46req *ifclat46 = (struct if_clat46req *)(void *)data; |
2387 | struct in6_ifaddr *ia6_clat = NULL; |
2388 | int error = 0; |
2389 | |
2390 | VERIFY(ifp != NULL); |
2391 | |
2392 | switch (cmd) { |
2393 | case SIOCGIFCLAT46ADDR: |
2394 | ia6_clat = in6ifa_ifpwithflag(ifp, IN6_IFF_CLAT46); |
2395 | if (ia6_clat == NULL) { |
2396 | error = ENOENT; |
2397 | break; |
2398 | } |
2399 | |
2400 | bcopy(&ia6_clat->ia_addr.sin6_addr, &ifclat46->ifclat46_addr.v6_address, |
2401 | sizeof(ifclat46->ifclat46_addr.v6_address)); |
2402 | ifclat46->ifclat46_addr.v6_prefixlen = ia6_clat->ia_plen; |
2403 | IFA_REMREF(&ia6_clat->ia_ifa); |
2404 | break; |
2405 | default: |
2406 | VERIFY(0); |
2407 | /* NOTREACHED */ |
2408 | } |
2409 | |
2410 | return (error); |
2411 | } |
2412 | #endif |
2413 | |
2414 | |
2415 | static int |
2416 | ifioctl_get_protolist(struct ifnet *ifp, u_int32_t * ret_count, |
2417 | user_addr_t ifpl) |
2418 | { |
2419 | u_int32_t actual_count; |
2420 | u_int32_t count; |
2421 | int error = 0; |
2422 | u_int32_t *list = NULL; |
2423 | |
2424 | /* find out how many */ |
2425 | count = if_get_protolist(ifp, NULL, 0); |
2426 | if (ifpl == USER_ADDR_NULL) { |
2427 | goto done; |
2428 | } |
2429 | |
2430 | /* copy out how many there's space for */ |
2431 | if (*ret_count < count) { |
2432 | count = *ret_count; |
2433 | } |
2434 | if (count == 0) { |
2435 | goto done; |
2436 | } |
2437 | list = _MALLOC(count * sizeof(*list), M_TEMP, M_WAITOK | M_ZERO); |
2438 | if (list == NULL) { |
2439 | error = ENOMEM; |
2440 | goto done; |
2441 | } |
2442 | actual_count = if_get_protolist(ifp, list, count); |
2443 | if (actual_count < count) { |
2444 | count = actual_count; |
2445 | } |
2446 | if (count != 0) { |
2447 | error = copyout((caddr_t)list, ifpl, count * sizeof(*list)); |
2448 | } |
2449 | |
2450 | done: |
2451 | if (list != NULL) { |
2452 | if_free_protolist(list); |
2453 | } |
2454 | *ret_count = count; |
2455 | return (error); |
2456 | } |
2457 | |
2458 | static __attribute__((noinline)) int |
2459 | ifioctl_protolist(struct ifnet *ifp, u_long cmd, caddr_t data) |
2460 | { |
2461 | int error = 0; |
2462 | |
2463 | switch (cmd) { |
2464 | case SIOCGIFPROTOLIST32: { /* struct if_protolistreq32 */ |
2465 | struct if_protolistreq32 ifpl; |
2466 | |
2467 | bcopy(data, &ifpl, sizeof(ifpl)); |
2468 | if (ifpl.ifpl_reserved != 0) { |
2469 | error = EINVAL; |
2470 | break; |
2471 | } |
2472 | error = ifioctl_get_protolist(ifp, &ifpl.ifpl_count, |
2473 | CAST_USER_ADDR_T(ifpl.ifpl_list)); |
2474 | bcopy(&ifpl, data, sizeof(ifpl)); |
2475 | break; |
2476 | } |
2477 | case SIOCGIFPROTOLIST64: { /* struct if_protolistreq64 */ |
2478 | struct if_protolistreq64 ifpl; |
2479 | |
2480 | bcopy(data, &ifpl, sizeof(ifpl)); |
2481 | if (ifpl.ifpl_reserved != 0) { |
2482 | error = EINVAL; |
2483 | break; |
2484 | } |
2485 | error = ifioctl_get_protolist(ifp, &ifpl.ifpl_count, |
2486 | ifpl.ifpl_list); |
2487 | bcopy(&ifpl, data, sizeof(ifpl)); |
2488 | break; |
2489 | } |
2490 | default: |
2491 | VERIFY(0); |
2492 | /* NOTREACHED */ |
2493 | } |
2494 | |
2495 | return (error); |
2496 | } |
2497 | |
2498 | /* |
2499 | * List the ioctl()s we can perform on restricted INTCOPROC interfaces. |
2500 | */ |
2501 | static bool |
2502 | ifioctl_restrict_intcoproc(unsigned long cmd, const char *ifname, |
2503 | struct ifnet *ifp, struct proc *p) |
2504 | { |
2505 | |
2506 | if (intcoproc_unrestricted == TRUE) { |
2507 | return (false); |
2508 | } |
2509 | if (proc_pid(p) == 0) { |
2510 | return (false); |
2511 | } |
2512 | if (ifname) { |
2513 | ifp = ifunit(ifname); |
2514 | } |
2515 | if (ifp == NULL) { |
2516 | return (false); |
2517 | } |
2518 | if (!IFNET_IS_INTCOPROC(ifp)) { |
2519 | return (false); |
2520 | } |
2521 | switch (cmd) { |
2522 | case SIOCGIFBRDADDR: |
2523 | case SIOCGIFCONF32: |
2524 | case SIOCGIFCONF64: |
2525 | case SIOCGIFFLAGS: |
2526 | case SIOCGIFEFLAGS: |
2527 | case SIOCGIFCAP: |
2528 | case SIOCGIFMAC: |
2529 | case SIOCGIFMETRIC: |
2530 | case SIOCGIFMTU: |
2531 | case SIOCGIFPHYS: |
2532 | case SIOCGIFTYPE: |
2533 | case SIOCGIFFUNCTIONALTYPE: |
2534 | case SIOCGIFPSRCADDR: |
2535 | case SIOCGIFPDSTADDR: |
2536 | case SIOCGIFGENERIC: |
2537 | case SIOCGIFDEVMTU: |
2538 | case SIOCGIFVLAN: |
2539 | case SIOCGIFBOND: |
2540 | case SIOCGIFWAKEFLAGS: |
2541 | case SIOCGIFGETRTREFCNT: |
2542 | case SIOCGIFOPPORTUNISTIC: |
2543 | case SIOCGIFLINKQUALITYMETRIC: |
2544 | case SIOCGIFLOG: |
2545 | case SIOCGIFDELEGATE: |
2546 | case SIOCGIFEXPENSIVE: |
2547 | case SIOCGIFINTERFACESTATE: |
2548 | case SIOCGIFPROBECONNECTIVITY: |
2549 | case SIOCGIFTIMESTAMPENABLED: |
2550 | case SIOCGECNMODE: |
2551 | case SIOCGQOSMARKINGMODE: |
2552 | case SIOCGQOSMARKINGENABLED: |
2553 | case SIOCGIFLOWINTERNET: |
2554 | case SIOCGIFSTATUS: |
2555 | case SIOCGIFMEDIA32: |
2556 | case SIOCGIFMEDIA64: |
2557 | case SIOCGIFDESC: |
2558 | case SIOCGIFLINKPARAMS: |
2559 | case SIOCGIFQUEUESTATS: |
2560 | case SIOCGIFTHROTTLE: |
2561 | case SIOCGIFAGENTIDS32: |
2562 | case SIOCGIFAGENTIDS64: |
2563 | case SIOCGIFNETSIGNATURE: |
2564 | case SIOCGIFINFO_IN6: |
2565 | case SIOCGIFAFLAG_IN6: |
2566 | case SIOCGNBRINFO_IN6: |
2567 | case SIOCGIFALIFETIME_IN6: |
2568 | case SIOCGIFNETMASK_IN6: |
2569 | case SIOCGIFPROTOLIST32: |
2570 | case SIOCGIFPROTOLIST64: |
2571 | return (false); |
2572 | default: |
2573 | #if (DEBUG || DEVELOPMENT) |
2574 | printf("%s: cmd 0x%lx not allowed (pid %u)\n" , |
2575 | __func__, cmd, proc_pid(p)); |
2576 | #endif |
2577 | return (true); |
2578 | } |
2579 | return (false); |
2580 | } |
2581 | |
2582 | /* |
2583 | * Interface ioctls. |
2584 | * |
2585 | * Most of the routines called to handle the ioctls would end up being |
2586 | * tail-call optimized, which unfortunately causes this routine to |
2587 | * consume too much stack space; this is the reason for the "noinline" |
2588 | * attribute used on those routines. |
2589 | */ |
2590 | int |
2591 | ifioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) |
2592 | { |
2593 | char ifname[IFNAMSIZ + 1]; |
2594 | struct ifnet *ifp = NULL; |
2595 | struct ifstat *ifs = NULL; |
2596 | int error = 0; |
2597 | |
2598 | bzero(ifname, sizeof (ifname)); |
2599 | |
2600 | /* |
2601 | * ioctls which don't require ifp, or ifreq ioctls |
2602 | */ |
2603 | switch (cmd) { |
2604 | case OSIOCGIFCONF32: /* struct ifconf32 */ |
2605 | case SIOCGIFCONF32: /* struct ifconf32 */ |
2606 | case SIOCGIFCONF64: /* struct ifconf64 */ |
2607 | case OSIOCGIFCONF64: /* struct ifconf64 */ |
2608 | error = ifioctl_ifconf(cmd, data); |
2609 | goto done; |
2610 | |
2611 | case SIOCIFGCLONERS32: /* struct if_clonereq32 */ |
2612 | case SIOCIFGCLONERS64: /* struct if_clonereq64 */ |
2613 | error = ifioctl_ifclone(cmd, data); |
2614 | goto done; |
2615 | |
2616 | case SIOCGIFAGENTDATA32: /* struct netagent_req32 */ |
2617 | case SIOCGIFAGENTDATA64: /* struct netagent_req64 */ |
2618 | case SIOCGIFAGENTLIST32: /* struct netagentlist_req32 */ |
2619 | case SIOCGIFAGENTLIST64: /* struct netagentlist_req64 */ |
2620 | error = netagent_ioctl(cmd, data); |
2621 | goto done; |
2622 | |
2623 | case SIOCSIFORDER: /* struct if_order */ |
2624 | error = ifioctl_iforder(cmd, data); |
2625 | goto done; |
2626 | |
2627 | case SIOCSIFDSTADDR: /* struct ifreq */ |
2628 | case SIOCSIFADDR: /* struct ifreq */ |
2629 | case SIOCSIFBRDADDR: /* struct ifreq */ |
2630 | case SIOCSIFNETMASK: /* struct ifreq */ |
2631 | case OSIOCGIFADDR: /* struct ifreq */ |
2632 | case OSIOCGIFDSTADDR: /* struct ifreq */ |
2633 | case OSIOCGIFBRDADDR: /* struct ifreq */ |
2634 | case OSIOCGIFNETMASK: /* struct ifreq */ |
2635 | case SIOCSIFKPI: /* struct ifreq */ |
2636 | if (so->so_proto == NULL) { |
2637 | error = EOPNOTSUPP; |
2638 | goto done; |
2639 | } |
2640 | /* FALLTHRU */ |
2641 | case SIOCIFCREATE: /* struct ifreq */ |
2642 | case SIOCIFCREATE2: /* struct ifreq */ |
2643 | case SIOCIFDESTROY: /* struct ifreq */ |
2644 | case SIOCGIFFLAGS: /* struct ifreq */ |
2645 | case SIOCGIFEFLAGS: /* struct ifreq */ |
2646 | case SIOCGIFCAP: /* struct ifreq */ |
2647 | #if CONFIG_MACF_NET |
2648 | case SIOCGIFMAC: /* struct ifreq */ |
2649 | case SIOCSIFMAC: /* struct ifreq */ |
2650 | #endif /* CONFIG_MACF_NET */ |
2651 | case SIOCGIFMETRIC: /* struct ifreq */ |
2652 | case SIOCGIFMTU: /* struct ifreq */ |
2653 | case SIOCGIFPHYS: /* struct ifreq */ |
2654 | case SIOCSIFFLAGS: /* struct ifreq */ |
2655 | case SIOCSIFCAP: /* struct ifreq */ |
2656 | case SIOCSIFMETRIC: /* struct ifreq */ |
2657 | case SIOCSIFPHYS: /* struct ifreq */ |
2658 | case SIOCSIFMTU: /* struct ifreq */ |
2659 | case SIOCADDMULTI: /* struct ifreq */ |
2660 | case SIOCDELMULTI: /* struct ifreq */ |
2661 | case SIOCDIFPHYADDR: /* struct ifreq */ |
2662 | case SIOCSIFMEDIA: /* struct ifreq */ |
2663 | case SIOCSIFGENERIC: /* struct ifreq */ |
2664 | case SIOCSIFLLADDR: /* struct ifreq */ |
2665 | case SIOCSIFALTMTU: /* struct ifreq */ |
2666 | case SIOCSIFVLAN: /* struct ifreq */ |
2667 | case SIOCSIFBOND: /* struct ifreq */ |
2668 | case SIOCGIFLLADDR: /* struct ifreq */ |
2669 | case SIOCGIFTYPE: /* struct ifreq */ |
2670 | case SIOCGIFFUNCTIONALTYPE: /* struct ifreq */ |
2671 | case SIOCGIFPSRCADDR: /* struct ifreq */ |
2672 | case SIOCGIFPDSTADDR: /* struct ifreq */ |
2673 | case SIOCGIFGENERIC: /* struct ifreq */ |
2674 | case SIOCGIFDEVMTU: /* struct ifreq */ |
2675 | case SIOCGIFVLAN: /* struct ifreq */ |
2676 | case SIOCGIFBOND: /* struct ifreq */ |
2677 | case SIOCGIFWAKEFLAGS: /* struct ifreq */ |
2678 | case SIOCGIFGETRTREFCNT: /* struct ifreq */ |
2679 | case SIOCSIFOPPORTUNISTIC: /* struct ifreq */ |
2680 | case SIOCGIFOPPORTUNISTIC: /* struct ifreq */ |
2681 | case SIOCGIFLINKQUALITYMETRIC: /* struct ifreq */ |
2682 | case SIOCSIFLOG: /* struct ifreq */ |
2683 | case SIOCGIFLOG: /* struct ifreq */ |
2684 | case SIOCGIFDELEGATE: /* struct ifreq */ |
2685 | case SIOCGIFEXPENSIVE: /* struct ifreq */ |
2686 | case SIOCSIFEXPENSIVE: /* struct ifreq */ |
2687 | case SIOCSIF2KCL: /* struct ifreq */ |
2688 | case SIOCGIF2KCL: /* struct ifreq */ |
2689 | case SIOCSIFINTERFACESTATE: /* struct ifreq */ |
2690 | case SIOCGIFINTERFACESTATE: /* struct ifreq */ |
2691 | case SIOCSIFPROBECONNECTIVITY: /* struct ifreq */ |
2692 | case SIOCGIFPROBECONNECTIVITY: /* struct ifreq */ |
2693 | case SIOCGSTARTDELAY: /* struct ifreq */ |
2694 | case SIOCSIFTIMESTAMPENABLE: /* struct ifreq */ |
2695 | case SIOCSIFTIMESTAMPDISABLE: /* struct ifreq */ |
2696 | case SIOCGIFTIMESTAMPENABLED: /* struct ifreq */ |
2697 | #if (DEBUG || DEVELOPMENT) |
2698 | case SIOCSIFDISABLEOUTPUT: /* struct ifreq */ |
2699 | #endif /* (DEBUG || DEVELOPMENT) */ |
2700 | case SIOCGECNMODE: /* struct ifreq */ |
2701 | case SIOCSECNMODE: |
2702 | case SIOCSQOSMARKINGMODE: /* struct ifreq */ |
2703 | case SIOCSQOSMARKINGENABLED: /* struct ifreq */ |
2704 | case SIOCGQOSMARKINGMODE: /* struct ifreq */ |
2705 | case SIOCGQOSMARKINGENABLED: /* struct ifreq */ |
2706 | case SIOCSIFLOWINTERNET: /* struct ifreq */ |
2707 | case SIOCGIFLOWINTERNET: /* struct ifreq */ |
2708 | case SIOCGIFLOWPOWER: /* struct ifreq */ |
2709 | case SIOCSIFLOWPOWER: /* struct ifreq */ |
2710 | { /* struct ifreq */ |
2711 | struct ifreq ifr; |
2712 | bcopy(data, &ifr, sizeof (ifr)); |
2713 | ifr.ifr_name[IFNAMSIZ - 1] = '\0'; |
2714 | bcopy(&ifr.ifr_name, ifname, IFNAMSIZ); |
2715 | if (ifioctl_restrict_intcoproc(cmd, ifname, NULL, p) == true) { |
2716 | error = EPERM; |
2717 | goto done; |
2718 | } |
2719 | error = ifioctl_ifreq(so, cmd, &ifr, p); |
2720 | bcopy(&ifr, data, sizeof (ifr)); |
2721 | goto done; |
2722 | } |
2723 | } |
2724 | |
2725 | /* |
2726 | * ioctls which require ifp. Note that we acquire dlil_ifnet_lock |
2727 | * here to ensure that the ifnet, if found, has been fully attached. |
2728 | */ |
2729 | dlil_if_lock(); |
2730 | switch (cmd) { |
2731 | case SIOCSIFPHYADDR: /* struct {if,in_}aliasreq */ |
2732 | bcopy(((struct in_aliasreq *)(void *)data)->ifra_name, |
2733 | ifname, IFNAMSIZ); |
2734 | ifp = ifunit(ifname); |
2735 | break; |
2736 | |
2737 | #if INET6 |
2738 | case SIOCSIFPHYADDR_IN6_32: /* struct in6_aliasreq_32 */ |
2739 | bcopy(((struct in6_aliasreq_32 *)(void *)data)->ifra_name, |
2740 | ifname, IFNAMSIZ); |
2741 | ifp = ifunit(ifname); |
2742 | break; |
2743 | |
2744 | case SIOCSIFPHYADDR_IN6_64: /* struct in6_aliasreq_64 */ |
2745 | bcopy(((struct in6_aliasreq_64 *)(void *)data)->ifra_name, |
2746 | ifname, IFNAMSIZ); |
2747 | ifp = ifunit(ifname); |
2748 | break; |
2749 | #endif /* INET6 */ |
2750 | |
2751 | case SIOCGIFSTATUS: /* struct ifstat */ |
2752 | ifs = _MALLOC(sizeof (*ifs), M_DEVBUF, M_WAITOK); |
2753 | if (ifs == NULL) { |
2754 | error = ENOMEM; |
2755 | dlil_if_unlock(); |
2756 | goto done; |
2757 | } |
2758 | bcopy(data, ifs, sizeof (*ifs)); |
2759 | ifs->ifs_name[IFNAMSIZ - 1] = '\0'; |
2760 | bcopy(ifs->ifs_name, ifname, IFNAMSIZ); |
2761 | ifp = ifunit(ifname); |
2762 | break; |
2763 | |
2764 | case SIOCGIFMEDIA32: /* struct ifmediareq32 */ |
2765 | bcopy(((struct ifmediareq32 *)(void *)data)->ifm_name, |
2766 | ifname, IFNAMSIZ); |
2767 | ifp = ifunit(ifname); |
2768 | break; |
2769 | |
2770 | case SIOCGIFMEDIA64: /* struct ifmediareq64 */ |
2771 | bcopy(((struct ifmediareq64 *)(void *)data)->ifm_name, |
2772 | ifname, IFNAMSIZ); |
2773 | ifp = ifunit(ifname); |
2774 | break; |
2775 | |
2776 | case SIOCSIFDESC: /* struct if_descreq */ |
2777 | case SIOCGIFDESC: /* struct if_descreq */ |
2778 | bcopy(((struct if_descreq *)(void *)data)->ifdr_name, |
2779 | ifname, IFNAMSIZ); |
2780 | ifp = ifunit(ifname); |
2781 | break; |
2782 | |
2783 | case SIOCSIFLINKPARAMS: /* struct if_linkparamsreq */ |
2784 | case SIOCGIFLINKPARAMS: /* struct if_linkparamsreq */ |
2785 | bcopy(((struct if_linkparamsreq *)(void *)data)->iflpr_name, |
2786 | ifname, IFNAMSIZ); |
2787 | ifp = ifunit(ifname); |
2788 | break; |
2789 | |
2790 | case SIOCGIFQUEUESTATS: /* struct if_qstatsreq */ |
2791 | bcopy(((struct if_qstatsreq *)(void *)data)->ifqr_name, |
2792 | ifname, IFNAMSIZ); |
2793 | ifp = ifunit(ifname); |
2794 | break; |
2795 | |
2796 | case SIOCSIFTHROTTLE: /* struct if_throttlereq */ |
2797 | case SIOCGIFTHROTTLE: /* struct if_throttlereq */ |
2798 | bcopy(((struct if_throttlereq *)(void *)data)->ifthr_name, |
2799 | ifname, IFNAMSIZ); |
2800 | ifp = ifunit(ifname); |
2801 | break; |
2802 | |
2803 | case SIOCAIFAGENTID: /* struct if_agentidreq */ |
2804 | case SIOCDIFAGENTID: /* struct if_agentidreq */ |
2805 | case SIOCGIFAGENTIDS32: /* struct if_agentidsreq32 */ |
2806 | case SIOCGIFAGENTIDS64: /* struct if_agentidsreq64 */ |
2807 | bcopy(((struct if_agentidreq *)(void *)data)->ifar_name, |
2808 | ifname, IFNAMSIZ); |
2809 | ifp = ifunit(ifname); |
2810 | break; |
2811 | |
2812 | case SIOCSIFNETSIGNATURE: /* struct if_nsreq */ |
2813 | case SIOCGIFNETSIGNATURE: /* struct if_nsreq */ |
2814 | bcopy(((struct if_nsreq *)(void *)data)->ifnsr_name, |
2815 | ifname, IFNAMSIZ); |
2816 | ifp = ifunit(ifname); |
2817 | break; |
2818 | |
2819 | case SIOCGIFPROTOLIST32: /* struct if_protolistreq32 */ |
2820 | case SIOCGIFPROTOLIST64: /* struct if_protolistreq64 */ |
2821 | bcopy(((struct if_protolistreq *)(void *)data)->ifpl_name, |
2822 | ifname, IFNAMSIZ); |
2823 | ifp = ifunit(ifname); |
2824 | break; |
2825 | default: |
2826 | /* |
2827 | * This is a bad assumption, but the code seems to |
2828 | * have been doing this in the past; caveat emptor. |
2829 | */ |
2830 | bcopy(((struct ifreq *)(void *)data)->ifr_name, |
2831 | ifname, IFNAMSIZ); |
2832 | ifp = ifunit(ifname); |
2833 | break; |
2834 | } |
2835 | dlil_if_unlock(); |
2836 | |
2837 | if (ifp == NULL) { |
2838 | error = ENXIO; |
2839 | goto done; |
2840 | } |
2841 | |
2842 | if (ifioctl_restrict_intcoproc(cmd, NULL, ifp, p) == true) { |
2843 | error = EPERM; |
2844 | goto done; |
2845 | } |
2846 | switch (cmd) { |
2847 | case SIOCSIFPHYADDR: /* struct {if,in_}aliasreq */ |
2848 | #if INET6 |
2849 | case SIOCSIFPHYADDR_IN6_32: /* struct in6_aliasreq_32 */ |
2850 | case SIOCSIFPHYADDR_IN6_64: /* struct in6_aliasreq_64 */ |
2851 | #endif /* INET6 */ |
2852 | error = proc_suser(p); |
2853 | if (error != 0) |
2854 | break; |
2855 | |
2856 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, data); |
2857 | if (error != 0) |
2858 | break; |
2859 | |
2860 | ifnet_touch_lastchange(ifp); |
2861 | break; |
2862 | |
2863 | case SIOCGIFSTATUS: /* struct ifstat */ |
2864 | VERIFY(ifs != NULL); |
2865 | ifs->ascii[0] = '\0'; |
2866 | |
2867 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifs); |
2868 | |
2869 | bcopy(ifs, data, sizeof (*ifs)); |
2870 | break; |
2871 | |
2872 | case SIOCGIFMEDIA32: /* struct ifmediareq32 */ |
2873 | case SIOCGIFMEDIA64: /* struct ifmediareq64 */ |
2874 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, data); |
2875 | break; |
2876 | |
2877 | case SIOCSIFDESC: /* struct if_descreq */ |
2878 | case SIOCGIFDESC: /* struct if_descreq */ |
2879 | error = ifioctl_ifdesc(ifp, cmd, data, p); |
2880 | break; |
2881 | |
2882 | case SIOCSIFLINKPARAMS: /* struct if_linkparamsreq */ |
2883 | case SIOCGIFLINKPARAMS: /* struct if_linkparamsreq */ |
2884 | error = ifioctl_linkparams(ifp, cmd, data, p); |
2885 | break; |
2886 | |
2887 | case SIOCGIFQUEUESTATS: /* struct if_qstatsreq */ |
2888 | error = ifioctl_qstats(ifp, cmd, data); |
2889 | break; |
2890 | |
2891 | case SIOCSIFTHROTTLE: /* struct if_throttlereq */ |
2892 | case SIOCGIFTHROTTLE: /* struct if_throttlereq */ |
2893 | error = ifioctl_throttle(ifp, cmd, data, p); |
2894 | break; |
2895 | |
2896 | case SIOCAIFAGENTID: /* struct if_agentidreq */ |
2897 | case SIOCDIFAGENTID: /* struct if_agentidreq */ |
2898 | case SIOCGIFAGENTIDS32: /* struct if_agentidsreq32 */ |
2899 | case SIOCGIFAGENTIDS64: /* struct if_agentidsreq64 */ |
2900 | error = ifioctl_netagent(ifp, cmd, data, p); |
2901 | break; |
2902 | |
2903 | case SIOCSIFNETSIGNATURE: /* struct if_nsreq */ |
2904 | case SIOCGIFNETSIGNATURE: /* struct if_nsreq */ |
2905 | error = ifioctl_netsignature(ifp, cmd, data); |
2906 | break; |
2907 | |
2908 | #if INET6 |
2909 | case SIOCSIFNAT64PREFIX: /* struct if_nat64req */ |
2910 | case SIOCGIFNAT64PREFIX: /* struct if_nat64req */ |
2911 | error = ifioctl_nat64prefix(ifp, cmd, data); |
2912 | break; |
2913 | |
2914 | case SIOCGIFCLAT46ADDR: /* struct if_clat46req */ |
2915 | error = ifioctl_clat46addr(ifp, cmd, data); |
2916 | break; |
2917 | #endif |
2918 | |
2919 | case SIOCGIFPROTOLIST32: /* struct if_protolistreq32 */ |
2920 | case SIOCGIFPROTOLIST64: /* struct if_protolistreq64 */ |
2921 | error = ifioctl_protolist(ifp, cmd, data); |
2922 | break; |
2923 | |
2924 | default: |
2925 | if (so->so_proto == NULL) { |
2926 | error = EOPNOTSUPP; |
2927 | break; |
2928 | } |
2929 | |
2930 | socket_lock(so, 1); |
2931 | error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, |
2932 | data, ifp, p)); |
2933 | socket_unlock(so, 1); |
2934 | |
2935 | if (error == EOPNOTSUPP || error == ENOTSUP) { |
2936 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, data); |
2937 | } |
2938 | break; |
2939 | } |
2940 | |
2941 | done: |
2942 | if (ifs != NULL) |
2943 | _FREE(ifs, M_DEVBUF); |
2944 | |
2945 | if (if_verbose) { |
2946 | if (ifname[0] == '\0') |
2947 | (void) snprintf(ifname, sizeof (ifname), "%s" , |
2948 | "NULL" ); |
2949 | else if (ifp != NULL) |
2950 | (void) snprintf(ifname, sizeof (ifname), "%s" , |
2951 | if_name(ifp)); |
2952 | |
2953 | if (error != 0) { |
2954 | printf("%s[%s,%d]: ifp %s cmd 0x%08lx (%c%c [%lu] " |
2955 | "%c %lu) error %d\n" , __func__, |
2956 | proc_name_address(p), proc_pid(p), |
2957 | ifname, cmd, (cmd & IOC_IN) ? 'I' : ' ', |
2958 | (cmd & IOC_OUT) ? 'O' : ' ', IOCPARM_LEN(cmd), |
2959 | (char)IOCGROUP(cmd), cmd & 0xff, error); |
2960 | } else if (if_verbose > 1) { |
2961 | printf("%s[%s,%d]: ifp %s cmd 0x%08lx (%c%c [%lu] " |
2962 | "%c %lu) OK\n" , __func__, |
2963 | proc_name_address(p), proc_pid(p), |
2964 | ifname, cmd, (cmd & IOC_IN) ? 'I' : ' ', |
2965 | (cmd & IOC_OUT) ? 'O' : ' ', IOCPARM_LEN(cmd), |
2966 | (char)IOCGROUP(cmd), cmd & 0xff); |
2967 | } |
2968 | } |
2969 | |
2970 | return (error); |
2971 | } |
2972 | |
2973 | static __attribute__((noinline)) int |
2974 | ifioctl_ifreq(struct socket *so, u_long cmd, struct ifreq *ifr, struct proc *p) |
2975 | { |
2976 | struct ifnet *ifp; |
2977 | u_long ocmd = cmd; |
2978 | int error = 0; |
2979 | struct kev_msg ev_msg; |
2980 | struct net_event_data ev_data; |
2981 | |
2982 | bzero(&ev_data, sizeof (struct net_event_data)); |
2983 | bzero(&ev_msg, sizeof (struct kev_msg)); |
2984 | |
2985 | switch (cmd) { |
2986 | case SIOCIFCREATE: |
2987 | case SIOCIFCREATE2: |
2988 | error = proc_suser(p); |
2989 | if (error) |
2990 | return (error); |
2991 | return (if_clone_create(ifr->ifr_name, sizeof(ifr->ifr_name), |
2992 | cmd == SIOCIFCREATE2 ? ifr->ifr_data : NULL)); |
2993 | case SIOCIFDESTROY: |
2994 | error = proc_suser(p); |
2995 | if (error) |
2996 | return (error); |
2997 | return (if_clone_destroy(ifr->ifr_name)); |
2998 | } |
2999 | |
3000 | /* |
3001 | * ioctls which require ifp. Note that we acquire dlil_ifnet_lock |
3002 | * here to ensure that the ifnet, if found, has been fully attached. |
3003 | */ |
3004 | dlil_if_lock(); |
3005 | ifp = ifunit(ifr->ifr_name); |
3006 | dlil_if_unlock(); |
3007 | |
3008 | if (ifp == NULL) |
3009 | return (ENXIO); |
3010 | |
3011 | switch (cmd) { |
3012 | case SIOCGIFFLAGS: |
3013 | ifnet_lock_shared(ifp); |
3014 | ifr->ifr_flags = ifp->if_flags; |
3015 | ifnet_lock_done(ifp); |
3016 | break; |
3017 | |
3018 | case SIOCGIFEFLAGS: |
3019 | ifnet_lock_shared(ifp); |
3020 | ifr->ifr_eflags = ifp->if_eflags; |
3021 | ifnet_lock_done(ifp); |
3022 | break; |
3023 | |
3024 | case SIOCGIFCAP: |
3025 | ifnet_lock_shared(ifp); |
3026 | ifr->ifr_reqcap = ifp->if_capabilities; |
3027 | ifr->ifr_curcap = ifp->if_capenable; |
3028 | ifnet_lock_done(ifp); |
3029 | break; |
3030 | |
3031 | #if CONFIG_MACF_NET |
3032 | case SIOCGIFMAC: |
3033 | error = mac_ifnet_label_get(kauth_cred_get(), ifr, ifp); |
3034 | break; |
3035 | |
3036 | case SIOCSIFMAC: |
3037 | error = mac_ifnet_label_set(kauth_cred_get(), ifr, ifp); |
3038 | break; |
3039 | #endif /* CONFIG_MACF_NET */ |
3040 | |
3041 | case SIOCGIFMETRIC: |
3042 | ifnet_lock_shared(ifp); |
3043 | ifr->ifr_metric = ifp->if_metric; |
3044 | ifnet_lock_done(ifp); |
3045 | break; |
3046 | |
3047 | case SIOCGIFMTU: |
3048 | ifnet_lock_shared(ifp); |
3049 | ifr->ifr_mtu = ifp->if_mtu; |
3050 | ifnet_lock_done(ifp); |
3051 | break; |
3052 | |
3053 | case SIOCGIFPHYS: |
3054 | ifnet_lock_shared(ifp); |
3055 | ifr->ifr_phys = ifp->if_physical; |
3056 | ifnet_lock_done(ifp); |
3057 | break; |
3058 | |
3059 | case SIOCSIFFLAGS: |
3060 | error = proc_suser(p); |
3061 | if (error != 0) |
3062 | break; |
3063 | |
3064 | (void) ifnet_set_flags(ifp, ifr->ifr_flags, |
3065 | (u_int16_t)~IFF_CANTCHANGE); |
3066 | |
3067 | /* |
3068 | * Note that we intentionally ignore any error from below |
3069 | * for the SIOCSIFFLAGS case. |
3070 | */ |
3071 | (void) ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); |
3072 | |
3073 | /* |
3074 | * Send the event even upon error from the driver because |
3075 | * we changed the flags. |
3076 | */ |
3077 | dlil_post_sifflags_msg(ifp); |
3078 | |
3079 | ifnet_touch_lastchange(ifp); |
3080 | break; |
3081 | |
3082 | case SIOCSIFCAP: |
3083 | error = proc_suser(p); |
3084 | if (error != 0) |
3085 | break; |
3086 | |
3087 | if ((ifr->ifr_reqcap & ~ifp->if_capabilities)) { |
3088 | error = EINVAL; |
3089 | break; |
3090 | } |
3091 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); |
3092 | |
3093 | ifnet_touch_lastchange(ifp); |
3094 | break; |
3095 | |
3096 | case SIOCSIFMETRIC: |
3097 | error = proc_suser(p); |
3098 | if (error != 0) |
3099 | break; |
3100 | |
3101 | ifp->if_metric = ifr->ifr_metric; |
3102 | |
3103 | ev_msg.vendor_code = KEV_VENDOR_APPLE; |
3104 | ev_msg.kev_class = KEV_NETWORK_CLASS; |
3105 | ev_msg.kev_subclass = KEV_DL_SUBCLASS; |
3106 | |
3107 | ev_msg.event_code = KEV_DL_SIFMETRICS; |
3108 | strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ); |
3109 | ev_data.if_family = ifp->if_family; |
3110 | ev_data.if_unit = (u_int32_t) ifp->if_unit; |
3111 | ev_msg.dv[0].data_length = sizeof(struct net_event_data); |
3112 | ev_msg.dv[0].data_ptr = &ev_data; |
3113 | |
3114 | ev_msg.dv[1].data_length = 0; |
3115 | dlil_post_complete_msg(ifp, &ev_msg); |
3116 | |
3117 | ifnet_touch_lastchange(ifp); |
3118 | break; |
3119 | |
3120 | case SIOCSIFPHYS: |
3121 | error = proc_suser(p); |
3122 | if (error != 0) |
3123 | break; |
3124 | |
3125 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); |
3126 | if (error != 0) |
3127 | break; |
3128 | |
3129 | ev_msg.vendor_code = KEV_VENDOR_APPLE; |
3130 | ev_msg.kev_class = KEV_NETWORK_CLASS; |
3131 | ev_msg.kev_subclass = KEV_DL_SUBCLASS; |
3132 | |
3133 | ev_msg.event_code = KEV_DL_SIFPHYS; |
3134 | strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ); |
3135 | ev_data.if_family = ifp->if_family; |
3136 | ev_data.if_unit = (u_int32_t) ifp->if_unit; |
3137 | ev_msg.dv[0].data_length = sizeof(struct net_event_data); |
3138 | ev_msg.dv[0].data_ptr = &ev_data; |
3139 | ev_msg.dv[1].data_length = 0; |
3140 | dlil_post_complete_msg(ifp, &ev_msg); |
3141 | |
3142 | ifnet_touch_lastchange(ifp); |
3143 | break; |
3144 | |
3145 | case SIOCSIFMTU: { |
3146 | u_int32_t oldmtu = ifp->if_mtu; |
3147 | struct ifclassq *ifq = &ifp->if_snd; |
3148 | |
3149 | error = proc_suser(p); |
3150 | if (error != 0) |
3151 | break; |
3152 | |
3153 | if (ifp->if_ioctl == NULL) { |
3154 | error = EOPNOTSUPP; |
3155 | break; |
3156 | } |
3157 | if (ifr->ifr_mtu < IF_MINMTU || ifr->ifr_mtu > IF_MAXMTU) { |
3158 | error = EINVAL; |
3159 | break; |
3160 | } |
3161 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); |
3162 | if (error != 0) |
3163 | break; |
3164 | |
3165 | ev_msg.vendor_code = KEV_VENDOR_APPLE; |
3166 | ev_msg.kev_class = KEV_NETWORK_CLASS; |
3167 | ev_msg.kev_subclass = KEV_DL_SUBCLASS; |
3168 | |
3169 | ev_msg.event_code = KEV_DL_SIFMTU; |
3170 | strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ); |
3171 | ev_data.if_family = ifp->if_family; |
3172 | ev_data.if_unit = (u_int32_t) ifp->if_unit; |
3173 | ev_msg.dv[0].data_length = sizeof(struct net_event_data); |
3174 | ev_msg.dv[0].data_ptr = &ev_data; |
3175 | ev_msg.dv[1].data_length = 0; |
3176 | dlil_post_complete_msg(ifp, &ev_msg); |
3177 | |
3178 | ifnet_touch_lastchange(ifp); |
3179 | rt_ifmsg(ifp); |
3180 | |
3181 | /* |
3182 | * If the link MTU changed, do network layer specific procedure |
3183 | * and update all route entries associated with the interface, |
3184 | * so that their MTU metric gets updated. |
3185 | */ |
3186 | if (ifp->if_mtu != oldmtu) { |
3187 | if_rtmtu_update(ifp); |
3188 | #if INET6 |
3189 | nd6_setmtu(ifp); |
3190 | #endif /* INET6 */ |
3191 | /* Inform all transmit queues about the new MTU */ |
3192 | IFCQ_LOCK(ifq); |
3193 | ifnet_update_sndq(ifq, CLASSQ_EV_LINK_MTU); |
3194 | IFCQ_UNLOCK(ifq); |
3195 | } |
3196 | break; |
3197 | } |
3198 | |
3199 | case SIOCADDMULTI: |
3200 | case SIOCDELMULTI: |
3201 | error = proc_suser(p); |
3202 | if (error != 0) |
3203 | break; |
3204 | |
3205 | /* Don't allow group membership on non-multicast interfaces. */ |
3206 | if ((ifp->if_flags & IFF_MULTICAST) == 0) { |
3207 | error = EOPNOTSUPP; |
3208 | break; |
3209 | } |
3210 | |
3211 | /* Don't let users screw up protocols' entries. */ |
3212 | if (ifr->ifr_addr.sa_family != AF_UNSPEC && |
3213 | ifr->ifr_addr.sa_family != AF_LINK) { |
3214 | error = EINVAL; |
3215 | break; |
3216 | } |
3217 | |
3218 | /* |
3219 | * User is permitted to anonymously join a particular link |
3220 | * multicast group via SIOCADDMULTI. Subsequent join requested |
3221 | * for the same record which has an outstanding refcnt from a |
3222 | * past if_addmulti_anon() will not result in EADDRINUSE error |
3223 | * (unlike other BSDs.) Anonymously leaving a group is also |
3224 | * allowed only as long as there is an outstanding refcnt held |
3225 | * by a previous anonymous request, or else ENOENT (even if the |
3226 | * link-layer multicast membership exists for a network-layer |
3227 | * membership.) |
3228 | */ |
3229 | if (cmd == SIOCADDMULTI) { |
3230 | error = if_addmulti_anon(ifp, &ifr->ifr_addr, NULL); |
3231 | ev_msg.event_code = KEV_DL_ADDMULTI; |
3232 | } else { |
3233 | error = if_delmulti_anon(ifp, &ifr->ifr_addr); |
3234 | ev_msg.event_code = KEV_DL_DELMULTI; |
3235 | } |
3236 | if (error != 0) |
3237 | break; |
3238 | |
3239 | ev_msg.vendor_code = KEV_VENDOR_APPLE; |
3240 | ev_msg.kev_class = KEV_NETWORK_CLASS; |
3241 | ev_msg.kev_subclass = KEV_DL_SUBCLASS; |
3242 | strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ); |
3243 | |
3244 | ev_data.if_family = ifp->if_family; |
3245 | ev_data.if_unit = (u_int32_t) ifp->if_unit; |
3246 | ev_msg.dv[0].data_length = sizeof(struct net_event_data); |
3247 | ev_msg.dv[0].data_ptr = &ev_data; |
3248 | ev_msg.dv[1].data_length = 0; |
3249 | dlil_post_complete_msg(ifp, &ev_msg); |
3250 | |
3251 | ifnet_touch_lastchange(ifp); |
3252 | break; |
3253 | |
3254 | case SIOCDIFPHYADDR: |
3255 | case SIOCSIFMEDIA: |
3256 | case SIOCSIFGENERIC: |
3257 | case SIOCSIFLLADDR: |
3258 | case SIOCSIFALTMTU: |
3259 | case SIOCSIFVLAN: |
3260 | case SIOCSIFBOND: |
3261 | error = proc_suser(p); |
3262 | if (error != 0) |
3263 | break; |
3264 | |
3265 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); |
3266 | if (error != 0) |
3267 | break; |
3268 | |
3269 | ifnet_touch_lastchange(ifp); |
3270 | break; |
3271 | |
3272 | case SIOCGIFLLADDR: { |
3273 | struct sockaddr_dl *sdl = SDL(ifp->if_lladdr->ifa_addr); |
3274 | |
3275 | if (sdl->sdl_alen == 0) { |
3276 | error = EADDRNOTAVAIL; |
3277 | break; |
3278 | } |
3279 | /* If larger than 14-bytes we'll need another mechanism */ |
3280 | if (sdl->sdl_alen > sizeof (ifr->ifr_addr.sa_data)) { |
3281 | error = EMSGSIZE; |
3282 | break; |
3283 | } |
3284 | /* Follow the same convention used by SIOCSIFLLADDR */ |
3285 | bzero(&ifr->ifr_addr, sizeof (ifr->ifr_addr)); |
3286 | ifr->ifr_addr.sa_family = AF_LINK; |
3287 | ifr->ifr_addr.sa_len = sdl->sdl_alen; |
3288 | error = ifnet_guarded_lladdr_copy_bytes(ifp, |
3289 | &ifr->ifr_addr.sa_data, sdl->sdl_alen); |
3290 | break; |
3291 | } |
3292 | |
3293 | case SIOCGIFTYPE: |
3294 | ifr->ifr_type.ift_type = ifp->if_type; |
3295 | ifr->ifr_type.ift_family = ifp->if_family; |
3296 | ifr->ifr_type.ift_subfamily = ifp->if_subfamily; |
3297 | break; |
3298 | |
3299 | case SIOCGIFFUNCTIONALTYPE: |
3300 | ifr->ifr_functional_type = if_functional_type(ifp, FALSE); |
3301 | break; |
3302 | |
3303 | case SIOCGIFPSRCADDR: |
3304 | case SIOCGIFPDSTADDR: |
3305 | case SIOCGIFGENERIC: |
3306 | case SIOCGIFDEVMTU: |
3307 | case SIOCGIFVLAN: |
3308 | case SIOCGIFBOND: |
3309 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, (caddr_t)ifr); |
3310 | break; |
3311 | |
3312 | case SIOCGIFWAKEFLAGS: |
3313 | ifnet_lock_shared(ifp); |
3314 | ifr->ifr_wake_flags = ifnet_get_wake_flags(ifp); |
3315 | ifnet_lock_done(ifp); |
3316 | break; |
3317 | |
3318 | case SIOCGIFGETRTREFCNT: |
3319 | ifnet_lock_shared(ifp); |
3320 | ifr->ifr_route_refcnt = ifp->if_route_refcnt; |
3321 | ifnet_lock_done(ifp); |
3322 | break; |
3323 | |
3324 | case SIOCSIFOPPORTUNISTIC: |
3325 | case SIOCGIFOPPORTUNISTIC: |
3326 | error = ifnet_getset_opportunistic(ifp, cmd, ifr, p); |
3327 | break; |
3328 | |
3329 | case SIOCGIFLINKQUALITYMETRIC: |
3330 | ifnet_lock_shared(ifp); |
3331 | if ((ifp->if_interface_state.valid_bitmask & |
3332 | IF_INTERFACE_STATE_LQM_STATE_VALID)) { |
3333 | ifr->ifr_link_quality_metric = |
3334 | ifp->if_interface_state.lqm_state; |
3335 | } else if (IF_FULLY_ATTACHED(ifp)) { |
3336 | ifr->ifr_link_quality_metric = |
3337 | IFNET_LQM_THRESH_UNKNOWN; |
3338 | } else { |
3339 | ifr->ifr_link_quality_metric = |
3340 | IFNET_LQM_THRESH_OFF; |
3341 | } |
3342 | ifnet_lock_done(ifp); |
3343 | break; |
3344 | |
3345 | case SIOCSIFLOG: |
3346 | case SIOCGIFLOG: |
3347 | error = ifnet_getset_log(ifp, cmd, ifr, p); |
3348 | break; |
3349 | |
3350 | case SIOCGIFDELEGATE: |
3351 | ifnet_lock_shared(ifp); |
3352 | ifr->ifr_delegated = ((ifp->if_delegated.ifp != NULL) ? |
3353 | ifp->if_delegated.ifp->if_index : 0); |
3354 | ifnet_lock_done(ifp); |
3355 | break; |
3356 | |
3357 | case SIOCGIFEXPENSIVE: |
3358 | ifnet_lock_shared(ifp); |
3359 | if (ifp->if_eflags & IFEF_EXPENSIVE) |
3360 | ifr->ifr_expensive = 1; |
3361 | else |
3362 | ifr->ifr_expensive = 0; |
3363 | ifnet_lock_done(ifp); |
3364 | break; |
3365 | |
3366 | case SIOCSIFEXPENSIVE: |
3367 | { |
3368 | struct ifnet *difp; |
3369 | |
3370 | if ((error = priv_check_cred(kauth_cred_get(), |
3371 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3372 | return (error); |
3373 | ifnet_lock_exclusive(ifp); |
3374 | if (ifr->ifr_expensive) |
3375 | ifp->if_eflags |= IFEF_EXPENSIVE; |
3376 | else |
3377 | ifp->if_eflags &= ~IFEF_EXPENSIVE; |
3378 | ifnet_lock_done(ifp); |
3379 | /* |
3380 | * Update the expensive bit in the delegated interface |
3381 | * structure. |
3382 | */ |
3383 | ifnet_head_lock_shared(); |
3384 | TAILQ_FOREACH(difp, &ifnet_head, if_link) { |
3385 | ifnet_lock_exclusive(difp); |
3386 | if (difp->if_delegated.ifp == ifp) { |
3387 | difp->if_delegated.expensive = |
3388 | ifp->if_eflags & IFEF_EXPENSIVE ? 1 : 0; |
3389 | |
3390 | } |
3391 | ifnet_lock_done(difp); |
3392 | } |
3393 | ifnet_head_done(); |
3394 | break; |
3395 | } |
3396 | |
3397 | case SIOCGIF2KCL: |
3398 | ifnet_lock_shared(ifp); |
3399 | if (ifp->if_eflags & IFEF_2KCL) |
3400 | ifr->ifr_2kcl = 1; |
3401 | else |
3402 | ifr->ifr_2kcl = 0; |
3403 | ifnet_lock_done(ifp); |
3404 | break; |
3405 | |
3406 | case SIOCSIF2KCL: |
3407 | if ((error = priv_check_cred(kauth_cred_get(), |
3408 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3409 | return (error); |
3410 | ifnet_lock_exclusive(ifp); |
3411 | if (ifr->ifr_2kcl) |
3412 | ifp->if_eflags |= IFEF_2KCL; |
3413 | else |
3414 | ifp->if_eflags &= ~IFEF_2KCL; |
3415 | ifnet_lock_done(ifp); |
3416 | break; |
3417 | case SIOCGSTARTDELAY: |
3418 | ifnet_lock_shared(ifp); |
3419 | if (ifp->if_eflags & IFEF_ENQUEUE_MULTI) { |
3420 | ifr->ifr_start_delay_qlen = |
3421 | ifp->if_start_delay_qlen; |
3422 | ifr->ifr_start_delay_timeout = |
3423 | ifp->if_start_delay_timeout; |
3424 | } else { |
3425 | ifr->ifr_start_delay_qlen = 0; |
3426 | ifr->ifr_start_delay_timeout = 0; |
3427 | } |
3428 | ifnet_lock_done(ifp); |
3429 | break; |
3430 | case SIOCSIFDSTADDR: |
3431 | case SIOCSIFADDR: |
3432 | case SIOCSIFBRDADDR: |
3433 | case SIOCSIFNETMASK: |
3434 | case OSIOCGIFADDR: |
3435 | case OSIOCGIFDSTADDR: |
3436 | case OSIOCGIFBRDADDR: |
3437 | case OSIOCGIFNETMASK: |
3438 | case SIOCSIFKPI: |
3439 | VERIFY(so->so_proto != NULL); |
3440 | |
3441 | if (cmd == SIOCSIFDSTADDR || cmd == SIOCSIFADDR || |
3442 | cmd == SIOCSIFBRDADDR || cmd == SIOCSIFNETMASK) { |
3443 | #if BYTE_ORDER != BIG_ENDIAN |
3444 | if (ifr->ifr_addr.sa_family == 0 && |
3445 | ifr->ifr_addr.sa_len < 16) { |
3446 | ifr->ifr_addr.sa_family = ifr->ifr_addr.sa_len; |
3447 | ifr->ifr_addr.sa_len = 16; |
3448 | } |
3449 | #else |
3450 | if (ifr->ifr_addr.sa_len == 0) |
3451 | ifr->ifr_addr.sa_len = 16; |
3452 | #endif |
3453 | } else if (cmd == OSIOCGIFADDR) { |
3454 | cmd = SIOCGIFADDR; /* struct ifreq */ |
3455 | } else if (cmd == OSIOCGIFDSTADDR) { |
3456 | cmd = SIOCGIFDSTADDR; /* struct ifreq */ |
3457 | } else if (cmd == OSIOCGIFBRDADDR) { |
3458 | cmd = SIOCGIFBRDADDR; /* struct ifreq */ |
3459 | } else if (cmd == OSIOCGIFNETMASK) { |
3460 | cmd = SIOCGIFNETMASK; /* struct ifreq */ |
3461 | } |
3462 | |
3463 | socket_lock(so, 1); |
3464 | error = ((*so->so_proto->pr_usrreqs->pru_control)(so, cmd, |
3465 | (caddr_t)ifr, ifp, p)); |
3466 | socket_unlock(so, 1); |
3467 | |
3468 | switch (ocmd) { |
3469 | case OSIOCGIFADDR: |
3470 | case OSIOCGIFDSTADDR: |
3471 | case OSIOCGIFBRDADDR: |
3472 | case OSIOCGIFNETMASK: |
3473 | bcopy(&ifr->ifr_addr.sa_family, &ifr->ifr_addr, |
3474 | sizeof (u_short)); |
3475 | } |
3476 | |
3477 | if (cmd == SIOCSIFKPI) { |
3478 | int temperr = proc_suser(p); |
3479 | if (temperr != 0) |
3480 | error = temperr; |
3481 | } |
3482 | |
3483 | if (error == EOPNOTSUPP || error == ENOTSUP) { |
3484 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, |
3485 | (caddr_t)ifr); |
3486 | } |
3487 | break; |
3488 | |
3489 | case SIOCGIFINTERFACESTATE: |
3490 | if_get_state(ifp, &ifr->ifr_interface_state); |
3491 | |
3492 | break; |
3493 | case SIOCSIFINTERFACESTATE: |
3494 | if ((error = priv_check_cred(kauth_cred_get(), |
3495 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3496 | return (error); |
3497 | |
3498 | error = if_state_update(ifp, &ifr->ifr_interface_state); |
3499 | |
3500 | break; |
3501 | case SIOCSIFPROBECONNECTIVITY: |
3502 | if ((error = priv_check_cred(kauth_cred_get(), |
3503 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3504 | return (error); |
3505 | error = if_probe_connectivity(ifp, |
3506 | ifr->ifr_probe_connectivity); |
3507 | break; |
3508 | case SIOCGIFPROBECONNECTIVITY: |
3509 | if ((error = priv_check_cred(kauth_cred_get(), |
3510 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3511 | return (error); |
3512 | if (ifp->if_eflags & IFEF_PROBE_CONNECTIVITY) |
3513 | ifr->ifr_probe_connectivity = 1; |
3514 | else |
3515 | ifr->ifr_probe_connectivity = 0; |
3516 | break; |
3517 | case SIOCGECNMODE: |
3518 | if ((ifp->if_eflags & (IFEF_ECN_ENABLE|IFEF_ECN_DISABLE)) == |
3519 | IFEF_ECN_ENABLE) |
3520 | ifr->ifr_ecn_mode = IFRTYPE_ECN_ENABLE; |
3521 | else if ((ifp->if_eflags & (IFEF_ECN_ENABLE|IFEF_ECN_DISABLE)) == |
3522 | IFEF_ECN_DISABLE) |
3523 | ifr->ifr_ecn_mode = IFRTYPE_ECN_DISABLE; |
3524 | else |
3525 | ifr->ifr_ecn_mode = IFRTYPE_ECN_DEFAULT; |
3526 | break; |
3527 | case SIOCSECNMODE: |
3528 | if ((error = priv_check_cred(kauth_cred_get(), |
3529 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3530 | return (error); |
3531 | if (ifr->ifr_ecn_mode == IFRTYPE_ECN_DEFAULT) { |
3532 | ifp->if_eflags &= ~(IFEF_ECN_ENABLE|IFEF_ECN_DISABLE); |
3533 | } else if (ifr->ifr_ecn_mode == IFRTYPE_ECN_ENABLE) { |
3534 | ifp->if_eflags |= IFEF_ECN_ENABLE; |
3535 | ifp->if_eflags &= ~IFEF_ECN_DISABLE; |
3536 | } else if (ifr->ifr_ecn_mode == IFRTYPE_ECN_DISABLE) { |
3537 | ifp->if_eflags |= IFEF_ECN_DISABLE; |
3538 | ifp->if_eflags &= ~IFEF_ECN_ENABLE; |
3539 | } else |
3540 | error = EINVAL; |
3541 | break; |
3542 | case SIOCSIFTIMESTAMPENABLE: |
3543 | case SIOCSIFTIMESTAMPDISABLE: |
3544 | error = proc_suser(p); |
3545 | if (error != 0) |
3546 | break; |
3547 | |
3548 | ifnet_lock_exclusive(ifp); |
3549 | if ((cmd == SIOCSIFTIMESTAMPENABLE && |
3550 | (ifp->if_xflags & IFXF_TIMESTAMP_ENABLED) != 0) || |
3551 | (cmd == SIOCSIFTIMESTAMPDISABLE && |
3552 | (ifp->if_xflags & IFXF_TIMESTAMP_ENABLED) == 0)) { |
3553 | ifnet_lock_done(ifp); |
3554 | break; |
3555 | } |
3556 | if (cmd == SIOCSIFTIMESTAMPENABLE) |
3557 | ifp->if_xflags |= IFXF_TIMESTAMP_ENABLED; |
3558 | else |
3559 | ifp->if_xflags &= ~IFXF_TIMESTAMP_ENABLED; |
3560 | ifnet_lock_done(ifp); |
3561 | /* |
3562 | * Pass the setting to the interface if it supports either |
3563 | * software or hardware time stamping |
3564 | */ |
3565 | if (ifp->if_capabilities & (IFCAP_HW_TIMESTAMP | |
3566 | IFCAP_SW_TIMESTAMP)) { |
3567 | error = ifnet_ioctl(ifp, SOCK_DOM(so), cmd, |
3568 | (caddr_t)ifr); |
3569 | } |
3570 | break; |
3571 | case SIOCGIFTIMESTAMPENABLED: { |
3572 | if ((ifp->if_xflags & IFXF_TIMESTAMP_ENABLED) != 0) |
3573 | ifr->ifr_intval = 1; |
3574 | else |
3575 | ifr->ifr_intval = 0; |
3576 | break; |
3577 | } |
3578 | case SIOCSQOSMARKINGMODE: |
3579 | if ((error = priv_check_cred(kauth_cred_get(), |
3580 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3581 | return (error); |
3582 | error = if_set_qosmarking_mode(ifp, ifr->ifr_qosmarking_mode); |
3583 | break; |
3584 | |
3585 | case SIOCGQOSMARKINGMODE: |
3586 | ifr->ifr_qosmarking_mode = ifp->if_qosmarking_mode; |
3587 | break; |
3588 | |
3589 | case SIOCSQOSMARKINGENABLED: |
3590 | if ((error = priv_check_cred(kauth_cred_get(), |
3591 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3592 | return (error); |
3593 | if (ifr->ifr_qosmarking_enabled != 0) |
3594 | ifp->if_eflags |= IFEF_QOSMARKING_ENABLED; |
3595 | else |
3596 | ifp->if_eflags &= ~IFEF_QOSMARKING_ENABLED; |
3597 | break; |
3598 | |
3599 | case SIOCGQOSMARKINGENABLED: |
3600 | ifr->ifr_qosmarking_enabled = |
3601 | (ifp->if_eflags & IFEF_QOSMARKING_ENABLED) ? 1 : 0; |
3602 | break; |
3603 | |
3604 | case SIOCSIFDISABLEOUTPUT: |
3605 | #if (DEBUG || DEVELOPMENT) |
3606 | if (ifr->ifr_disable_output == 1) { |
3607 | error = ifnet_disable_output(ifp); |
3608 | } else if (ifr->ifr_disable_output == 0) { |
3609 | error = ifnet_enable_output(ifp); |
3610 | } else { |
3611 | error = EINVAL; |
3612 | } |
3613 | #else |
3614 | error = EINVAL; |
3615 | #endif /* (DEBUG || DEVELOPMENT) */ |
3616 | break; |
3617 | case SIOCSIFLOWINTERNET: |
3618 | if ((error = priv_check_cred(kauth_cred_get(), |
3619 | PRIV_NET_INTERFACE_CONTROL, 0)) != 0) |
3620 | return (error); |
3621 | |
3622 | ifnet_lock_exclusive(ifp); |
3623 | if (ifr->ifr_low_internet & IFRTYPE_LOW_INTERNET_ENABLE_UL) |
3624 | ifp->if_xflags |= IFXF_LOW_INTERNET_UL; |
3625 | else |
3626 | ifp->if_xflags &= ~(IFXF_LOW_INTERNET_UL); |
3627 | if (ifr->ifr_low_internet & IFRTYPE_LOW_INTERNET_ENABLE_DL) |
3628 | ifp->if_xflags |= IFXF_LOW_INTERNET_DL; |
3629 | else |
3630 | ifp->if_xflags &= ~(IFXF_LOW_INTERNET_DL); |
3631 | ifnet_lock_done(ifp); |
3632 | break; |
3633 | case SIOCGIFLOWINTERNET: |
3634 | ifnet_lock_shared(ifp); |
3635 | ifr->ifr_low_internet = 0; |
3636 | if (ifp->if_xflags & IFXF_LOW_INTERNET_UL) |
3637 | ifr->ifr_low_internet |= |
3638 | IFRTYPE_LOW_INTERNET_ENABLE_UL; |
3639 | if (ifp->if_xflags & IFXF_LOW_INTERNET_DL) |
3640 | ifr->ifr_low_internet |= |
3641 | IFRTYPE_LOW_INTERNET_ENABLE_DL; |
3642 | ifnet_lock_done(ifp); |
3643 | break; |
3644 | case SIOCGIFLOWPOWER: |
3645 | ifr->ifr_low_power_mode = |
3646 | !!(ifp->if_xflags & IFXF_LOW_POWER); |
3647 | break; |
3648 | case SIOCSIFLOWPOWER: |
3649 | #if (DEVELOPMENT || DEBUG) |
3650 | error = if_set_low_power(ifp, !!(ifr->ifr_low_power_mode)); |
3651 | #else /* DEVELOPMENT || DEBUG */ |
3652 | error = EOPNOTSUPP; |
3653 | #endif /* DEVELOPMENT || DEBUG */ |
3654 | break; |
3655 | default: |
3656 | VERIFY(0); |
3657 | /* NOTREACHED */ |
3658 | } |
3659 | |
3660 | return (error); |
3661 | } |
3662 | |
3663 | int |
3664 | ifioctllocked(struct socket *so, u_long cmd, caddr_t data, struct proc *p) |
3665 | { |
3666 | int error; |
3667 | |
3668 | socket_unlock(so, 0); |
3669 | error = ifioctl(so, cmd, data, p); |
3670 | socket_lock(so, 0); |
3671 | return (error); |
3672 | } |
3673 | |
3674 | /* |
3675 | * Set/clear promiscuous mode on interface ifp based on the truth value |
3676 | * of pswitch. The calls are reference counted so that only the first |
3677 | * "on" request actually has an effect, as does the final "off" request. |
3678 | * Results are undefined if the "off" and "on" requests are not matched. |
3679 | */ |
3680 | errno_t |
3681 | ifnet_set_promiscuous( |
3682 | ifnet_t ifp, |
3683 | int pswitch) |
3684 | { |
3685 | int error = 0; |
3686 | int oldflags = 0; |
3687 | int newflags = 0; |
3688 | |
3689 | ifnet_lock_exclusive(ifp); |
3690 | oldflags = ifp->if_flags; |
3691 | ifp->if_pcount += pswitch ? 1 : -1; |
3692 | |
3693 | if (ifp->if_pcount > 0) |
3694 | ifp->if_flags |= IFF_PROMISC; |
3695 | else |
3696 | ifp->if_flags &= ~IFF_PROMISC; |
3697 | |
3698 | newflags = ifp->if_flags; |
3699 | ifnet_lock_done(ifp); |
3700 | |
3701 | if (newflags != oldflags && (newflags & IFF_UP) != 0) { |
3702 | error = ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL); |
3703 | if (error == 0) { |
3704 | rt_ifmsg(ifp); |
3705 | } else { |
3706 | ifnet_lock_exclusive(ifp); |
3707 | // revert the flags |
3708 | ifp->if_pcount -= pswitch ? 1 : -1; |
3709 | if (ifp->if_pcount > 0) |
3710 | ifp->if_flags |= IFF_PROMISC; |
3711 | else |
3712 | ifp->if_flags &= ~IFF_PROMISC; |
3713 | ifnet_lock_done(ifp); |
3714 | } |
3715 | } |
3716 | |
3717 | if (newflags != oldflags) { |
3718 | log(LOG_INFO, "%s: promiscuous mode %s%s\n" , |
3719 | if_name(ifp), |
3720 | (newflags & IFF_PROMISC) != 0 ? "enable" : "disable" , |
3721 | error != 0 ? " failed" : " succeeded" ); |
3722 | } |
3723 | return (error); |
3724 | } |
3725 | |
3726 | /* |
3727 | * Return interface configuration |
3728 | * of system. List may be used |
3729 | * in later ioctl's (above) to get |
3730 | * other information. |
3731 | */ |
3732 | /*ARGSUSED*/ |
3733 | static int |
3734 | ifconf(u_long cmd, user_addr_t ifrp, int *ret_space) |
3735 | { |
3736 | struct ifnet *ifp = NULL; |
3737 | struct ifaddr *ifa; |
3738 | struct ifreq ifr; |
3739 | int error = 0; |
3740 | size_t space; |
3741 | net_thread_marks_t marks; |
3742 | |
3743 | marks = net_thread_marks_push(NET_THREAD_CKREQ_LLADDR); |
3744 | |
3745 | /* |
3746 | * Zero the ifr buffer to make sure we don't |
3747 | * disclose the contents of the stack. |
3748 | */ |
3749 | bzero(&ifr, sizeof (struct ifreq)); |
3750 | |
3751 | space = *ret_space; |
3752 | ifnet_head_lock_shared(); |
3753 | for (ifp = ifnet_head.tqh_first; space > sizeof (ifr) && |
3754 | ifp; ifp = ifp->if_link.tqe_next) { |
3755 | char workbuf[64]; |
3756 | size_t ifnlen, addrs; |
3757 | |
3758 | ifnlen = snprintf(workbuf, sizeof (workbuf), |
3759 | "%s" , if_name(ifp)); |
3760 | if (ifnlen + 1 > sizeof (ifr.ifr_name)) { |
3761 | error = ENAMETOOLONG; |
3762 | break; |
3763 | } else { |
3764 | strlcpy(ifr.ifr_name, workbuf, IFNAMSIZ); |
3765 | } |
3766 | |
3767 | ifnet_lock_shared(ifp); |
3768 | |
3769 | addrs = 0; |
3770 | ifa = ifp->if_addrhead.tqh_first; |
3771 | for (; space > sizeof (ifr) && ifa; |
3772 | ifa = ifa->ifa_link.tqe_next) { |
3773 | struct sockaddr *sa; |
3774 | union { |
3775 | struct sockaddr sa; |
3776 | struct sockaddr_dl sdl; |
3777 | uint8_t buf[SOCK_MAXADDRLEN + 1]; |
3778 | } u; |
3779 | |
3780 | /* |
3781 | * Make sure to accomodate the largest possible |
3782 | * size of SA(if_lladdr)->sa_len. |
3783 | */ |
3784 | _CASSERT(sizeof (u) == (SOCK_MAXADDRLEN + 1)); |
3785 | |
3786 | IFA_LOCK(ifa); |
3787 | sa = ifa->ifa_addr; |
3788 | addrs++; |
3789 | |
3790 | if (ifa == ifp->if_lladdr) { |
3791 | VERIFY(sa->sa_family == AF_LINK); |
3792 | bcopy(sa, &u, sa->sa_len); |
3793 | IFA_UNLOCK(ifa); |
3794 | ifnet_guarded_lladdr_copy_bytes(ifp, |
3795 | LLADDR(&u.sdl), u.sdl.sdl_alen); |
3796 | IFA_LOCK(ifa); |
3797 | sa = &u.sa; |
3798 | } |
3799 | |
3800 | if (cmd == OSIOCGIFCONF32 || cmd == OSIOCGIFCONF64) { |
3801 | struct osockaddr *osa = |
3802 | (struct osockaddr *)(void *)&ifr.ifr_addr; |
3803 | ifr.ifr_addr = *sa; |
3804 | osa->sa_family = sa->sa_family; |
3805 | error = copyout((caddr_t)&ifr, ifrp, |
3806 | sizeof (ifr)); |
3807 | ifrp += sizeof (struct ifreq); |
3808 | } else if (sa->sa_len <= sizeof (*sa)) { |
3809 | ifr.ifr_addr = *sa; |
3810 | error = copyout((caddr_t)&ifr, ifrp, |
3811 | sizeof (ifr)); |
3812 | ifrp += sizeof (struct ifreq); |
3813 | } else { |
3814 | if (space < |
3815 | sizeof (ifr) + sa->sa_len - sizeof (*sa)) { |
3816 | IFA_UNLOCK(ifa); |
3817 | break; |
3818 | } |
3819 | space -= sa->sa_len - sizeof (*sa); |
3820 | error = copyout((caddr_t)&ifr, ifrp, |
3821 | sizeof (ifr.ifr_name)); |
3822 | if (error == 0) { |
3823 | error = copyout((caddr_t)sa, (ifrp + |
3824 | offsetof(struct ifreq, ifr_addr)), |
3825 | sa->sa_len); |
3826 | } |
3827 | ifrp += (sa->sa_len + offsetof(struct ifreq, |
3828 | ifr_addr)); |
3829 | } |
3830 | IFA_UNLOCK(ifa); |
3831 | if (error) |
3832 | break; |
3833 | space -= sizeof (ifr); |
3834 | } |
3835 | ifnet_lock_done(ifp); |
3836 | |
3837 | if (error) |
3838 | break; |
3839 | if (!addrs) { |
3840 | bzero((caddr_t)&ifr.ifr_addr, sizeof (ifr.ifr_addr)); |
3841 | error = copyout((caddr_t)&ifr, ifrp, sizeof (ifr)); |
3842 | if (error) |
3843 | break; |
3844 | space -= sizeof (ifr); |
3845 | ifrp += sizeof (struct ifreq); |
3846 | } |
3847 | } |
3848 | ifnet_head_done(); |
3849 | *ret_space -= space; |
3850 | net_thread_marks_pop(marks); |
3851 | return (error); |
3852 | } |
3853 | |
3854 | /* |
3855 | * Just like if_promisc(), but for all-multicast-reception mode. |
3856 | */ |
3857 | int |
3858 | if_allmulti(struct ifnet *ifp, int onswitch) |
3859 | { |
3860 | int error = 0; |
3861 | int modified = 0; |
3862 | |
3863 | ifnet_lock_exclusive(ifp); |
3864 | |
3865 | if (onswitch) { |
3866 | if (ifp->if_amcount++ == 0) { |
3867 | ifp->if_flags |= IFF_ALLMULTI; |
3868 | modified = 1; |
3869 | } |
3870 | } else { |
3871 | if (ifp->if_amcount > 1) { |
3872 | ifp->if_amcount--; |
3873 | } else { |
3874 | ifp->if_amcount = 0; |
3875 | ifp->if_flags &= ~IFF_ALLMULTI; |
3876 | modified = 1; |
3877 | } |
3878 | } |
3879 | ifnet_lock_done(ifp); |
3880 | |
3881 | if (modified) |
3882 | error = ifnet_ioctl(ifp, 0, SIOCSIFFLAGS, NULL); |
3883 | |
3884 | if (error == 0) |
3885 | rt_ifmsg(ifp); |
3886 | return (error); |
3887 | } |
3888 | |
3889 | static struct ifmultiaddr * |
3890 | ifma_alloc(int how) |
3891 | { |
3892 | struct ifmultiaddr *ifma; |
3893 | |
3894 | ifma = (how == M_WAITOK) ? zalloc(ifma_zone) : |
3895 | zalloc_noblock(ifma_zone); |
3896 | |
3897 | if (ifma != NULL) { |
3898 | bzero(ifma, ifma_size); |
3899 | lck_mtx_init(&ifma->ifma_lock, ifa_mtx_grp, ifa_mtx_attr); |
3900 | ifma->ifma_debug |= IFD_ALLOC; |
3901 | if (ifma_debug != 0) { |
3902 | ifma->ifma_debug |= IFD_DEBUG; |
3903 | ifma->ifma_trace = ifma_trace; |
3904 | } |
3905 | } |
3906 | return (ifma); |
3907 | } |
3908 | |
3909 | static void |
3910 | ifma_free(struct ifmultiaddr *ifma) |
3911 | { |
3912 | IFMA_LOCK(ifma); |
3913 | |
3914 | if (ifma->ifma_protospec != NULL) { |
3915 | panic("%s: Protospec not NULL for ifma=%p" , __func__, ifma); |
3916 | /* NOTREACHED */ |
3917 | } else if ((ifma->ifma_flags & IFMAF_ANONYMOUS) || |
3918 | ifma->ifma_anoncnt != 0) { |
3919 | panic("%s: Freeing ifma=%p with outstanding anon req" , |
3920 | __func__, ifma); |
3921 | /* NOTREACHED */ |
3922 | } else if (ifma->ifma_debug & IFD_ATTACHED) { |
3923 | panic("%s: ifma=%p attached to ifma_ifp=%p is being freed" , |
3924 | __func__, ifma, ifma->ifma_ifp); |
3925 | /* NOTREACHED */ |
3926 | } else if (!(ifma->ifma_debug & IFD_ALLOC)) { |
3927 | panic("%s: ifma %p cannot be freed" , __func__, ifma); |
3928 | /* NOTREACHED */ |
3929 | } else if (ifma->ifma_refcount != 0) { |
3930 | panic("%s: non-zero refcount ifma=%p" , __func__, ifma); |
3931 | /* NOTREACHED */ |
3932 | } else if (ifma->ifma_reqcnt != 0) { |
3933 | panic("%s: non-zero reqcnt ifma=%p" , __func__, ifma); |
3934 | /* NOTREACHED */ |
3935 | } else if (ifma->ifma_ifp != NULL) { |
3936 | panic("%s: non-NULL ifma_ifp=%p for ifma=%p" , __func__, |
3937 | ifma->ifma_ifp, ifma); |
3938 | /* NOTREACHED */ |
3939 | } else if (ifma->ifma_ll != NULL) { |
3940 | panic("%s: non-NULL ifma_ll=%p for ifma=%p" , __func__, |
3941 | ifma->ifma_ll, ifma); |
3942 | /* NOTREACHED */ |
3943 | } |
3944 | ifma->ifma_debug &= ~IFD_ALLOC; |
3945 | if ((ifma->ifma_debug & (IFD_DEBUG | IFD_TRASHED)) == |
3946 | (IFD_DEBUG | IFD_TRASHED)) { |
3947 | lck_mtx_lock(&ifma_trash_lock); |
3948 | TAILQ_REMOVE(&ifma_trash_head, (struct ifmultiaddr_dbg *)ifma, |
3949 | ifma_trash_link); |
3950 | lck_mtx_unlock(&ifma_trash_lock); |
3951 | ifma->ifma_debug &= ~IFD_TRASHED; |
3952 | } |
3953 | IFMA_UNLOCK(ifma); |
3954 | |
3955 | if (ifma->ifma_addr != NULL) { |
3956 | FREE(ifma->ifma_addr, M_IFADDR); |
3957 | ifma->ifma_addr = NULL; |
3958 | } |
3959 | lck_mtx_destroy(&ifma->ifma_lock, ifa_mtx_grp); |
3960 | zfree(ifma_zone, ifma); |
3961 | } |
3962 | |
3963 | static void |
3964 | ifma_trace(struct ifmultiaddr *ifma, int refhold) |
3965 | { |
3966 | struct ifmultiaddr_dbg *ifma_dbg = (struct ifmultiaddr_dbg *)ifma; |
3967 | ctrace_t *tr; |
3968 | u_int32_t idx; |
3969 | u_int16_t *cnt; |
3970 | |
3971 | if (!(ifma->ifma_debug & IFD_DEBUG)) { |
3972 | panic("%s: ifma %p has no debug structure" , __func__, ifma); |
3973 | /* NOTREACHED */ |
3974 | } |
3975 | if (refhold) { |
3976 | cnt = &ifma_dbg->ifma_refhold_cnt; |
3977 | tr = ifma_dbg->ifma_refhold; |
3978 | } else { |
3979 | cnt = &ifma_dbg->ifma_refrele_cnt; |
3980 | tr = ifma_dbg->ifma_refrele; |
3981 | } |
3982 | |
3983 | idx = atomic_add_16_ov(cnt, 1) % IFMA_TRACE_HIST_SIZE; |
3984 | ctrace_record(&tr[idx]); |
3985 | } |
3986 | |
3987 | void |
3988 | ifma_addref(struct ifmultiaddr *ifma, int locked) |
3989 | { |
3990 | if (!locked) |
3991 | IFMA_LOCK(ifma); |
3992 | else |
3993 | IFMA_LOCK_ASSERT_HELD(ifma); |
3994 | |
3995 | if (++ifma->ifma_refcount == 0) { |
3996 | panic("%s: ifma=%p wraparound refcnt" , __func__, ifma); |
3997 | /* NOTREACHED */ |
3998 | } else if (ifma->ifma_trace != NULL) { |
3999 | (*ifma->ifma_trace)(ifma, TRUE); |
4000 | } |
4001 | if (!locked) |
4002 | IFMA_UNLOCK(ifma); |
4003 | } |
4004 | |
4005 | void |
4006 | ifma_remref(struct ifmultiaddr *ifma) |
4007 | { |
4008 | struct ifmultiaddr *ll; |
4009 | |
4010 | IFMA_LOCK(ifma); |
4011 | |
4012 | if (ifma->ifma_refcount == 0) { |
4013 | panic("%s: ifma=%p negative refcnt" , __func__, ifma); |
4014 | /* NOTREACHED */ |
4015 | } else if (ifma->ifma_trace != NULL) { |
4016 | (*ifma->ifma_trace)(ifma, FALSE); |
4017 | } |
4018 | |
4019 | --ifma->ifma_refcount; |
4020 | if (ifma->ifma_refcount > 0) { |
4021 | IFMA_UNLOCK(ifma); |
4022 | return; |
4023 | } |
4024 | |
4025 | ll = ifma->ifma_ll; |
4026 | ifma->ifma_ifp = NULL; |
4027 | ifma->ifma_ll = NULL; |
4028 | IFMA_UNLOCK(ifma); |
4029 | ifma_free(ifma); /* deallocate it */ |
4030 | |
4031 | if (ll != NULL) |
4032 | IFMA_REMREF(ll); |
4033 | } |
4034 | |
4035 | static void |
4036 | if_attach_ifma(struct ifnet *ifp, struct ifmultiaddr *ifma, int anon) |
4037 | { |
4038 | ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_EXCLUSIVE); |
4039 | IFMA_LOCK_ASSERT_HELD(ifma); |
4040 | |
4041 | if (ifma->ifma_ifp != ifp) { |
4042 | panic("%s: Mismatch ifma_ifp=%p != ifp=%p" , __func__, |
4043 | ifma->ifma_ifp, ifp); |
4044 | /* NOTREACHED */ |
4045 | } else if (ifma->ifma_debug & IFD_ATTACHED) { |
4046 | panic("%s: Attempt to attach an already attached ifma=%p" , |
4047 | __func__, ifma); |
4048 | /* NOTREACHED */ |
4049 | } else if (anon && (ifma->ifma_flags & IFMAF_ANONYMOUS)) { |
4050 | panic("%s: ifma=%p unexpected IFMAF_ANONYMOUS" , __func__, ifma); |
4051 | /* NOTREACHED */ |
4052 | } else if (ifma->ifma_debug & IFD_TRASHED) { |
4053 | panic("%s: Attempt to reattach a detached ifma=%p" , |
4054 | __func__, ifma); |
4055 | /* NOTREACHED */ |
4056 | } |
4057 | |
4058 | ifma->ifma_reqcnt++; |
4059 | VERIFY(ifma->ifma_reqcnt == 1); |
4060 | IFMA_ADDREF_LOCKED(ifma); |
4061 | ifma->ifma_debug |= IFD_ATTACHED; |
4062 | if (anon) { |
4063 | ifma->ifma_anoncnt++; |
4064 | VERIFY(ifma->ifma_anoncnt == 1); |
4065 | ifma->ifma_flags |= IFMAF_ANONYMOUS; |
4066 | } |
4067 | |
4068 | LIST_INSERT_HEAD(&ifp->if_multiaddrs, ifma, ifma_link); |
4069 | } |
4070 | |
4071 | static int |
4072 | if_detach_ifma(struct ifnet *ifp, struct ifmultiaddr *ifma, int anon) |
4073 | { |
4074 | ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_EXCLUSIVE); |
4075 | IFMA_LOCK_ASSERT_HELD(ifma); |
4076 | |
4077 | if (ifma->ifma_reqcnt == 0) { |
4078 | panic("%s: ifma=%p negative reqcnt" , __func__, ifma); |
4079 | /* NOTREACHED */ |
4080 | } else if (anon && !(ifma->ifma_flags & IFMAF_ANONYMOUS)) { |
4081 | panic("%s: ifma=%p missing IFMAF_ANONYMOUS" , __func__, ifma); |
4082 | /* NOTREACHED */ |
4083 | } else if (anon && ifma->ifma_anoncnt == 0) { |
4084 | panic("%s: ifma=%p negative anonreqcnt" , __func__, ifma); |
4085 | /* NOTREACHED */ |
4086 | } else if (ifma->ifma_ifp != ifp) { |
4087 | panic("%s: Mismatch ifma_ifp=%p, ifp=%p" , __func__, |
4088 | ifma->ifma_ifp, ifp); |
4089 | /* NOTREACHED */ |
4090 | } |
4091 | |
4092 | if (anon) { |
4093 | --ifma->ifma_anoncnt; |
4094 | if (ifma->ifma_anoncnt > 0) |
4095 | return (0); |
4096 | ifma->ifma_flags &= ~IFMAF_ANONYMOUS; |
4097 | } |
4098 | |
4099 | --ifma->ifma_reqcnt; |
4100 | if (ifma->ifma_reqcnt > 0) |
4101 | return (0); |
4102 | |
4103 | if (ifma->ifma_protospec != NULL) { |
4104 | panic("%s: Protospec not NULL for ifma=%p" , __func__, ifma); |
4105 | /* NOTREACHED */ |
4106 | } else if ((ifma->ifma_flags & IFMAF_ANONYMOUS) || |
4107 | ifma->ifma_anoncnt != 0) { |
4108 | panic("%s: Detaching ifma=%p with outstanding anon req" , |
4109 | __func__, ifma); |
4110 | /* NOTREACHED */ |
4111 | } else if (!(ifma->ifma_debug & IFD_ATTACHED)) { |
4112 | panic("%s: Attempt to detach an unattached address ifma=%p" , |
4113 | __func__, ifma); |
4114 | /* NOTREACHED */ |
4115 | } else if (ifma->ifma_debug & IFD_TRASHED) { |
4116 | panic("%s: ifma %p is already in trash list" , __func__, ifma); |
4117 | /* NOTREACHED */ |
4118 | } |
4119 | |
4120 | /* |
4121 | * NOTE: Caller calls IFMA_REMREF |
4122 | */ |
4123 | ifma->ifma_debug &= ~IFD_ATTACHED; |
4124 | LIST_REMOVE(ifma, ifma_link); |
4125 | if (LIST_EMPTY(&ifp->if_multiaddrs)) |
4126 | ifp->if_updatemcasts = 0; |
4127 | |
4128 | if (ifma->ifma_debug & IFD_DEBUG) { |
4129 | /* Become a regular mutex, just in case */ |
4130 | IFMA_CONVERT_LOCK(ifma); |
4131 | lck_mtx_lock(&ifma_trash_lock); |
4132 | TAILQ_INSERT_TAIL(&ifma_trash_head, |
4133 | (struct ifmultiaddr_dbg *)ifma, ifma_trash_link); |
4134 | lck_mtx_unlock(&ifma_trash_lock); |
4135 | ifma->ifma_debug |= IFD_TRASHED; |
4136 | } |
4137 | |
4138 | return (1); |
4139 | } |
4140 | |
4141 | /* |
4142 | * Find an ifmultiaddr that matches a socket address on an interface. |
4143 | * |
4144 | * Caller is responsible for holding the ifnet_lock while calling |
4145 | * this function. |
4146 | */ |
4147 | static int |
4148 | if_addmulti_doesexist(struct ifnet *ifp, const struct sockaddr *sa, |
4149 | struct ifmultiaddr **retifma, int anon) |
4150 | { |
4151 | struct ifmultiaddr *ifma; |
4152 | |
4153 | for (ifma = LIST_FIRST(&ifp->if_multiaddrs); ifma != NULL; |
4154 | ifma = LIST_NEXT(ifma, ifma_link)) { |
4155 | IFMA_LOCK_SPIN(ifma); |
4156 | if (!ifa_equal(sa, ifma->ifma_addr)) { |
4157 | IFMA_UNLOCK(ifma); |
4158 | continue; |
4159 | } |
4160 | if (anon) { |
4161 | VERIFY(!(ifma->ifma_flags & IFMAF_ANONYMOUS) || |
4162 | ifma->ifma_anoncnt != 0); |
4163 | VERIFY((ifma->ifma_flags & IFMAF_ANONYMOUS) || |
4164 | ifma->ifma_anoncnt == 0); |
4165 | ifma->ifma_anoncnt++; |
4166 | if (!(ifma->ifma_flags & IFMAF_ANONYMOUS)) { |
4167 | VERIFY(ifma->ifma_anoncnt == 1); |
4168 | ifma->ifma_flags |= IFMAF_ANONYMOUS; |
4169 | } |
4170 | } |
4171 | if (!anon || ifma->ifma_anoncnt == 1) { |
4172 | ifma->ifma_reqcnt++; |
4173 | VERIFY(ifma->ifma_reqcnt > 1); |
4174 | } |
4175 | if (retifma != NULL) { |
4176 | *retifma = ifma; |
4177 | IFMA_ADDREF_LOCKED(ifma); |
4178 | } |
4179 | IFMA_UNLOCK(ifma); |
4180 | return (0); |
4181 | } |
4182 | return (ENOENT); |
4183 | } |
4184 | |
4185 | /* |
4186 | * Radar 3642395, make sure all multicasts are in a standard format. |
4187 | */ |
4188 | static struct sockaddr * |
4189 | copy_and_normalize(const struct sockaddr *original) |
4190 | { |
4191 | int alen = 0; |
4192 | const u_char *aptr = NULL; |
4193 | struct sockaddr *copy = NULL; |
4194 | struct sockaddr_dl *sdl_new = NULL; |
4195 | int len = 0; |
4196 | |
4197 | if (original->sa_family != AF_LINK && |
4198 | original->sa_family != AF_UNSPEC) { |
4199 | /* Just make a copy */ |
4200 | MALLOC(copy, struct sockaddr *, original->sa_len, |
4201 | M_IFADDR, M_WAITOK); |
4202 | if (copy != NULL) |
4203 | bcopy(original, copy, original->sa_len); |
4204 | return (copy); |
4205 | } |
4206 | |
4207 | switch (original->sa_family) { |
4208 | case AF_LINK: { |
4209 | const struct sockaddr_dl *sdl_original = |
4210 | (struct sockaddr_dl *)(uintptr_t)(size_t)original; |
4211 | |
4212 | if (sdl_original->sdl_nlen + sdl_original->sdl_alen + |
4213 | sdl_original->sdl_slen + |
4214 | offsetof(struct sockaddr_dl, sdl_data) > |
4215 | sdl_original->sdl_len) |
4216 | return (NULL); |
4217 | |
4218 | alen = sdl_original->sdl_alen; |
4219 | aptr = CONST_LLADDR(sdl_original); |
4220 | } |
4221 | break; |
4222 | |
4223 | case AF_UNSPEC: { |
4224 | if (original->sa_len < ETHER_ADDR_LEN + |
4225 | offsetof(struct sockaddr, sa_data)) { |
4226 | return (NULL); |
4227 | } |
4228 | |
4229 | alen = ETHER_ADDR_LEN; |
4230 | aptr = (const u_char *)original->sa_data; |
4231 | } |
4232 | break; |
4233 | } |
4234 | |
4235 | if (alen == 0 || aptr == NULL) |
4236 | return (NULL); |
4237 | |
4238 | len = alen + offsetof(struct sockaddr_dl, sdl_data); |
4239 | MALLOC(sdl_new, struct sockaddr_dl *, len, M_IFADDR, M_WAITOK); |
4240 | |
4241 | if (sdl_new != NULL) { |
4242 | bzero(sdl_new, len); |
4243 | sdl_new->sdl_len = len; |
4244 | sdl_new->sdl_family = AF_LINK; |
4245 | sdl_new->sdl_alen = alen; |
4246 | bcopy(aptr, LLADDR(sdl_new), alen); |
4247 | } |
4248 | |
4249 | return ((struct sockaddr *)sdl_new); |
4250 | } |
4251 | |
4252 | /* |
4253 | * Network-layer protocol domains which hold references to the underlying |
4254 | * link-layer record must use this routine. |
4255 | */ |
4256 | int |
4257 | if_addmulti(struct ifnet *ifp, const struct sockaddr *sa, |
4258 | struct ifmultiaddr **retifma) |
4259 | { |
4260 | return (if_addmulti_common(ifp, sa, retifma, 0)); |
4261 | } |
4262 | |
4263 | /* |
4264 | * Anything other than network-layer protocol domains which hold references |
4265 | * to the underlying link-layer record must use this routine: SIOCADDMULTI |
4266 | * ioctl, ifnet_add_multicast(), if_bond. |
4267 | */ |
4268 | int |
4269 | if_addmulti_anon(struct ifnet *ifp, const struct sockaddr *sa, |
4270 | struct ifmultiaddr **retifma) |
4271 | { |
4272 | return (if_addmulti_common(ifp, sa, retifma, 1)); |
4273 | } |
4274 | |
4275 | /* |
4276 | * Register an additional multicast address with a network interface. |
4277 | * |
4278 | * - If the address is already present, bump the reference count on the |
4279 | * address and return. |
4280 | * - If the address is not link-layer, look up a link layer address. |
4281 | * - Allocate address structures for one or both addresses, and attach to the |
4282 | * multicast address list on the interface. If automatically adding a link |
4283 | * layer address, the protocol address will own a reference to the link |
4284 | * layer address, to be freed when it is freed. |
4285 | * - Notify the network device driver of an addition to the multicast address |
4286 | * list. |
4287 | * |
4288 | * 'sa' points to caller-owned memory with the desired multicast address. |
4289 | * |
4290 | * 'retifma' will be used to return a pointer to the resulting multicast |
4291 | * address reference, if desired. |
4292 | * |
4293 | * 'anon' indicates a link-layer address with no protocol address reference |
4294 | * made to it. Anything other than network-layer protocol domain requests |
4295 | * are considered as anonymous. |
4296 | */ |
4297 | static int |
4298 | if_addmulti_common(struct ifnet *ifp, const struct sockaddr *sa, |
4299 | struct ifmultiaddr **retifma, int anon) |
4300 | { |
4301 | struct sockaddr_storage storage; |
4302 | struct sockaddr *llsa = NULL; |
4303 | struct sockaddr *dupsa = NULL; |
4304 | int error = 0, ll_firstref = 0, lladdr; |
4305 | struct ifmultiaddr *ifma = NULL; |
4306 | struct ifmultiaddr *llifma = NULL; |
4307 | |
4308 | /* Only AF_UNSPEC/AF_LINK is allowed for an "anonymous" address */ |
4309 | VERIFY(!anon || sa->sa_family == AF_UNSPEC || |
4310 | sa->sa_family == AF_LINK); |
4311 | |
4312 | /* If sa is a AF_LINK or AF_UNSPEC, duplicate and normalize it */ |
4313 | if (sa->sa_family == AF_LINK || sa->sa_family == AF_UNSPEC) { |
4314 | dupsa = copy_and_normalize(sa); |
4315 | if (dupsa == NULL) { |
4316 | error = ENOMEM; |
4317 | goto cleanup; |
4318 | } |
4319 | sa = dupsa; |
4320 | } |
4321 | |
4322 | ifnet_lock_exclusive(ifp); |
4323 | if (!(ifp->if_flags & IFF_MULTICAST)) { |
4324 | error = EADDRNOTAVAIL; |
4325 | ifnet_lock_done(ifp); |
4326 | goto cleanup; |
4327 | } |
4328 | |
4329 | /* If the address is already present, return a new reference to it */ |
4330 | error = if_addmulti_doesexist(ifp, sa, retifma, anon); |
4331 | ifnet_lock_done(ifp); |
4332 | if (error == 0) |
4333 | goto cleanup; |
4334 | |
4335 | /* |
4336 | * The address isn't already present; give the link layer a chance |
4337 | * to accept/reject it, and also find out which AF_LINK address this |
4338 | * maps to, if it isn't one already. |
4339 | */ |
4340 | error = dlil_resolve_multi(ifp, sa, (struct sockaddr *)&storage, |
4341 | sizeof (storage)); |
4342 | if (error == 0 && storage.ss_len != 0) { |
4343 | llsa = copy_and_normalize((struct sockaddr *)&storage); |
4344 | if (llsa == NULL) { |
4345 | error = ENOMEM; |
4346 | goto cleanup; |
4347 | } |
4348 | |
4349 | llifma = ifma_alloc(M_WAITOK); |
4350 | if (llifma == NULL) { |
4351 | error = ENOMEM; |
4352 | goto cleanup; |
4353 | } |
4354 | } |
4355 | |
4356 | /* to be similar to FreeBSD */ |
4357 | if (error == EOPNOTSUPP) |
4358 | error = 0; |
4359 | else if (error != 0) |
4360 | goto cleanup; |
4361 | |
4362 | /* Allocate while we aren't holding any locks */ |
4363 | if (dupsa == NULL) { |
4364 | dupsa = copy_and_normalize(sa); |
4365 | if (dupsa == NULL) { |
4366 | error = ENOMEM; |
4367 | goto cleanup; |
4368 | } |
4369 | } |
4370 | ifma = ifma_alloc(M_WAITOK); |
4371 | if (ifma == NULL) { |
4372 | error = ENOMEM; |
4373 | goto cleanup; |
4374 | } |
4375 | |
4376 | ifnet_lock_exclusive(ifp); |
4377 | /* |
4378 | * Check again for the matching multicast. |
4379 | */ |
4380 | error = if_addmulti_doesexist(ifp, sa, retifma, anon); |
4381 | if (error == 0) { |
4382 | ifnet_lock_done(ifp); |
4383 | goto cleanup; |
4384 | } |
4385 | |
4386 | if (llifma != NULL) { |
4387 | VERIFY(!anon); /* must not get here if "anonymous" */ |
4388 | if (if_addmulti_doesexist(ifp, llsa, &ifma->ifma_ll, 0) == 0) { |
4389 | FREE(llsa, M_IFADDR); |
4390 | llsa = NULL; |
4391 | ifma_free(llifma); |
4392 | llifma = NULL; |
4393 | VERIFY(ifma->ifma_ll->ifma_ifp == ifp); |
4394 | } else { |
4395 | ll_firstref = 1; |
4396 | llifma->ifma_addr = llsa; |
4397 | llifma->ifma_ifp = ifp; |
4398 | IFMA_LOCK(llifma); |
4399 | if_attach_ifma(ifp, llifma, 0); |
4400 | /* add extra refcnt for ifma */ |
4401 | IFMA_ADDREF_LOCKED(llifma); |
4402 | IFMA_UNLOCK(llifma); |
4403 | ifma->ifma_ll = llifma; |
4404 | } |
4405 | } |
4406 | |
4407 | /* "anonymous" request should not result in network address */ |
4408 | VERIFY(!anon || ifma->ifma_ll == NULL); |
4409 | |
4410 | ifma->ifma_addr = dupsa; |
4411 | ifma->ifma_ifp = ifp; |
4412 | IFMA_LOCK(ifma); |
4413 | if_attach_ifma(ifp, ifma, anon); |
4414 | IFMA_ADDREF_LOCKED(ifma); /* for this routine */ |
4415 | if (retifma != NULL) { |
4416 | *retifma = ifma; |
4417 | IFMA_ADDREF_LOCKED(*retifma); /* for caller */ |
4418 | } |
4419 | lladdr = (ifma->ifma_addr->sa_family == AF_UNSPEC || |
4420 | ifma->ifma_addr->sa_family == AF_LINK); |
4421 | IFMA_UNLOCK(ifma); |
4422 | ifnet_lock_done(ifp); |
4423 | |
4424 | rt_newmaddrmsg(RTM_NEWMADDR, ifma); |
4425 | IFMA_REMREF(ifma); /* for this routine */ |
4426 | |
4427 | /* |
4428 | * We are certain we have added something, so call down to the |
4429 | * interface to let them know about it. Do this only for newly- |
4430 | * added AF_LINK/AF_UNSPEC address in the if_multiaddrs set. |
4431 | */ |
4432 | if (lladdr || ll_firstref) |
4433 | (void) ifnet_ioctl(ifp, 0, SIOCADDMULTI, NULL); |
4434 | |
4435 | if (ifp->if_updatemcasts > 0) |
4436 | ifp->if_updatemcasts = 0; |
4437 | |
4438 | return (0); |
4439 | |
4440 | cleanup: |
4441 | if (ifma != NULL) |
4442 | ifma_free(ifma); |
4443 | if (dupsa != NULL) |
4444 | FREE(dupsa, M_IFADDR); |
4445 | if (llifma != NULL) |
4446 | ifma_free(llifma); |
4447 | if (llsa != NULL) |
4448 | FREE(llsa, M_IFADDR); |
4449 | |
4450 | return (error); |
4451 | } |
4452 | |
4453 | /* |
4454 | * Delete a multicast group membership by network-layer group address. |
4455 | * This routine is deprecated. |
4456 | */ |
4457 | int |
4458 | if_delmulti(struct ifnet *ifp, const struct sockaddr *sa) |
4459 | { |
4460 | return (if_delmulti_common(NULL, ifp, sa, 0)); |
4461 | } |
4462 | |
4463 | /* |
4464 | * Delete a multicast group membership by group membership pointer. |
4465 | * Network-layer protocol domains must use this routine. |
4466 | */ |
4467 | int |
4468 | if_delmulti_ifma(struct ifmultiaddr *ifma) |
4469 | { |
4470 | return (if_delmulti_common(ifma, NULL, NULL, 0)); |
4471 | } |
4472 | |
4473 | /* |
4474 | * Anything other than network-layer protocol domains which hold references |
4475 | * to the underlying link-layer record must use this routine: SIOCDELMULTI |
4476 | * ioctl, ifnet_remove_multicast(), if_bond. |
4477 | */ |
4478 | int |
4479 | if_delmulti_anon(struct ifnet *ifp, const struct sockaddr *sa) |
4480 | { |
4481 | return (if_delmulti_common(NULL, ifp, sa, 1)); |
4482 | } |
4483 | |
4484 | /* |
4485 | * Delete a multicast group membership by network-layer group address. |
4486 | * |
4487 | * Returns ENOENT if the entry could not be found. |
4488 | */ |
4489 | static int |
4490 | if_delmulti_common(struct ifmultiaddr *ifma, struct ifnet *ifp, |
4491 | const struct sockaddr *sa, int anon) |
4492 | { |
4493 | struct sockaddr *dupsa = NULL; |
4494 | int lastref, ll_lastref = 0, lladdr; |
4495 | struct ifmultiaddr *ll = NULL; |
4496 | |
4497 | /* sanity check for callers */ |
4498 | VERIFY(ifma != NULL || (ifp != NULL && sa != NULL)); |
4499 | |
4500 | if (ifma != NULL) |
4501 | ifp = ifma->ifma_ifp; |
4502 | |
4503 | if (sa != NULL && |
4504 | (sa->sa_family == AF_LINK || sa->sa_family == AF_UNSPEC)) { |
4505 | dupsa = copy_and_normalize(sa); |
4506 | if (dupsa == NULL) |
4507 | return (ENOMEM); |
4508 | sa = dupsa; |
4509 | } |
4510 | |
4511 | ifnet_lock_exclusive(ifp); |
4512 | if (ifma == NULL) { |
4513 | for (ifma = LIST_FIRST(&ifp->if_multiaddrs); ifma != NULL; |
4514 | ifma = LIST_NEXT(ifma, ifma_link)) { |
4515 | IFMA_LOCK(ifma); |
4516 | if (!ifa_equal(sa, ifma->ifma_addr) || |
4517 | (anon && !(ifma->ifma_flags & IFMAF_ANONYMOUS))) { |
4518 | VERIFY(!(ifma->ifma_flags & IFMAF_ANONYMOUS) || |
4519 | ifma->ifma_anoncnt != 0); |
4520 | IFMA_UNLOCK(ifma); |
4521 | continue; |
4522 | } |
4523 | /* found; keep it locked */ |
4524 | break; |
4525 | } |
4526 | if (ifma == NULL) { |
4527 | if (dupsa != NULL) |
4528 | FREE(dupsa, M_IFADDR); |
4529 | ifnet_lock_done(ifp); |
4530 | return (ENOENT); |
4531 | } |
4532 | } else { |
4533 | IFMA_LOCK(ifma); |
4534 | } |
4535 | IFMA_LOCK_ASSERT_HELD(ifma); |
4536 | IFMA_ADDREF_LOCKED(ifma); /* for this routine */ |
4537 | lastref = if_detach_ifma(ifp, ifma, anon); |
4538 | VERIFY(!lastref || (!(ifma->ifma_debug & IFD_ATTACHED) && |
4539 | ifma->ifma_reqcnt == 0)); |
4540 | VERIFY(!anon || ifma->ifma_ll == NULL); |
4541 | ll = ifma->ifma_ll; |
4542 | lladdr = (ifma->ifma_addr->sa_family == AF_UNSPEC || |
4543 | ifma->ifma_addr->sa_family == AF_LINK); |
4544 | IFMA_UNLOCK(ifma); |
4545 | if (lastref && ll != NULL) { |
4546 | IFMA_LOCK(ll); |
4547 | ll_lastref = if_detach_ifma(ifp, ll, 0); |
4548 | IFMA_UNLOCK(ll); |
4549 | } |
4550 | ifnet_lock_done(ifp); |
4551 | |
4552 | if (lastref) |
4553 | rt_newmaddrmsg(RTM_DELMADDR, ifma); |
4554 | |
4555 | if ((ll == NULL && lastref && lladdr) || ll_lastref) { |
4556 | /* |
4557 | * Make sure the interface driver is notified in the |
4558 | * case of a link layer mcast group being left. Do |
4559 | * this only for a AF_LINK/AF_UNSPEC address that has |
4560 | * been removed from the if_multiaddrs set. |
4561 | */ |
4562 | ifnet_ioctl(ifp, 0, SIOCDELMULTI, NULL); |
4563 | } |
4564 | |
4565 | if (lastref) |
4566 | IFMA_REMREF(ifma); /* for if_multiaddrs list */ |
4567 | if (ll_lastref) |
4568 | IFMA_REMREF(ll); /* for if_multiaddrs list */ |
4569 | |
4570 | IFMA_REMREF(ifma); /* for this routine */ |
4571 | if (dupsa != NULL) |
4572 | FREE(dupsa, M_IFADDR); |
4573 | |
4574 | return (0); |
4575 | } |
4576 | |
4577 | /* |
4578 | * Shutdown all network activity. Used boot() when halting |
4579 | * system. |
4580 | */ |
4581 | int |
4582 | if_down_all(void) |
4583 | { |
4584 | struct ifnet **ifp; |
4585 | u_int32_t count; |
4586 | u_int32_t i; |
4587 | |
4588 | if (ifnet_list_get_all(IFNET_FAMILY_ANY, &ifp, &count) == 0) { |
4589 | for (i = 0; i < count; i++) { |
4590 | if_down(ifp[i]); |
4591 | dlil_proto_unplumb_all(ifp[i]); |
4592 | } |
4593 | ifnet_list_free(ifp); |
4594 | } |
4595 | |
4596 | return (0); |
4597 | } |
4598 | |
4599 | /* |
4600 | * Delete Routes for a Network Interface |
4601 | * |
4602 | * Called for each routing entry via the rnh->rnh_walktree() call above |
4603 | * to delete all route entries referencing a detaching network interface. |
4604 | * |
4605 | * Arguments: |
4606 | * rn pointer to node in the routing table |
4607 | * arg argument passed to rnh->rnh_walktree() - detaching interface |
4608 | * |
4609 | * Returns: |
4610 | * 0 successful |
4611 | * errno failed - reason indicated |
4612 | * |
4613 | */ |
4614 | static int |
4615 | if_rtdel(struct radix_node *rn, void *arg) |
4616 | { |
4617 | struct rtentry *rt = (struct rtentry *)rn; |
4618 | struct ifnet *ifp = arg; |
4619 | int err; |
4620 | |
4621 | if (rt == NULL) |
4622 | return (0); |
4623 | /* |
4624 | * Checking against RTF_UP protects against walktree |
4625 | * recursion problems with cloned routes. |
4626 | */ |
4627 | RT_LOCK(rt); |
4628 | if (rt->rt_ifp == ifp && (rt->rt_flags & RTF_UP)) { |
4629 | /* |
4630 | * Safe to drop rt_lock and use rt_key, rt_gateway, |
4631 | * since holding rnh_lock here prevents another thread |
4632 | * from calling rt_setgate() on this route. |
4633 | */ |
4634 | RT_UNLOCK(rt); |
4635 | err = rtrequest_locked(RTM_DELETE, rt_key(rt), rt->rt_gateway, |
4636 | rt_mask(rt), rt->rt_flags, NULL); |
4637 | if (err) { |
4638 | log(LOG_WARNING, "if_rtdel: error %d\n" , err); |
4639 | } |
4640 | } else { |
4641 | RT_UNLOCK(rt); |
4642 | } |
4643 | return (0); |
4644 | } |
4645 | |
4646 | /* |
4647 | * Removes routing table reference to a given interface |
4648 | * for a given protocol family |
4649 | */ |
4650 | void |
4651 | if_rtproto_del(struct ifnet *ifp, int protocol) |
4652 | { |
4653 | struct radix_node_head *rnh; |
4654 | |
4655 | if ((protocol <= AF_MAX) && (protocol >= 0) && |
4656 | ((rnh = rt_tables[protocol]) != NULL) && (ifp != NULL)) { |
4657 | lck_mtx_lock(rnh_lock); |
4658 | (void) rnh->rnh_walktree(rnh, if_rtdel, ifp); |
4659 | lck_mtx_unlock(rnh_lock); |
4660 | } |
4661 | } |
4662 | |
4663 | static int |
4664 | if_rtmtu(struct radix_node *rn, void *arg) |
4665 | { |
4666 | struct rtentry *rt = (struct rtentry *)rn; |
4667 | struct ifnet *ifp = arg; |
4668 | |
4669 | RT_LOCK(rt); |
4670 | if (rt->rt_ifp == ifp) { |
4671 | /* |
4672 | * Update the MTU of this entry only if the MTU |
4673 | * has not been locked (RTV_MTU is not set) and |
4674 | * if it was non-zero to begin with. |
4675 | */ |
4676 | if (!(rt->rt_rmx.rmx_locks & RTV_MTU) && rt->rt_rmx.rmx_mtu) { |
4677 | rt->rt_rmx.rmx_mtu = ifp->if_mtu; |
4678 | if (rt_key(rt)->sa_family == AF_INET && |
4679 | INTF_ADJUST_MTU_FOR_CLAT46(ifp)) { |
4680 | rt->rt_rmx.rmx_mtu = IN6_LINKMTU(ifp); |
4681 | /* Further adjust the size for CLAT46 expansion */ |
4682 | rt->rt_rmx.rmx_mtu -= CLAT46_HDR_EXPANSION_OVERHD; |
4683 | } |
4684 | } |
4685 | } |
4686 | RT_UNLOCK(rt); |
4687 | |
4688 | return (0); |
4689 | } |
4690 | |
4691 | /* |
4692 | * Update the MTU metric of all route entries in all protocol tables |
4693 | * associated with a particular interface; this is called when the |
4694 | * MTU of that interface has changed. |
4695 | */ |
4696 | static void |
4697 | if_rtmtu_update(struct ifnet *ifp) |
4698 | { |
4699 | struct radix_node_head *rnh; |
4700 | int p; |
4701 | |
4702 | for (p = 0; p < AF_MAX + 1; p++) { |
4703 | if ((rnh = rt_tables[p]) == NULL) |
4704 | continue; |
4705 | |
4706 | lck_mtx_lock(rnh_lock); |
4707 | (void) rnh->rnh_walktree(rnh, if_rtmtu, ifp); |
4708 | lck_mtx_unlock(rnh_lock); |
4709 | } |
4710 | routegenid_update(); |
4711 | } |
4712 | |
4713 | __private_extern__ void |
4714 | if_data_internal_to_if_data(struct ifnet *ifp, |
4715 | const struct if_data_internal *if_data_int, struct if_data *if_data) |
4716 | { |
4717 | #pragma unused(ifp) |
4718 | #define COPYFIELD(fld) if_data->fld = if_data_int->fld |
4719 | #define COPYFIELD32(fld) if_data->fld = (u_int32_t)(if_data_int->fld) |
4720 | /* compiler will cast down to 32-bit */ |
4721 | #define COPYFIELD32_ATOMIC(fld) do { \ |
4722 | atomic_get_64(if_data->fld, \ |
4723 | (u_int64_t *)(void *)(uintptr_t)&if_data_int->fld); \ |
4724 | } while (0) |
4725 | |
4726 | COPYFIELD(ifi_type); |
4727 | COPYFIELD(ifi_typelen); |
4728 | COPYFIELD(ifi_physical); |
4729 | COPYFIELD(ifi_addrlen); |
4730 | COPYFIELD(ifi_hdrlen); |
4731 | COPYFIELD(ifi_recvquota); |
4732 | COPYFIELD(ifi_xmitquota); |
4733 | if_data->ifi_unused1 = 0; |
4734 | COPYFIELD(ifi_mtu); |
4735 | COPYFIELD(ifi_metric); |
4736 | if (if_data_int->ifi_baudrate & 0xFFFFFFFF00000000LL) { |
4737 | if_data->ifi_baudrate = 0xFFFFFFFF; |
4738 | } else { |
4739 | COPYFIELD32(ifi_baudrate); |
4740 | } |
4741 | |
4742 | COPYFIELD32_ATOMIC(ifi_ipackets); |
4743 | COPYFIELD32_ATOMIC(ifi_ierrors); |
4744 | COPYFIELD32_ATOMIC(ifi_opackets); |
4745 | COPYFIELD32_ATOMIC(ifi_oerrors); |
4746 | COPYFIELD32_ATOMIC(ifi_collisions); |
4747 | COPYFIELD32_ATOMIC(ifi_ibytes); |
4748 | COPYFIELD32_ATOMIC(ifi_obytes); |
4749 | COPYFIELD32_ATOMIC(ifi_imcasts); |
4750 | COPYFIELD32_ATOMIC(ifi_omcasts); |
4751 | COPYFIELD32_ATOMIC(ifi_iqdrops); |
4752 | COPYFIELD32_ATOMIC(ifi_noproto); |
4753 | |
4754 | COPYFIELD(ifi_recvtiming); |
4755 | COPYFIELD(ifi_xmittiming); |
4756 | |
4757 | if_data->ifi_lastchange.tv_sec = if_data_int->ifi_lastchange.tv_sec; |
4758 | if_data->ifi_lastchange.tv_usec = if_data_int->ifi_lastchange.tv_usec; |
4759 | |
4760 | if_data->ifi_lastchange.tv_sec += boottime_sec(); |
4761 | |
4762 | if_data->ifi_unused2 = 0; |
4763 | COPYFIELD(ifi_hwassist); |
4764 | if_data->ifi_reserved1 = 0; |
4765 | if_data->ifi_reserved2 = 0; |
4766 | #undef COPYFIELD32_ATOMIC |
4767 | #undef COPYFIELD32 |
4768 | #undef COPYFIELD |
4769 | } |
4770 | |
4771 | __private_extern__ void |
4772 | if_data_internal_to_if_data64(struct ifnet *ifp, |
4773 | const struct if_data_internal *if_data_int, |
4774 | struct if_data64 *if_data64) |
4775 | { |
4776 | #pragma unused(ifp) |
4777 | #define COPYFIELD64(fld) if_data64->fld = if_data_int->fld |
4778 | #define COPYFIELD64_ATOMIC(fld) do { \ |
4779 | atomic_get_64(if_data64->fld, \ |
4780 | (u_int64_t *)(void *)(uintptr_t)&if_data_int->fld); \ |
4781 | } while (0) |
4782 | |
4783 | COPYFIELD64(ifi_type); |
4784 | COPYFIELD64(ifi_typelen); |
4785 | COPYFIELD64(ifi_physical); |
4786 | COPYFIELD64(ifi_addrlen); |
4787 | COPYFIELD64(ifi_hdrlen); |
4788 | COPYFIELD64(ifi_recvquota); |
4789 | COPYFIELD64(ifi_xmitquota); |
4790 | if_data64->ifi_unused1 = 0; |
4791 | COPYFIELD64(ifi_mtu); |
4792 | COPYFIELD64(ifi_metric); |
4793 | COPYFIELD64(ifi_baudrate); |
4794 | |
4795 | COPYFIELD64_ATOMIC(ifi_ipackets); |
4796 | COPYFIELD64_ATOMIC(ifi_ierrors); |
4797 | COPYFIELD64_ATOMIC(ifi_opackets); |
4798 | COPYFIELD64_ATOMIC(ifi_oerrors); |
4799 | COPYFIELD64_ATOMIC(ifi_collisions); |
4800 | COPYFIELD64_ATOMIC(ifi_ibytes); |
4801 | COPYFIELD64_ATOMIC(ifi_obytes); |
4802 | COPYFIELD64_ATOMIC(ifi_imcasts); |
4803 | COPYFIELD64_ATOMIC(ifi_omcasts); |
4804 | COPYFIELD64_ATOMIC(ifi_iqdrops); |
4805 | COPYFIELD64_ATOMIC(ifi_noproto); |
4806 | |
4807 | /* |
4808 | * Note these two fields are actually 32 bit, so doing |
4809 | * COPYFIELD64_ATOMIC will cause them to be misaligned |
4810 | */ |
4811 | COPYFIELD64(ifi_recvtiming); |
4812 | COPYFIELD64(ifi_xmittiming); |
4813 | |
4814 | if_data64->ifi_lastchange.tv_sec = if_data_int->ifi_lastchange.tv_sec; |
4815 | if_data64->ifi_lastchange.tv_usec = if_data_int->ifi_lastchange.tv_usec; |
4816 | |
4817 | if_data64->ifi_lastchange.tv_sec += boottime_sec(); |
4818 | |
4819 | #undef COPYFIELD64 |
4820 | } |
4821 | |
4822 | __private_extern__ void |
4823 | if_copy_traffic_class(struct ifnet *ifp, |
4824 | struct if_traffic_class *if_tc) |
4825 | { |
4826 | #define COPY_IF_TC_FIELD64_ATOMIC(fld) do { \ |
4827 | atomic_get_64(if_tc->fld, \ |
4828 | (u_int64_t *)(void *)(uintptr_t)&ifp->if_tc.fld); \ |
4829 | } while (0) |
4830 | |
4831 | bzero(if_tc, sizeof (*if_tc)); |
4832 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ibepackets); |
4833 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ibebytes); |
4834 | COPY_IF_TC_FIELD64_ATOMIC(ifi_obepackets); |
4835 | COPY_IF_TC_FIELD64_ATOMIC(ifi_obebytes); |
4836 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ibkpackets); |
4837 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ibkbytes); |
4838 | COPY_IF_TC_FIELD64_ATOMIC(ifi_obkpackets); |
4839 | COPY_IF_TC_FIELD64_ATOMIC(ifi_obkbytes); |
4840 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ivipackets); |
4841 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ivibytes); |
4842 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ovipackets); |
4843 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ovibytes); |
4844 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ivopackets); |
4845 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ivobytes); |
4846 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ovopackets); |
4847 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ovobytes); |
4848 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ipvpackets); |
4849 | COPY_IF_TC_FIELD64_ATOMIC(ifi_ipvbytes); |
4850 | COPY_IF_TC_FIELD64_ATOMIC(ifi_opvpackets); |
4851 | COPY_IF_TC_FIELD64_ATOMIC(ifi_opvbytes); |
4852 | |
4853 | #undef COPY_IF_TC_FIELD64_ATOMIC |
4854 | } |
4855 | |
4856 | void |
4857 | if_copy_data_extended(struct ifnet *ifp, struct if_data_extended *if_de) |
4858 | { |
4859 | #define COPY_IF_DE_FIELD64_ATOMIC(fld) do { \ |
4860 | atomic_get_64(if_de->fld, \ |
4861 | (u_int64_t *)(void *)(uintptr_t)&ifp->if_data.fld); \ |
4862 | } while (0) |
4863 | |
4864 | bzero(if_de, sizeof (*if_de)); |
4865 | COPY_IF_DE_FIELD64_ATOMIC(ifi_alignerrs); |
4866 | COPY_IF_DE_FIELD64_ATOMIC(ifi_dt_bytes); |
4867 | COPY_IF_DE_FIELD64_ATOMIC(ifi_fpackets); |
4868 | COPY_IF_DE_FIELD64_ATOMIC(ifi_fbytes); |
4869 | |
4870 | #undef COPY_IF_DE_FIELD64_ATOMIC |
4871 | } |
4872 | |
4873 | void |
4874 | if_copy_packet_stats(struct ifnet *ifp, struct if_packet_stats *if_ps) |
4875 | { |
4876 | #define COPY_IF_PS_TCP_FIELD64_ATOMIC(fld) do { \ |
4877 | atomic_get_64(if_ps->ifi_tcp_##fld, \ |
4878 | (u_int64_t *)(void *)(uintptr_t)&ifp->if_tcp_stat->fld); \ |
4879 | } while (0) |
4880 | |
4881 | #define COPY_IF_PS_UDP_FIELD64_ATOMIC(fld) do { \ |
4882 | atomic_get_64(if_ps->ifi_udp_##fld, \ |
4883 | (u_int64_t *)(void *)(uintptr_t)&ifp->if_udp_stat->fld); \ |
4884 | } while (0) |
4885 | |
4886 | COPY_IF_PS_TCP_FIELD64_ATOMIC(badformat); |
4887 | COPY_IF_PS_TCP_FIELD64_ATOMIC(unspecv6); |
4888 | COPY_IF_PS_TCP_FIELD64_ATOMIC(synfin); |
4889 | COPY_IF_PS_TCP_FIELD64_ATOMIC(badformatipsec); |
4890 | COPY_IF_PS_TCP_FIELD64_ATOMIC(noconnnolist); |
4891 | COPY_IF_PS_TCP_FIELD64_ATOMIC(noconnlist); |
4892 | COPY_IF_PS_TCP_FIELD64_ATOMIC(listbadsyn); |
4893 | COPY_IF_PS_TCP_FIELD64_ATOMIC(icmp6unreach); |
4894 | COPY_IF_PS_TCP_FIELD64_ATOMIC(deprecate6); |
4895 | COPY_IF_PS_TCP_FIELD64_ATOMIC(ooopacket); |
4896 | COPY_IF_PS_TCP_FIELD64_ATOMIC(rstinsynrcv); |
4897 | COPY_IF_PS_TCP_FIELD64_ATOMIC(dospacket); |
4898 | COPY_IF_PS_TCP_FIELD64_ATOMIC(cleanup); |
4899 | COPY_IF_PS_TCP_FIELD64_ATOMIC(synwindow); |
4900 | |
4901 | COPY_IF_PS_UDP_FIELD64_ATOMIC(port_unreach); |
4902 | COPY_IF_PS_UDP_FIELD64_ATOMIC(faithprefix); |
4903 | COPY_IF_PS_UDP_FIELD64_ATOMIC(port0); |
4904 | COPY_IF_PS_UDP_FIELD64_ATOMIC(badlength); |
4905 | COPY_IF_PS_UDP_FIELD64_ATOMIC(badchksum); |
4906 | COPY_IF_PS_UDP_FIELD64_ATOMIC(badmcast); |
4907 | COPY_IF_PS_UDP_FIELD64_ATOMIC(cleanup); |
4908 | COPY_IF_PS_UDP_FIELD64_ATOMIC(badipsec); |
4909 | |
4910 | #undef COPY_IF_PS_TCP_FIELD64_ATOMIC |
4911 | #undef COPY_IF_PS_UDP_FIELD64_ATOMIC |
4912 | } |
4913 | |
4914 | void |
4915 | if_copy_rxpoll_stats(struct ifnet *ifp, struct if_rxpoll_stats *if_rs) |
4916 | { |
4917 | bzero(if_rs, sizeof (*if_rs)); |
4918 | if (!(ifp->if_eflags & IFEF_RXPOLL) || !ifnet_is_attached(ifp, 1)) |
4919 | return; |
4920 | |
4921 | /* by now, ifnet will stay attached so if_inp must be valid */ |
4922 | VERIFY(ifp->if_inp != NULL); |
4923 | bcopy(&ifp->if_inp->pstats, if_rs, sizeof (*if_rs)); |
4924 | |
4925 | /* Release the IO refcnt */ |
4926 | ifnet_decr_iorefcnt(ifp); |
4927 | } |
4928 | |
4929 | struct ifaddr * |
4930 | ifa_remref(struct ifaddr *ifa, int locked) |
4931 | { |
4932 | if (!locked) |
4933 | IFA_LOCK_SPIN(ifa); |
4934 | else |
4935 | IFA_LOCK_ASSERT_HELD(ifa); |
4936 | |
4937 | if (ifa->ifa_refcnt == 0) |
4938 | panic("%s: ifa %p negative refcnt\n" , __func__, ifa); |
4939 | else if (ifa->ifa_trace != NULL) |
4940 | (*ifa->ifa_trace)(ifa, FALSE); |
4941 | if (--ifa->ifa_refcnt == 0) { |
4942 | if (ifa->ifa_debug & IFD_ATTACHED) |
4943 | panic("ifa %p attached to ifp is being freed\n" , ifa); |
4944 | /* |
4945 | * Some interface addresses are allocated either statically |
4946 | * or carved out of a larger block. Only free it if it was |
4947 | * allocated via MALLOC or via the corresponding per-address |
4948 | * family allocator. Otherwise, leave it alone. |
4949 | */ |
4950 | if (ifa->ifa_debug & IFD_ALLOC) { |
4951 | if (ifa->ifa_free == NULL) { |
4952 | IFA_UNLOCK(ifa); |
4953 | FREE(ifa, M_IFADDR); |
4954 | } else { |
4955 | /* Become a regular mutex */ |
4956 | IFA_CONVERT_LOCK(ifa); |
4957 | /* callee will unlock */ |
4958 | (*ifa->ifa_free)(ifa); |
4959 | } |
4960 | } else { |
4961 | IFA_UNLOCK(ifa); |
4962 | } |
4963 | ifa = NULL; |
4964 | } |
4965 | |
4966 | if (!locked && ifa != NULL) |
4967 | IFA_UNLOCK(ifa); |
4968 | |
4969 | return (ifa); |
4970 | } |
4971 | |
4972 | void |
4973 | ifa_addref(struct ifaddr *ifa, int locked) |
4974 | { |
4975 | if (!locked) |
4976 | IFA_LOCK_SPIN(ifa); |
4977 | else |
4978 | IFA_LOCK_ASSERT_HELD(ifa); |
4979 | |
4980 | if (++ifa->ifa_refcnt == 0) { |
4981 | panic("%s: ifa %p wraparound refcnt\n" , __func__, ifa); |
4982 | /* NOTREACHED */ |
4983 | } else if (ifa->ifa_trace != NULL) { |
4984 | (*ifa->ifa_trace)(ifa, TRUE); |
4985 | } |
4986 | if (!locked) |
4987 | IFA_UNLOCK(ifa); |
4988 | } |
4989 | |
4990 | void |
4991 | ifa_lock_init(struct ifaddr *ifa) |
4992 | { |
4993 | lck_mtx_init(&ifa->ifa_lock, ifa_mtx_grp, ifa_mtx_attr); |
4994 | } |
4995 | |
4996 | void |
4997 | ifa_lock_destroy(struct ifaddr *ifa) |
4998 | { |
4999 | IFA_LOCK_ASSERT_NOTHELD(ifa); |
5000 | lck_mtx_destroy(&ifa->ifa_lock, ifa_mtx_grp); |
5001 | } |
5002 | |
5003 | /* |
5004 | * 'i' group ioctls. |
5005 | * |
5006 | * The switch statement below does nothing at runtime, as it serves as a |
5007 | * compile time check to ensure that all of the socket 'i' ioctls (those |
5008 | * in the 'i' group going thru soo_ioctl) that are made available by the |
5009 | * networking stack is unique. This works as long as this routine gets |
5010 | * updated each time a new interface ioctl gets added. |
5011 | * |
5012 | * Any failures at compile time indicates duplicated ioctl values. |
5013 | */ |
5014 | static __attribute__((unused)) void |
5015 | ifioctl_cassert(void) |
5016 | { |
5017 | /* |
5018 | * This is equivalent to _CASSERT() and the compiler wouldn't |
5019 | * generate any instructions, thus for compile time only. |
5020 | */ |
5021 | switch ((u_long)0) { |
5022 | case 0: |
5023 | |
5024 | /* bsd/net/if_ppp.h */ |
5025 | case SIOCGPPPSTATS: |
5026 | case SIOCGPPPCSTATS: |
5027 | |
5028 | #if INET6 |
5029 | /* bsd/netinet6/in6_var.h */ |
5030 | case SIOCSIFADDR_IN6: |
5031 | case SIOCGIFADDR_IN6: |
5032 | case SIOCSIFDSTADDR_IN6: |
5033 | case SIOCSIFNETMASK_IN6: |
5034 | case SIOCGIFDSTADDR_IN6: |
5035 | case SIOCGIFNETMASK_IN6: |
5036 | case SIOCDIFADDR_IN6: |
5037 | case SIOCAIFADDR_IN6_32: |
5038 | case SIOCAIFADDR_IN6_64: |
5039 | case SIOCSIFPHYADDR_IN6_32: |
5040 | case SIOCSIFPHYADDR_IN6_64: |
5041 | case SIOCGIFPSRCADDR_IN6: |
5042 | case SIOCGIFPDSTADDR_IN6: |
5043 | case SIOCGIFAFLAG_IN6: |
5044 | case SIOCGDRLST_IN6_32: |
5045 | case SIOCGDRLST_IN6_64: |
5046 | case SIOCGPRLST_IN6_32: |
5047 | case SIOCGPRLST_IN6_64: |
5048 | case OSIOCGIFINFO_IN6: |
5049 | case SIOCGIFINFO_IN6: |
5050 | case SIOCSNDFLUSH_IN6: |
5051 | case SIOCGNBRINFO_IN6_32: |
5052 | case SIOCGNBRINFO_IN6_64: |
5053 | case SIOCSPFXFLUSH_IN6: |
5054 | case SIOCSRTRFLUSH_IN6: |
5055 | case SIOCGIFALIFETIME_IN6: |
5056 | case SIOCSIFALIFETIME_IN6: |
5057 | case SIOCGIFSTAT_IN6: |
5058 | case SIOCGIFSTAT_ICMP6: |
5059 | case SIOCSDEFIFACE_IN6_32: |
5060 | case SIOCSDEFIFACE_IN6_64: |
5061 | case SIOCGDEFIFACE_IN6_32: |
5062 | case SIOCGDEFIFACE_IN6_64: |
5063 | case SIOCSIFINFO_FLAGS: |
5064 | case SIOCSSCOPE6: |
5065 | case SIOCGSCOPE6: |
5066 | case SIOCGSCOPE6DEF: |
5067 | case SIOCSIFPREFIX_IN6: |
5068 | case SIOCGIFPREFIX_IN6: |
5069 | case SIOCDIFPREFIX_IN6: |
5070 | case SIOCAIFPREFIX_IN6: |
5071 | case SIOCCIFPREFIX_IN6: |
5072 | case SIOCSGIFPREFIX_IN6: |
5073 | case SIOCPROTOATTACH_IN6_32: |
5074 | case SIOCPROTOATTACH_IN6_64: |
5075 | case SIOCPROTODETACH_IN6: |
5076 | case SIOCLL_START_32: |
5077 | case SIOCLL_START_64: |
5078 | case SIOCLL_STOP: |
5079 | case SIOCAUTOCONF_START: |
5080 | case SIOCAUTOCONF_STOP: |
5081 | case SIOCSETROUTERMODE_IN6: |
5082 | case SIOCLL_CGASTART_32: |
5083 | case SIOCLL_CGASTART_64: |
5084 | case SIOCGIFCGAPREP_IN6: |
5085 | case SIOCSIFCGAPREP_IN6: |
5086 | #endif /* INET6 */ |
5087 | |
5088 | /* bsd/sys/sockio.h */ |
5089 | case SIOCSIFADDR: |
5090 | case OSIOCGIFADDR: |
5091 | case SIOCSIFDSTADDR: |
5092 | case OSIOCGIFDSTADDR: |
5093 | case SIOCSIFFLAGS: |
5094 | case SIOCGIFFLAGS: |
5095 | case OSIOCGIFBRDADDR: |
5096 | case SIOCSIFBRDADDR: |
5097 | case OSIOCGIFCONF32: |
5098 | case OSIOCGIFCONF64: |
5099 | case OSIOCGIFNETMASK: |
5100 | case SIOCSIFNETMASK: |
5101 | case SIOCGIFMETRIC: |
5102 | case SIOCSIFMETRIC: |
5103 | case SIOCDIFADDR: |
5104 | case SIOCAIFADDR: |
5105 | |
5106 | case SIOCGIFADDR: |
5107 | case SIOCGIFDSTADDR: |
5108 | case SIOCGIFBRDADDR: |
5109 | case SIOCGIFCONF32: |
5110 | case SIOCGIFCONF64: |
5111 | case SIOCGIFNETMASK: |
5112 | case SIOCAUTOADDR: |
5113 | case SIOCAUTONETMASK: |
5114 | case SIOCARPIPLL: |
5115 | |
5116 | case SIOCADDMULTI: |
5117 | case SIOCDELMULTI: |
5118 | case SIOCGIFMTU: |
5119 | case SIOCSIFMTU: |
5120 | case SIOCGIFPHYS: |
5121 | case SIOCSIFPHYS: |
5122 | case SIOCSIFMEDIA: |
5123 | case SIOCGIFMEDIA32: |
5124 | case SIOCGIFMEDIA64: |
5125 | case SIOCSIFGENERIC: |
5126 | case SIOCGIFGENERIC: |
5127 | case SIOCRSLVMULTI: |
5128 | |
5129 | case SIOCSIFLLADDR: |
5130 | case SIOCGIFSTATUS: |
5131 | case SIOCSIFPHYADDR: |
5132 | case SIOCGIFPSRCADDR: |
5133 | case SIOCGIFPDSTADDR: |
5134 | case SIOCDIFPHYADDR: |
5135 | |
5136 | case SIOCGIFDEVMTU: |
5137 | case SIOCSIFALTMTU: |
5138 | case SIOCGIFALTMTU: |
5139 | case SIOCSIFBOND: |
5140 | case SIOCGIFBOND: |
5141 | |
5142 | case SIOCPROTOATTACH: |
5143 | case SIOCPROTODETACH: |
5144 | |
5145 | case SIOCSIFCAP: |
5146 | case SIOCGIFCAP: |
5147 | |
5148 | case SIOCIFCREATE: |
5149 | case SIOCIFDESTROY: |
5150 | case SIOCIFCREATE2: |
5151 | |
5152 | case SIOCSDRVSPEC32: |
5153 | case SIOCGDRVSPEC32: |
5154 | case SIOCSDRVSPEC64: |
5155 | case SIOCGDRVSPEC64: |
5156 | |
5157 | case SIOCSIFVLAN: |
5158 | case SIOCGIFVLAN: |
5159 | |
5160 | case SIOCIFGCLONERS32: |
5161 | case SIOCIFGCLONERS64: |
5162 | |
5163 | case SIOCGIFASYNCMAP: |
5164 | case SIOCSIFASYNCMAP: |
5165 | #if CONFIG_MACF_NET |
5166 | case SIOCGIFMAC: |
5167 | case SIOCSIFMAC: |
5168 | #endif /* CONFIG_MACF_NET */ |
5169 | case SIOCSIFKPI: |
5170 | case SIOCGIFKPI: |
5171 | |
5172 | case SIOCGIFWAKEFLAGS: |
5173 | |
5174 | case SIOCGIFGETRTREFCNT: |
5175 | case SIOCGIFLINKQUALITYMETRIC: |
5176 | case SIOCSIFOPPORTUNISTIC: |
5177 | case SIOCGIFOPPORTUNISTIC: |
5178 | case SIOCSETROUTERMODE: |
5179 | case SIOCGIFEFLAGS: |
5180 | case SIOCSIFDESC: |
5181 | case SIOCGIFDESC: |
5182 | case SIOCSIFLINKPARAMS: |
5183 | case SIOCGIFLINKPARAMS: |
5184 | case SIOCGIFQUEUESTATS: |
5185 | case SIOCSIFTHROTTLE: |
5186 | case SIOCGIFTHROTTLE: |
5187 | |
5188 | case SIOCGASSOCIDS32: |
5189 | case SIOCGASSOCIDS64: |
5190 | case SIOCGCONNIDS32: |
5191 | case SIOCGCONNIDS64: |
5192 | case SIOCGCONNINFO32: |
5193 | case SIOCGCONNINFO64: |
5194 | case SIOCSCONNORDER: |
5195 | case SIOCGCONNORDER: |
5196 | |
5197 | case SIOCSIFLOG: |
5198 | case SIOCGIFLOG: |
5199 | case SIOCGIFDELEGATE: |
5200 | case SIOCGIFLLADDR: |
5201 | case SIOCGIFTYPE: |
5202 | case SIOCGIFEXPENSIVE: |
5203 | case SIOCSIFEXPENSIVE: |
5204 | case SIOCGIF2KCL: |
5205 | case SIOCSIF2KCL: |
5206 | case SIOCGSTARTDELAY: |
5207 | |
5208 | case SIOCAIFAGENTID: |
5209 | case SIOCDIFAGENTID: |
5210 | case SIOCGIFAGENTIDS32: |
5211 | case SIOCGIFAGENTIDS64: |
5212 | case SIOCGIFAGENTDATA32: |
5213 | case SIOCGIFAGENTDATA64: |
5214 | |
5215 | case SIOCSIFINTERFACESTATE: |
5216 | case SIOCGIFINTERFACESTATE: |
5217 | case SIOCSIFPROBECONNECTIVITY: |
5218 | case SIOCGIFPROBECONNECTIVITY: |
5219 | |
5220 | case SIOCGIFFUNCTIONALTYPE: |
5221 | case SIOCSIFNETSIGNATURE: |
5222 | case SIOCGIFNETSIGNATURE: |
5223 | |
5224 | case SIOCGECNMODE: |
5225 | case SIOCSECNMODE: |
5226 | |
5227 | case SIOCSIFORDER: |
5228 | |
5229 | case SIOCSQOSMARKINGMODE: |
5230 | case SIOCSQOSMARKINGENABLED: |
5231 | case SIOCGQOSMARKINGMODE: |
5232 | case SIOCGQOSMARKINGENABLED: |
5233 | |
5234 | case SIOCSIFTIMESTAMPENABLE: |
5235 | case SIOCSIFTIMESTAMPDISABLE: |
5236 | case SIOCGIFTIMESTAMPENABLED: |
5237 | |
5238 | case SIOCSIFDISABLEOUTPUT: |
5239 | |
5240 | case SIOCGIFAGENTLIST32: |
5241 | case SIOCGIFAGENTLIST64: |
5242 | |
5243 | case SIOCSIFLOWINTERNET: |
5244 | case SIOCGIFLOWINTERNET: |
5245 | |
5246 | #if INET6 |
5247 | case SIOCGIFNAT64PREFIX: |
5248 | case SIOCSIFNAT64PREFIX: |
5249 | |
5250 | case SIOCGIFCLAT46ADDR: |
5251 | #endif /* INET6 */ |
5252 | |
5253 | case SIOCGIFPROTOLIST32: |
5254 | case SIOCGIFPROTOLIST64: |
5255 | |
5256 | case SIOCGIFLOWPOWER: |
5257 | case SIOCSIFLOWPOWER: |
5258 | ; |
5259 | } |
5260 | } |
5261 | |
5262 | uint32_t |
5263 | ifnet_mbuf_packetpreamblelen(struct ifnet *ifp) |
5264 | { |
5265 | #pragma unused(ifp) |
5266 | return (0); |
5267 | } |
5268 | |
5269 | /* The following is used to enqueue work items for interface events */ |
5270 | struct intf_event { |
5271 | struct ifnet *ifp; |
5272 | union sockaddr_in_4_6 addr; |
5273 | uint32_t intf_event_code; |
5274 | }; |
5275 | |
5276 | static void |
5277 | intf_event_callback(void *arg) |
5278 | { |
5279 | struct intf_event *p_intf_ev = (struct intf_event *)arg; |
5280 | |
5281 | /* Call this before we walk the tree */ |
5282 | EVENTHANDLER_INVOKE(&ifnet_evhdlr_ctxt, ifnet_event, p_intf_ev->ifp, |
5283 | (struct sockaddr *)&(p_intf_ev->addr), p_intf_ev->intf_event_code); |
5284 | } |
5285 | |
5286 | struct intf_event_nwk_wq_entry { |
5287 | struct nwk_wq_entry nwk_wqe; |
5288 | struct intf_event intf_ev_arg; |
5289 | }; |
5290 | |
5291 | void |
5292 | intf_event_enqueue_nwk_wq_entry(struct ifnet *ifp, struct sockaddr *addrp, |
5293 | uint32_t intf_event_code) |
5294 | { |
5295 | #pragma unused(addrp) |
5296 | struct intf_event_nwk_wq_entry *p_intf_ev = NULL; |
5297 | |
5298 | MALLOC(p_intf_ev, struct intf_event_nwk_wq_entry *, |
5299 | sizeof(struct intf_event_nwk_wq_entry), |
5300 | M_NWKWQ, M_WAITOK | M_ZERO); |
5301 | |
5302 | p_intf_ev->intf_ev_arg.ifp = ifp; |
5303 | /* |
5304 | * XXX Not using addr in the arg. This will be used |
5305 | * once we need IP address add/delete events |
5306 | */ |
5307 | p_intf_ev->intf_ev_arg.intf_event_code = intf_event_code; |
5308 | p_intf_ev->nwk_wqe.func = intf_event_callback; |
5309 | p_intf_ev->nwk_wqe.is_arg_managed = TRUE; |
5310 | p_intf_ev->nwk_wqe.arg = &p_intf_ev->intf_ev_arg; |
5311 | nwk_wq_enqueue((struct nwk_wq_entry*)p_intf_ev); |
5312 | } |
5313 | |