]> git.saurik.com Git - apple/xnu.git/blob - bsd/net/kpi_interface.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-6153.81.5.tar.gz
[apple/xnu.git] / bsd / net / kpi_interface.c
1 /*
2 * Copyright (c) 2004-2019 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 #include "kpi_interface.h"
30
31 #include <sys/queue.h>
32 #include <sys/param.h> /* for definition of NULL */
33 #include <kern/debug.h> /* for panic */
34 #include <sys/errno.h>
35 #include <sys/socket.h>
36 #include <sys/kern_event.h>
37 #include <sys/kernel.h>
38 #include <sys/malloc.h>
39 #include <sys/kpi_mbuf.h>
40 #include <sys/mcache.h>
41 #include <sys/protosw.h>
42 #include <sys/syslog.h>
43 #include <net/if_var.h>
44 #include <net/if_dl.h>
45 #include <net/dlil.h>
46 #include <net/if_types.h>
47 #include <net/if_dl.h>
48 #include <net/if_arp.h>
49 #include <net/if_llreach.h>
50 #include <net/if_ether.h>
51 #include <net/net_api_stats.h>
52 #include <net/route.h>
53 #include <net/if_ports_used.h>
54 #include <libkern/libkern.h>
55 #include <libkern/OSAtomic.h>
56 #include <kern/locks.h>
57 #include <kern/clock.h>
58 #include <sys/sockio.h>
59 #include <sys/proc.h>
60 #include <sys/sysctl.h>
61 #include <sys/mbuf.h>
62 #include <netinet/ip_var.h>
63 #include <netinet/udp.h>
64 #include <netinet/udp_var.h>
65 #include <netinet/tcp.h>
66 #include <netinet/tcp_var.h>
67 #include <netinet/in_pcb.h>
68 #ifdef INET
69 #include <netinet/igmp_var.h>
70 #endif
71 #ifdef INET6
72 #include <netinet6/mld6_var.h>
73 #endif
74 #include <netkey/key.h>
75 #include <stdbool.h>
76
77 #include "net/net_str_id.h"
78
79 #if CONFIG_MACF
80 #include <sys/kauth.h>
81 #include <security/mac_framework.h>
82 #endif
83
84
85 #undef ifnet_allocate
86 errno_t ifnet_allocate(const struct ifnet_init_params *init,
87 ifnet_t *ifp);
88
89 static errno_t ifnet_allocate_common(const struct ifnet_init_params *init,
90 ifnet_t *ifp, bool is_internal);
91
92
93 #define TOUCHLASTCHANGE(__if_lastchange) { \
94 (__if_lastchange)->tv_sec = net_uptime(); \
95 (__if_lastchange)->tv_usec = 0; \
96 }
97
98 static errno_t ifnet_defrouter_llreachinfo(ifnet_t, int,
99 struct ifnet_llreach_info *);
100 static void ifnet_kpi_free(ifnet_t);
101 static errno_t ifnet_list_get_common(ifnet_family_t, boolean_t, ifnet_t **,
102 u_int32_t *);
103 static errno_t ifnet_set_lladdr_internal(ifnet_t, const void *, size_t,
104 u_char, int);
105 static errno_t ifnet_awdl_check_eflags(ifnet_t, u_int32_t *, u_int32_t *);
106
107 /*
108 * Temporary work around until we have real reference counting
109 *
110 * We keep the bits about calling dlil_if_release (which should be
111 * called recycle) transparent by calling it from our if_free function
112 * pointer. We have to keep the client's original detach function
113 * somewhere so we can call it.
114 */
115 static void
116 ifnet_kpi_free(ifnet_t ifp)
117 {
118 ifnet_detached_func detach_func = ifp->if_kpi_storage;
119
120 if (detach_func != NULL) {
121 detach_func(ifp);
122 }
123
124 if (ifp->if_broadcast.length > sizeof(ifp->if_broadcast.u.buffer)) {
125 FREE(ifp->if_broadcast.u.ptr, M_IFADDR);
126 ifp->if_broadcast.u.ptr = NULL;
127 }
128
129 dlil_if_release(ifp);
130 }
131
132 errno_t
133 ifnet_allocate_common(const struct ifnet_init_params *init,
134 ifnet_t *ifp, bool is_internal)
135 {
136 struct ifnet_init_eparams einit;
137
138 bzero(&einit, sizeof(einit));
139
140 einit.ver = IFNET_INIT_CURRENT_VERSION;
141 einit.len = sizeof(einit);
142 einit.flags = IFNET_INIT_LEGACY | IFNET_INIT_NX_NOAUTO;
143 if (!is_internal) {
144 einit.flags |= IFNET_INIT_ALLOC_KPI;
145 }
146 einit.uniqueid = init->uniqueid;
147 einit.uniqueid_len = init->uniqueid_len;
148 einit.name = init->name;
149 einit.unit = init->unit;
150 einit.family = init->family;
151 einit.type = init->type;
152 einit.output = init->output;
153 einit.demux = init->demux;
154 einit.add_proto = init->add_proto;
155 einit.del_proto = init->del_proto;
156 einit.check_multi = init->check_multi;
157 einit.framer = init->framer;
158 einit.softc = init->softc;
159 einit.ioctl = init->ioctl;
160 einit.set_bpf_tap = init->set_bpf_tap;
161 einit.detach = init->detach;
162 einit.event = init->event;
163 einit.broadcast_addr = init->broadcast_addr;
164 einit.broadcast_len = init->broadcast_len;
165
166 return ifnet_allocate_extended(&einit, ifp);
167 }
168
169 errno_t
170 ifnet_allocate_internal(const struct ifnet_init_params *init, ifnet_t *ifp)
171 {
172 return ifnet_allocate_common(init, ifp, true);
173 }
174
175 errno_t
176 ifnet_allocate(const struct ifnet_init_params *init, ifnet_t *ifp)
177 {
178 return ifnet_allocate_common(init, ifp, false);
179 }
180
181 errno_t
182 ifnet_allocate_extended(const struct ifnet_init_eparams *einit0,
183 ifnet_t *interface)
184 {
185 struct ifnet_init_eparams einit;
186 struct ifnet *ifp = NULL;
187 char if_xname[IFXNAMSIZ] = {0};
188 int error;
189
190 einit = *einit0;
191
192 if (einit.ver != IFNET_INIT_CURRENT_VERSION ||
193 einit.len < sizeof(einit)) {
194 return EINVAL;
195 }
196
197 if (einit.family == 0 || einit.name == NULL ||
198 strlen(einit.name) >= IFNAMSIZ ||
199 (einit.type & 0xFFFFFF00) != 0 || einit.type == 0) {
200 return EINVAL;
201 }
202
203
204 if (einit.flags & IFNET_INIT_LEGACY) {
205 if (einit.output == NULL ||
206 (einit.flags & IFNET_INIT_INPUT_POLL)) {
207 return EINVAL;
208 }
209 einit.pre_enqueue = NULL;
210 einit.start = NULL;
211 einit.output_ctl = NULL;
212 einit.output_sched_model = IFNET_SCHED_MODEL_NORMAL;
213 einit.input_poll = NULL;
214 einit.input_ctl = NULL;
215 } else {
216 if (einit.start == NULL) {
217 return EINVAL;
218 }
219
220 einit.output = NULL;
221 if (einit.output_sched_model >= IFNET_SCHED_MODEL_MAX) {
222 return EINVAL;
223 }
224
225 if (einit.flags & IFNET_INIT_INPUT_POLL) {
226 if (einit.input_poll == NULL || einit.input_ctl == NULL) {
227 return EINVAL;
228 }
229 } else {
230 einit.input_poll = NULL;
231 einit.input_ctl = NULL;
232 }
233 }
234
235 /* Initialize external name (name + unit) */
236 (void) snprintf(if_xname, sizeof(if_xname), "%s%d",
237 einit.name, einit.unit);
238
239 if (einit.uniqueid == NULL) {
240 einit.uniqueid = if_xname;
241 einit.uniqueid_len = strlen(if_xname);
242 }
243
244 error = dlil_if_acquire(einit.family, einit.uniqueid,
245 einit.uniqueid_len, if_xname, &ifp);
246
247 if (error == 0) {
248 u_int64_t br;
249
250 /*
251 * Cast ifp->if_name as non const. dlil_if_acquire sets it up
252 * to point to storage of at least IFNAMSIZ bytes. It is safe
253 * to write to this.
254 */
255 strlcpy(__DECONST(char *, ifp->if_name), einit.name, IFNAMSIZ);
256 ifp->if_type = einit.type;
257 ifp->if_family = einit.family;
258 ifp->if_subfamily = einit.subfamily;
259 ifp->if_unit = einit.unit;
260 ifp->if_output = einit.output;
261 ifp->if_pre_enqueue = einit.pre_enqueue;
262 ifp->if_start = einit.start;
263 ifp->if_output_ctl = einit.output_ctl;
264 ifp->if_output_sched_model = einit.output_sched_model;
265 ifp->if_output_bw.eff_bw = einit.output_bw;
266 ifp->if_output_bw.max_bw = einit.output_bw_max;
267 ifp->if_output_lt.eff_lt = einit.output_lt;
268 ifp->if_output_lt.max_lt = einit.output_lt_max;
269 ifp->if_input_poll = einit.input_poll;
270 ifp->if_input_ctl = einit.input_ctl;
271 ifp->if_input_bw.eff_bw = einit.input_bw;
272 ifp->if_input_bw.max_bw = einit.input_bw_max;
273 ifp->if_input_lt.eff_lt = einit.input_lt;
274 ifp->if_input_lt.max_lt = einit.input_lt_max;
275 ifp->if_demux = einit.demux;
276 ifp->if_add_proto = einit.add_proto;
277 ifp->if_del_proto = einit.del_proto;
278 ifp->if_check_multi = einit.check_multi;
279 ifp->if_framer_legacy = einit.framer;
280 ifp->if_framer = einit.framer_extended;
281 ifp->if_softc = einit.softc;
282 ifp->if_ioctl = einit.ioctl;
283 ifp->if_set_bpf_tap = einit.set_bpf_tap;
284 ifp->if_free = ifnet_kpi_free;
285 ifp->if_event = einit.event;
286 ifp->if_kpi_storage = einit.detach;
287
288 /* Initialize external name (name + unit) */
289 snprintf(__DECONST(char *, ifp->if_xname), IFXNAMSIZ,
290 "%s", if_xname);
291
292 /*
293 * On embedded, framer() is already in the extended form;
294 * we simply use it as is, unless the caller specifies
295 * framer_extended() which will then override it.
296 *
297 * On non-embedded, framer() has long been exposed as part
298 * of the public KPI, and therefore its signature must
299 * remain the same (without the pre- and postpend length
300 * parameters.) We special case ether_frameout, such that
301 * it gets mapped to its extended variant. All other cases
302 * utilize the stub routine which will simply return zeroes
303 * for those new parameters.
304 *
305 * Internally, DLIL will only use the extended callback
306 * variant which is represented by if_framer.
307 */
308 #if CONFIG_EMBEDDED
309 if (ifp->if_framer == NULL && ifp->if_framer_legacy != NULL) {
310 ifp->if_framer = ifp->if_framer_legacy;
311 }
312 #else /* !CONFIG_EMBEDDED */
313 if (ifp->if_framer == NULL && ifp->if_framer_legacy != NULL) {
314 if (ifp->if_framer_legacy == ether_frameout) {
315 ifp->if_framer = ether_frameout_extended;
316 } else {
317 ifp->if_framer = ifnet_framer_stub;
318 }
319 }
320 #endif /* !CONFIG_EMBEDDED */
321
322 if (ifp->if_output_bw.eff_bw > ifp->if_output_bw.max_bw) {
323 ifp->if_output_bw.max_bw = ifp->if_output_bw.eff_bw;
324 } else if (ifp->if_output_bw.eff_bw == 0) {
325 ifp->if_output_bw.eff_bw = ifp->if_output_bw.max_bw;
326 }
327
328 if (ifp->if_input_bw.eff_bw > ifp->if_input_bw.max_bw) {
329 ifp->if_input_bw.max_bw = ifp->if_input_bw.eff_bw;
330 } else if (ifp->if_input_bw.eff_bw == 0) {
331 ifp->if_input_bw.eff_bw = ifp->if_input_bw.max_bw;
332 }
333
334 if (ifp->if_output_bw.max_bw == 0) {
335 ifp->if_output_bw = ifp->if_input_bw;
336 } else if (ifp->if_input_bw.max_bw == 0) {
337 ifp->if_input_bw = ifp->if_output_bw;
338 }
339
340 /* Pin if_baudrate to 32 bits */
341 br = MAX(ifp->if_output_bw.max_bw, ifp->if_input_bw.max_bw);
342 if (br != 0) {
343 ifp->if_baudrate = (br > 0xFFFFFFFF) ? 0xFFFFFFFF : br;
344 }
345
346 if (ifp->if_output_lt.eff_lt > ifp->if_output_lt.max_lt) {
347 ifp->if_output_lt.max_lt = ifp->if_output_lt.eff_lt;
348 } else if (ifp->if_output_lt.eff_lt == 0) {
349 ifp->if_output_lt.eff_lt = ifp->if_output_lt.max_lt;
350 }
351
352 if (ifp->if_input_lt.eff_lt > ifp->if_input_lt.max_lt) {
353 ifp->if_input_lt.max_lt = ifp->if_input_lt.eff_lt;
354 } else if (ifp->if_input_lt.eff_lt == 0) {
355 ifp->if_input_lt.eff_lt = ifp->if_input_lt.max_lt;
356 }
357
358 if (ifp->if_output_lt.max_lt == 0) {
359 ifp->if_output_lt = ifp->if_input_lt;
360 } else if (ifp->if_input_lt.max_lt == 0) {
361 ifp->if_input_lt = ifp->if_output_lt;
362 }
363
364 if (ifp->if_ioctl == NULL) {
365 ifp->if_ioctl = ifp_if_ioctl;
366 }
367
368 ifp->if_eflags = 0;
369 if (ifp->if_start != NULL) {
370 ifp->if_eflags |= IFEF_TXSTART;
371 if (ifp->if_pre_enqueue == NULL) {
372 ifp->if_pre_enqueue = ifnet_enqueue;
373 }
374 ifp->if_output = ifp->if_pre_enqueue;
375 } else {
376 ifp->if_eflags &= ~IFEF_TXSTART;
377 }
378
379 if (ifp->if_input_poll != NULL) {
380 ifp->if_eflags |= IFEF_RXPOLL;
381 } else {
382 ifp->if_eflags &= ~IFEF_RXPOLL;
383 }
384
385 ifp->if_output_dlil = dlil_output_handler;
386 ifp->if_input_dlil = dlil_input_handler;
387
388 VERIFY(!(einit.flags & IFNET_INIT_LEGACY) ||
389 (ifp->if_pre_enqueue == NULL && ifp->if_start == NULL &&
390 ifp->if_output_ctl == NULL && ifp->if_input_poll == NULL &&
391 ifp->if_input_ctl == NULL));
392 VERIFY(!(einit.flags & IFNET_INIT_INPUT_POLL) ||
393 (ifp->if_input_poll != NULL && ifp->if_input_ctl != NULL));
394
395 if (einit.broadcast_len && einit.broadcast_addr) {
396 if (einit.broadcast_len >
397 sizeof(ifp->if_broadcast.u.buffer)) {
398 MALLOC(ifp->if_broadcast.u.ptr, u_char *,
399 einit.broadcast_len, M_IFADDR, M_NOWAIT);
400 if (ifp->if_broadcast.u.ptr == NULL) {
401 error = ENOMEM;
402 } else {
403 bcopy(einit.broadcast_addr,
404 ifp->if_broadcast.u.ptr,
405 einit.broadcast_len);
406 }
407 } else {
408 bcopy(einit.broadcast_addr,
409 ifp->if_broadcast.u.buffer,
410 einit.broadcast_len);
411 }
412 ifp->if_broadcast.length = einit.broadcast_len;
413 } else {
414 bzero(&ifp->if_broadcast, sizeof(ifp->if_broadcast));
415 }
416
417 ifp->if_xflags = 0;
418 /* legacy interface */
419 ifp->if_xflags |= IFXF_LEGACY;
420
421 /*
422 * output target queue delay is specified in millisecond
423 * convert it to nanoseconds
424 */
425 IFCQ_TARGET_QDELAY(&ifp->if_snd) =
426 einit.output_target_qdelay * 1000 * 1000;
427 IFCQ_MAXLEN(&ifp->if_snd) = einit.sndq_maxlen;
428
429 ifnet_enqueue_multi_setup(ifp, einit.start_delay_qlen,
430 einit.start_delay_timeout);
431
432 IFCQ_PKT_DROP_LIMIT(&ifp->if_snd) = IFCQ_DEFAULT_PKT_DROP_LIMIT;
433
434 /*
435 * Set embryonic flag; this will be cleared
436 * later when it is fully attached.
437 */
438 ifp->if_refflags = IFRF_EMBRYONIC;
439
440 /*
441 * Count the newly allocated ifnet
442 */
443 OSIncrementAtomic64(&net_api_stats.nas_ifnet_alloc_count);
444 INC_ATOMIC_INT64_LIM(net_api_stats.nas_ifnet_alloc_total);
445 if (einit.flags & IFNET_INIT_ALLOC_KPI) {
446 ifp->if_xflags |= IFXF_ALLOC_KPI;
447 } else {
448 OSIncrementAtomic64(
449 &net_api_stats.nas_ifnet_alloc_os_count);
450 INC_ATOMIC_INT64_LIM(
451 net_api_stats.nas_ifnet_alloc_os_total);
452 }
453
454 if (error == 0) {
455 *interface = ifp;
456 // temporary - this should be done in dlil_if_acquire
457 ifnet_reference(ifp);
458 } else {
459 dlil_if_release(ifp);
460 *interface = NULL;
461 }
462 }
463 return error;
464 }
465
466 errno_t
467 ifnet_reference(ifnet_t ifp)
468 {
469 return dlil_if_ref(ifp);
470 }
471
472 errno_t
473 ifnet_release(ifnet_t ifp)
474 {
475 return dlil_if_free(ifp);
476 }
477
478 errno_t
479 ifnet_interface_family_find(const char *module_string,
480 ifnet_family_t *family_id)
481 {
482 if (module_string == NULL || family_id == NULL) {
483 return EINVAL;
484 }
485
486 return net_str_id_find_internal(module_string, family_id,
487 NSI_IF_FAM_ID, 1);
488 }
489
490 void *
491 ifnet_softc(ifnet_t interface)
492 {
493 return (interface == NULL) ? NULL : interface->if_softc;
494 }
495
496 const char *
497 ifnet_name(ifnet_t interface)
498 {
499 return (interface == NULL) ? NULL : interface->if_name;
500 }
501
502 ifnet_family_t
503 ifnet_family(ifnet_t interface)
504 {
505 return (interface == NULL) ? 0 : interface->if_family;
506 }
507
508 ifnet_subfamily_t
509 ifnet_subfamily(ifnet_t interface)
510 {
511 return (interface == NULL) ? 0 : interface->if_subfamily;
512 }
513
514 u_int32_t
515 ifnet_unit(ifnet_t interface)
516 {
517 return (interface == NULL) ? (u_int32_t)0xffffffff :
518 (u_int32_t)interface->if_unit;
519 }
520
521 u_int32_t
522 ifnet_index(ifnet_t interface)
523 {
524 return (interface == NULL) ? (u_int32_t)0xffffffff :
525 interface->if_index;
526 }
527
528 errno_t
529 ifnet_set_flags(ifnet_t interface, u_int16_t new_flags, u_int16_t mask)
530 {
531 uint16_t old_flags;
532
533 if (interface == NULL) {
534 return EINVAL;
535 }
536
537 ifnet_lock_exclusive(interface);
538
539 /* If we are modifying the up/down state, call if_updown */
540 if ((mask & IFF_UP) != 0) {
541 if_updown(interface, (new_flags & IFF_UP) == IFF_UP);
542 }
543
544 old_flags = interface->if_flags;
545 interface->if_flags = (new_flags & mask) | (interface->if_flags & ~mask);
546 /* If we are modifying the multicast flag, set/unset the silent flag */
547 if ((old_flags & IFF_MULTICAST) !=
548 (interface->if_flags & IFF_MULTICAST)) {
549 #if INET
550 if (IGMP_IFINFO(interface) != NULL) {
551 igmp_initsilent(interface, IGMP_IFINFO(interface));
552 }
553 #endif /* INET */
554 #if INET6
555 if (MLD_IFINFO(interface) != NULL) {
556 mld6_initsilent(interface, MLD_IFINFO(interface));
557 }
558 #endif /* INET6 */
559 }
560
561 ifnet_lock_done(interface);
562
563 return 0;
564 }
565
566 u_int16_t
567 ifnet_flags(ifnet_t interface)
568 {
569 return (interface == NULL) ? 0 : interface->if_flags;
570 }
571
572 /*
573 * This routine ensures the following:
574 *
575 * If IFEF_AWDL is set by the caller, also set the rest of flags as
576 * defined in IFEF_AWDL_MASK.
577 *
578 * If IFEF_AWDL has been set on the interface and the caller attempts
579 * to clear one or more of the associated flags in IFEF_AWDL_MASK,
580 * return failure.
581 *
582 * If IFEF_AWDL_RESTRICTED is set by the caller, make sure IFEF_AWDL is set
583 * on the interface.
584 *
585 * All other flags not associated with AWDL are not affected.
586 *
587 * See <net/if.h> for current definition of IFEF_AWDL_MASK.
588 */
589 static errno_t
590 ifnet_awdl_check_eflags(ifnet_t ifp, u_int32_t *new_eflags, u_int32_t *mask)
591 {
592 u_int32_t eflags;
593
594 ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_EXCLUSIVE);
595
596 eflags = (*new_eflags & *mask) | (ifp->if_eflags & ~(*mask));
597
598 if (ifp->if_eflags & IFEF_AWDL) {
599 if (eflags & IFEF_AWDL) {
600 if ((eflags & IFEF_AWDL_MASK) != IFEF_AWDL_MASK) {
601 return EINVAL;
602 }
603 } else {
604 *new_eflags &= ~IFEF_AWDL_MASK;
605 *mask |= IFEF_AWDL_MASK;
606 }
607 } else if (eflags & IFEF_AWDL) {
608 *new_eflags |= IFEF_AWDL_MASK;
609 *mask |= IFEF_AWDL_MASK;
610 } else if (eflags & IFEF_AWDL_RESTRICTED &&
611 !(ifp->if_eflags & IFEF_AWDL)) {
612 return EINVAL;
613 }
614
615 return 0;
616 }
617
618 errno_t
619 ifnet_set_eflags(ifnet_t interface, u_int32_t new_flags, u_int32_t mask)
620 {
621 uint32_t oeflags;
622 struct kev_msg ev_msg;
623 struct net_event_data ev_data;
624
625 if (interface == NULL) {
626 return EINVAL;
627 }
628
629 bzero(&ev_msg, sizeof(ev_msg));
630 ifnet_lock_exclusive(interface);
631 /*
632 * Sanity checks for IFEF_AWDL and its related flags.
633 */
634 if (ifnet_awdl_check_eflags(interface, &new_flags, &mask) != 0) {
635 ifnet_lock_done(interface);
636 return EINVAL;
637 }
638 /*
639 * Currently Interface advisory reporting is supported only for
640 * skywalk interface.
641 */
642 if ((((new_flags & mask) & IFEF_ADV_REPORT) != 0) &&
643 ((interface->if_eflags & IFEF_SKYWALK_NATIVE) == 0)) {
644 return EINVAL;
645 }
646 oeflags = interface->if_eflags;
647 interface->if_eflags =
648 (new_flags & mask) | (interface->if_eflags & ~mask);
649 ifnet_lock_done(interface);
650 if (interface->if_eflags & IFEF_AWDL_RESTRICTED &&
651 !(oeflags & IFEF_AWDL_RESTRICTED)) {
652 ev_msg.event_code = KEV_DL_AWDL_RESTRICTED;
653 /*
654 * The interface is now restricted to applications that have
655 * the entitlement.
656 * The check for the entitlement will be done in the data
657 * path, so we don't have to do anything here.
658 */
659 } else if (oeflags & IFEF_AWDL_RESTRICTED &&
660 !(interface->if_eflags & IFEF_AWDL_RESTRICTED)) {
661 ev_msg.event_code = KEV_DL_AWDL_UNRESTRICTED;
662 }
663 /*
664 * Notify configd so that it has a chance to perform better
665 * reachability detection.
666 */
667 if (ev_msg.event_code) {
668 bzero(&ev_data, sizeof(ev_data));
669 ev_msg.vendor_code = KEV_VENDOR_APPLE;
670 ev_msg.kev_class = KEV_NETWORK_CLASS;
671 ev_msg.kev_subclass = KEV_DL_SUBCLASS;
672 strlcpy(ev_data.if_name, interface->if_name, IFNAMSIZ);
673 ev_data.if_family = interface->if_family;
674 ev_data.if_unit = interface->if_unit;
675 ev_msg.dv[0].data_length = sizeof(struct net_event_data);
676 ev_msg.dv[0].data_ptr = &ev_data;
677 ev_msg.dv[1].data_length = 0;
678 dlil_post_complete_msg(interface, &ev_msg);
679 }
680
681 return 0;
682 }
683
684 u_int32_t
685 ifnet_eflags(ifnet_t interface)
686 {
687 return (interface == NULL) ? 0 : interface->if_eflags;
688 }
689
690 errno_t
691 ifnet_set_idle_flags_locked(ifnet_t ifp, u_int32_t new_flags, u_int32_t mask)
692 {
693 int before, after;
694
695 if (ifp == NULL) {
696 return EINVAL;
697 }
698
699 LCK_MTX_ASSERT(rnh_lock, LCK_MTX_ASSERT_OWNED);
700 ifnet_lock_assert(ifp, IFNET_LCK_ASSERT_EXCLUSIVE);
701
702 /*
703 * If this is called prior to ifnet attach, the actual work will
704 * be done at attach time. Otherwise, if it is called after
705 * ifnet detach, then it is a no-op.
706 */
707 if (!ifnet_is_attached(ifp, 0)) {
708 ifp->if_idle_new_flags = new_flags;
709 ifp->if_idle_new_flags_mask = mask;
710 return 0;
711 } else {
712 ifp->if_idle_new_flags = ifp->if_idle_new_flags_mask = 0;
713 }
714
715 before = ifp->if_idle_flags;
716 ifp->if_idle_flags = (new_flags & mask) | (ifp->if_idle_flags & ~mask);
717 after = ifp->if_idle_flags;
718
719 if ((after - before) < 0 && ifp->if_idle_flags == 0 &&
720 ifp->if_want_aggressive_drain != 0) {
721 ifp->if_want_aggressive_drain = 0;
722 } else if ((after - before) > 0 && ifp->if_want_aggressive_drain == 0) {
723 ifp->if_want_aggressive_drain++;
724 }
725
726 return 0;
727 }
728
729 errno_t
730 ifnet_set_idle_flags(ifnet_t ifp, u_int32_t new_flags, u_int32_t mask)
731 {
732 errno_t err;
733
734 lck_mtx_lock(rnh_lock);
735 ifnet_lock_exclusive(ifp);
736 err = ifnet_set_idle_flags_locked(ifp, new_flags, mask);
737 ifnet_lock_done(ifp);
738 lck_mtx_unlock(rnh_lock);
739
740 return err;
741 }
742
743 u_int32_t
744 ifnet_idle_flags(ifnet_t ifp)
745 {
746 return (ifp == NULL) ? 0 : ifp->if_idle_flags;
747 }
748
749 errno_t
750 ifnet_set_link_quality(ifnet_t ifp, int quality)
751 {
752 errno_t err = 0;
753
754 if (ifp == NULL || quality < IFNET_LQM_MIN || quality > IFNET_LQM_MAX) {
755 err = EINVAL;
756 goto done;
757 }
758
759 if (!ifnet_is_attached(ifp, 0)) {
760 err = ENXIO;
761 goto done;
762 }
763
764 if_lqm_update(ifp, quality, 0);
765
766 done:
767 return err;
768 }
769
770 int
771 ifnet_link_quality(ifnet_t ifp)
772 {
773 int lqm;
774
775 if (ifp == NULL) {
776 return IFNET_LQM_THRESH_OFF;
777 }
778
779 ifnet_lock_shared(ifp);
780 lqm = ifp->if_interface_state.lqm_state;
781 ifnet_lock_done(ifp);
782
783 return lqm;
784 }
785
786 errno_t
787 ifnet_set_interface_state(ifnet_t ifp,
788 struct if_interface_state *if_interface_state)
789 {
790 errno_t err = 0;
791
792 if (ifp == NULL || if_interface_state == NULL) {
793 err = EINVAL;
794 goto done;
795 }
796
797 if (!ifnet_is_attached(ifp, 0)) {
798 err = ENXIO;
799 goto done;
800 }
801
802 if_state_update(ifp, if_interface_state);
803
804 done:
805 return err;
806 }
807
808 errno_t
809 ifnet_get_interface_state(ifnet_t ifp,
810 struct if_interface_state *if_interface_state)
811 {
812 errno_t err = 0;
813
814 if (ifp == NULL || if_interface_state == NULL) {
815 err = EINVAL;
816 goto done;
817 }
818
819 if (!ifnet_is_attached(ifp, 0)) {
820 err = ENXIO;
821 goto done;
822 }
823
824 if_get_state(ifp, if_interface_state);
825
826 done:
827 return err;
828 }
829
830
831 static errno_t
832 ifnet_defrouter_llreachinfo(ifnet_t ifp, int af,
833 struct ifnet_llreach_info *iflri)
834 {
835 if (ifp == NULL || iflri == NULL) {
836 return EINVAL;
837 }
838
839 VERIFY(af == AF_INET || af == AF_INET6);
840
841 return ifnet_llreach_get_defrouter(ifp, af, iflri);
842 }
843
844 errno_t
845 ifnet_inet_defrouter_llreachinfo(ifnet_t ifp, struct ifnet_llreach_info *iflri)
846 {
847 return ifnet_defrouter_llreachinfo(ifp, AF_INET, iflri);
848 }
849
850 errno_t
851 ifnet_inet6_defrouter_llreachinfo(ifnet_t ifp, struct ifnet_llreach_info *iflri)
852 {
853 return ifnet_defrouter_llreachinfo(ifp, AF_INET6, iflri);
854 }
855
856 errno_t
857 ifnet_set_capabilities_supported(ifnet_t ifp, u_int32_t new_caps,
858 u_int32_t mask)
859 {
860 errno_t error = 0;
861 int tmp;
862
863 if (ifp == NULL) {
864 return EINVAL;
865 }
866
867 ifnet_lock_exclusive(ifp);
868 tmp = (new_caps & mask) | (ifp->if_capabilities & ~mask);
869 if ((tmp & ~IFCAP_VALID)) {
870 error = EINVAL;
871 } else {
872 ifp->if_capabilities = tmp;
873 }
874 ifnet_lock_done(ifp);
875
876 return error;
877 }
878
879 u_int32_t
880 ifnet_capabilities_supported(ifnet_t ifp)
881 {
882 return (ifp == NULL) ? 0 : ifp->if_capabilities;
883 }
884
885
886 errno_t
887 ifnet_set_capabilities_enabled(ifnet_t ifp, u_int32_t new_caps,
888 u_int32_t mask)
889 {
890 errno_t error = 0;
891 int tmp;
892 struct kev_msg ev_msg;
893 struct net_event_data ev_data;
894
895 if (ifp == NULL) {
896 return EINVAL;
897 }
898
899 ifnet_lock_exclusive(ifp);
900 tmp = (new_caps & mask) | (ifp->if_capenable & ~mask);
901 if ((tmp & ~IFCAP_VALID) || (tmp & ~ifp->if_capabilities)) {
902 error = EINVAL;
903 } else {
904 ifp->if_capenable = tmp;
905 }
906 ifnet_lock_done(ifp);
907
908 /* Notify application of the change */
909 bzero(&ev_data, sizeof(struct net_event_data));
910 bzero(&ev_msg, sizeof(struct kev_msg));
911 ev_msg.vendor_code = KEV_VENDOR_APPLE;
912 ev_msg.kev_class = KEV_NETWORK_CLASS;
913 ev_msg.kev_subclass = KEV_DL_SUBCLASS;
914
915 ev_msg.event_code = KEV_DL_IFCAP_CHANGED;
916 strlcpy(&ev_data.if_name[0], ifp->if_name, IFNAMSIZ);
917 ev_data.if_family = ifp->if_family;
918 ev_data.if_unit = (u_int32_t)ifp->if_unit;
919 ev_msg.dv[0].data_length = sizeof(struct net_event_data);
920 ev_msg.dv[0].data_ptr = &ev_data;
921 ev_msg.dv[1].data_length = 0;
922 dlil_post_complete_msg(ifp, &ev_msg);
923
924 return error;
925 }
926
927 u_int32_t
928 ifnet_capabilities_enabled(ifnet_t ifp)
929 {
930 return (ifp == NULL) ? 0 : ifp->if_capenable;
931 }
932
933 static const ifnet_offload_t offload_mask =
934 (IFNET_CSUM_IP | IFNET_CSUM_TCP | IFNET_CSUM_UDP | IFNET_CSUM_FRAGMENT |
935 IFNET_IP_FRAGMENT | IFNET_CSUM_TCPIPV6 | IFNET_CSUM_UDPIPV6 |
936 IFNET_IPV6_FRAGMENT | IFNET_CSUM_PARTIAL | IFNET_CSUM_ZERO_INVERT |
937 IFNET_VLAN_TAGGING | IFNET_VLAN_MTU | IFNET_MULTIPAGES |
938 IFNET_TSO_IPV4 | IFNET_TSO_IPV6 | IFNET_TX_STATUS | IFNET_HW_TIMESTAMP |
939 IFNET_SW_TIMESTAMP);
940
941 static const ifnet_offload_t any_offload_csum = IFNET_CHECKSUMF;
942
943 errno_t
944 ifnet_set_offload(ifnet_t interface, ifnet_offload_t offload)
945 {
946 u_int32_t ifcaps = 0;
947
948 if (interface == NULL) {
949 return EINVAL;
950 }
951
952 ifnet_lock_exclusive(interface);
953 interface->if_hwassist = (offload & offload_mask);
954
955 /*
956 * Hardware capable of partial checksum offload is
957 * flexible enough to handle any transports utilizing
958 * Internet Checksumming. Include those transports
959 * here, and leave the final decision to IP.
960 */
961 if (interface->if_hwassist & IFNET_CSUM_PARTIAL) {
962 interface->if_hwassist |= (IFNET_CSUM_TCP | IFNET_CSUM_UDP |
963 IFNET_CSUM_TCPIPV6 | IFNET_CSUM_UDPIPV6);
964 }
965 if (dlil_verbose) {
966 log(LOG_DEBUG, "%s: set offload flags=%b\n",
967 if_name(interface),
968 interface->if_hwassist, IFNET_OFFLOADF_BITS);
969 }
970 ifnet_lock_done(interface);
971
972 if ((offload & any_offload_csum)) {
973 ifcaps |= IFCAP_HWCSUM;
974 }
975 if ((offload & IFNET_TSO_IPV4)) {
976 ifcaps |= IFCAP_TSO4;
977 }
978 if ((offload & IFNET_TSO_IPV6)) {
979 ifcaps |= IFCAP_TSO6;
980 }
981 if ((offload & IFNET_VLAN_MTU)) {
982 ifcaps |= IFCAP_VLAN_MTU;
983 }
984 if ((offload & IFNET_VLAN_TAGGING)) {
985 ifcaps |= IFCAP_VLAN_HWTAGGING;
986 }
987 if ((offload & IFNET_TX_STATUS)) {
988 ifcaps |= IFCAP_TXSTATUS;
989 }
990 if ((offload & IFNET_HW_TIMESTAMP)) {
991 ifcaps |= IFCAP_HW_TIMESTAMP;
992 }
993 if ((offload & IFNET_SW_TIMESTAMP)) {
994 ifcaps |= IFCAP_SW_TIMESTAMP;
995 }
996 if ((offload & IFNET_CSUM_PARTIAL)) {
997 ifcaps |= IFCAP_CSUM_PARTIAL;
998 }
999 if ((offload & IFNET_CSUM_ZERO_INVERT)) {
1000 ifcaps |= IFCAP_CSUM_ZERO_INVERT;
1001 }
1002 if (ifcaps != 0) {
1003 (void) ifnet_set_capabilities_supported(interface, ifcaps,
1004 IFCAP_VALID);
1005 (void) ifnet_set_capabilities_enabled(interface, ifcaps,
1006 IFCAP_VALID);
1007 }
1008
1009 return 0;
1010 }
1011
1012 ifnet_offload_t
1013 ifnet_offload(ifnet_t interface)
1014 {
1015 return (interface == NULL) ?
1016 0 : (interface->if_hwassist & offload_mask);
1017 }
1018
1019 errno_t
1020 ifnet_set_tso_mtu(ifnet_t interface, sa_family_t family, u_int32_t mtuLen)
1021 {
1022 errno_t error = 0;
1023
1024 if (interface == NULL || mtuLen < interface->if_mtu) {
1025 return EINVAL;
1026 }
1027
1028 switch (family) {
1029 case AF_INET:
1030 if (interface->if_hwassist & IFNET_TSO_IPV4) {
1031 interface->if_tso_v4_mtu = mtuLen;
1032 } else {
1033 error = EINVAL;
1034 }
1035 break;
1036
1037 case AF_INET6:
1038 if (interface->if_hwassist & IFNET_TSO_IPV6) {
1039 interface->if_tso_v6_mtu = mtuLen;
1040 } else {
1041 error = EINVAL;
1042 }
1043 break;
1044
1045 default:
1046 error = EPROTONOSUPPORT;
1047 break;
1048 }
1049
1050 return error;
1051 }
1052
1053 errno_t
1054 ifnet_get_tso_mtu(ifnet_t interface, sa_family_t family, u_int32_t *mtuLen)
1055 {
1056 errno_t error = 0;
1057
1058 if (interface == NULL || mtuLen == NULL) {
1059 return EINVAL;
1060 }
1061
1062 switch (family) {
1063 case AF_INET:
1064 if (interface->if_hwassist & IFNET_TSO_IPV4) {
1065 *mtuLen = interface->if_tso_v4_mtu;
1066 } else {
1067 error = EINVAL;
1068 }
1069 break;
1070
1071 case AF_INET6:
1072 if (interface->if_hwassist & IFNET_TSO_IPV6) {
1073 *mtuLen = interface->if_tso_v6_mtu;
1074 } else {
1075 error = EINVAL;
1076 }
1077 break;
1078
1079 default:
1080 error = EPROTONOSUPPORT;
1081 break;
1082 }
1083
1084 return error;
1085 }
1086
1087 errno_t
1088 ifnet_set_wake_flags(ifnet_t interface, u_int32_t properties, u_int32_t mask)
1089 {
1090 struct kev_msg ev_msg;
1091 struct net_event_data ev_data;
1092
1093 bzero(&ev_data, sizeof(struct net_event_data));
1094 bzero(&ev_msg, sizeof(struct kev_msg));
1095
1096 if (interface == NULL) {
1097 return EINVAL;
1098 }
1099
1100 /* Do not accept wacky values */
1101 if ((properties & mask) & ~IF_WAKE_VALID_FLAGS) {
1102 return EINVAL;
1103 }
1104
1105 ifnet_lock_exclusive(interface);
1106
1107 if (mask & IF_WAKE_ON_MAGIC_PACKET) {
1108 if (properties & IF_WAKE_ON_MAGIC_PACKET) {
1109 interface->if_xflags |= IFXF_WAKE_ON_MAGIC_PACKET;
1110 } else {
1111 interface->if_xflags &= ~IFXF_WAKE_ON_MAGIC_PACKET;
1112 }
1113 }
1114
1115 ifnet_lock_done(interface);
1116
1117 (void) ifnet_touch_lastchange(interface);
1118
1119 /* Notify application of the change */
1120 ev_msg.vendor_code = KEV_VENDOR_APPLE;
1121 ev_msg.kev_class = KEV_NETWORK_CLASS;
1122 ev_msg.kev_subclass = KEV_DL_SUBCLASS;
1123
1124 ev_msg.event_code = KEV_DL_WAKEFLAGS_CHANGED;
1125 strlcpy(&ev_data.if_name[0], interface->if_name, IFNAMSIZ);
1126 ev_data.if_family = interface->if_family;
1127 ev_data.if_unit = (u_int32_t)interface->if_unit;
1128 ev_msg.dv[0].data_length = sizeof(struct net_event_data);
1129 ev_msg.dv[0].data_ptr = &ev_data;
1130 ev_msg.dv[1].data_length = 0;
1131 dlil_post_complete_msg(interface, &ev_msg);
1132
1133 return 0;
1134 }
1135
1136 u_int32_t
1137 ifnet_get_wake_flags(ifnet_t interface)
1138 {
1139 u_int32_t flags = 0;
1140
1141 if (interface == NULL) {
1142 return 0;
1143 }
1144
1145 if (interface->if_xflags & IFXF_WAKE_ON_MAGIC_PACKET) {
1146 flags |= IF_WAKE_ON_MAGIC_PACKET;
1147 }
1148
1149 return flags;
1150 }
1151
1152 /*
1153 * Should MIB data store a copy?
1154 */
1155 errno_t
1156 ifnet_set_link_mib_data(ifnet_t interface, void *mibData, u_int32_t mibLen)
1157 {
1158 if (interface == NULL) {
1159 return EINVAL;
1160 }
1161
1162 ifnet_lock_exclusive(interface);
1163 interface->if_linkmib = (void*)mibData;
1164 interface->if_linkmiblen = mibLen;
1165 ifnet_lock_done(interface);
1166 return 0;
1167 }
1168
1169 errno_t
1170 ifnet_get_link_mib_data(ifnet_t interface, void *mibData, u_int32_t *mibLen)
1171 {
1172 errno_t result = 0;
1173
1174 if (interface == NULL) {
1175 return EINVAL;
1176 }
1177
1178 ifnet_lock_shared(interface);
1179 if (*mibLen < interface->if_linkmiblen) {
1180 result = EMSGSIZE;
1181 }
1182 if (result == 0 && interface->if_linkmib == NULL) {
1183 result = ENOTSUP;
1184 }
1185
1186 if (result == 0) {
1187 *mibLen = interface->if_linkmiblen;
1188 bcopy(interface->if_linkmib, mibData, *mibLen);
1189 }
1190 ifnet_lock_done(interface);
1191
1192 return result;
1193 }
1194
1195 u_int32_t
1196 ifnet_get_link_mib_data_length(ifnet_t interface)
1197 {
1198 return (interface == NULL) ? 0 : interface->if_linkmiblen;
1199 }
1200
1201 errno_t
1202 ifnet_output(ifnet_t interface, protocol_family_t protocol_family,
1203 mbuf_t m, void *route, const struct sockaddr *dest)
1204 {
1205 if (interface == NULL || protocol_family == 0 || m == NULL) {
1206 if (m != NULL) {
1207 mbuf_freem_list(m);
1208 }
1209 return EINVAL;
1210 }
1211 return dlil_output(interface, protocol_family, m, route, dest, 0, NULL);
1212 }
1213
1214 errno_t
1215 ifnet_output_raw(ifnet_t interface, protocol_family_t protocol_family, mbuf_t m)
1216 {
1217 if (interface == NULL || m == NULL) {
1218 if (m != NULL) {
1219 mbuf_freem_list(m);
1220 }
1221 return EINVAL;
1222 }
1223 return dlil_output(interface, protocol_family, m, NULL, NULL, 1, NULL);
1224 }
1225
1226 errno_t
1227 ifnet_set_mtu(ifnet_t interface, u_int32_t mtu)
1228 {
1229 if (interface == NULL) {
1230 return EINVAL;
1231 }
1232
1233 interface->if_mtu = mtu;
1234 return 0;
1235 }
1236
1237 u_int32_t
1238 ifnet_mtu(ifnet_t interface)
1239 {
1240 return (interface == NULL) ? 0 : interface->if_mtu;
1241 }
1242
1243 u_char
1244 ifnet_type(ifnet_t interface)
1245 {
1246 return (interface == NULL) ? 0 : interface->if_data.ifi_type;
1247 }
1248
1249 errno_t
1250 ifnet_set_addrlen(ifnet_t interface, u_char addrlen)
1251 {
1252 if (interface == NULL) {
1253 return EINVAL;
1254 }
1255
1256 interface->if_data.ifi_addrlen = addrlen;
1257 return 0;
1258 }
1259
1260 u_char
1261 ifnet_addrlen(ifnet_t interface)
1262 {
1263 return (interface == NULL) ? 0 : interface->if_data.ifi_addrlen;
1264 }
1265
1266 errno_t
1267 ifnet_set_hdrlen(ifnet_t interface, u_char hdrlen)
1268 {
1269 if (interface == NULL) {
1270 return EINVAL;
1271 }
1272
1273 interface->if_data.ifi_hdrlen = hdrlen;
1274 return 0;
1275 }
1276
1277 u_char
1278 ifnet_hdrlen(ifnet_t interface)
1279 {
1280 return (interface == NULL) ? 0 : interface->if_data.ifi_hdrlen;
1281 }
1282
1283 errno_t
1284 ifnet_set_metric(ifnet_t interface, u_int32_t metric)
1285 {
1286 if (interface == NULL) {
1287 return EINVAL;
1288 }
1289
1290 interface->if_data.ifi_metric = metric;
1291 return 0;
1292 }
1293
1294 u_int32_t
1295 ifnet_metric(ifnet_t interface)
1296 {
1297 return (interface == NULL) ? 0 : interface->if_data.ifi_metric;
1298 }
1299
1300 errno_t
1301 ifnet_set_baudrate(struct ifnet *ifp, u_int64_t baudrate)
1302 {
1303 if (ifp == NULL) {
1304 return EINVAL;
1305 }
1306
1307 ifp->if_output_bw.max_bw = ifp->if_input_bw.max_bw =
1308 ifp->if_output_bw.eff_bw = ifp->if_input_bw.eff_bw = baudrate;
1309
1310 /* Pin if_baudrate to 32 bits until we can change the storage size */
1311 ifp->if_baudrate = (baudrate > 0xFFFFFFFF) ? 0xFFFFFFFF : baudrate;
1312
1313 return 0;
1314 }
1315
1316 u_int64_t
1317 ifnet_baudrate(struct ifnet *ifp)
1318 {
1319 return (ifp == NULL) ? 0 : ifp->if_baudrate;
1320 }
1321
1322 errno_t
1323 ifnet_set_bandwidths(struct ifnet *ifp, struct if_bandwidths *output_bw,
1324 struct if_bandwidths *input_bw)
1325 {
1326 if (ifp == NULL) {
1327 return EINVAL;
1328 }
1329
1330 /* set input values first (if any), as output values depend on them */
1331 if (input_bw != NULL) {
1332 (void) ifnet_set_input_bandwidths(ifp, input_bw);
1333 }
1334
1335 if (output_bw != NULL) {
1336 (void) ifnet_set_output_bandwidths(ifp, output_bw, FALSE);
1337 }
1338
1339 return 0;
1340 }
1341
1342 static void
1343 ifnet_set_link_status_outbw(struct ifnet *ifp)
1344 {
1345 struct if_wifi_status_v1 *sr;
1346 sr = &ifp->if_link_status->ifsr_u.ifsr_wifi.if_wifi_u.if_status_v1;
1347 if (ifp->if_output_bw.eff_bw != 0) {
1348 sr->valid_bitmask |=
1349 IF_WIFI_UL_EFFECTIVE_BANDWIDTH_VALID;
1350 sr->ul_effective_bandwidth =
1351 ifp->if_output_bw.eff_bw;
1352 }
1353 if (ifp->if_output_bw.max_bw != 0) {
1354 sr->valid_bitmask |=
1355 IF_WIFI_UL_MAX_BANDWIDTH_VALID;
1356 sr->ul_max_bandwidth =
1357 ifp->if_output_bw.max_bw;
1358 }
1359 }
1360
1361 errno_t
1362 ifnet_set_output_bandwidths(struct ifnet *ifp, struct if_bandwidths *bw,
1363 boolean_t locked)
1364 {
1365 struct if_bandwidths old_bw;
1366 struct ifclassq *ifq;
1367 u_int64_t br;
1368
1369 VERIFY(ifp != NULL && bw != NULL);
1370
1371 ifq = &ifp->if_snd;
1372 if (!locked) {
1373 IFCQ_LOCK(ifq);
1374 }
1375 IFCQ_LOCK_ASSERT_HELD(ifq);
1376
1377 old_bw = ifp->if_output_bw;
1378 if (bw->eff_bw != 0) {
1379 ifp->if_output_bw.eff_bw = bw->eff_bw;
1380 }
1381 if (bw->max_bw != 0) {
1382 ifp->if_output_bw.max_bw = bw->max_bw;
1383 }
1384 if (ifp->if_output_bw.eff_bw > ifp->if_output_bw.max_bw) {
1385 ifp->if_output_bw.max_bw = ifp->if_output_bw.eff_bw;
1386 } else if (ifp->if_output_bw.eff_bw == 0) {
1387 ifp->if_output_bw.eff_bw = ifp->if_output_bw.max_bw;
1388 }
1389
1390 /* Pin if_baudrate to 32 bits */
1391 br = MAX(ifp->if_output_bw.max_bw, ifp->if_input_bw.max_bw);
1392 if (br != 0) {
1393 ifp->if_baudrate = (br > 0xFFFFFFFF) ? 0xFFFFFFFF : br;
1394 }
1395
1396 /* Adjust queue parameters if needed */
1397 if (old_bw.eff_bw != ifp->if_output_bw.eff_bw ||
1398 old_bw.max_bw != ifp->if_output_bw.max_bw) {
1399 ifnet_update_sndq(ifq, CLASSQ_EV_LINK_BANDWIDTH);
1400 }
1401
1402 if (!locked) {
1403 IFCQ_UNLOCK(ifq);
1404 }
1405
1406 /*
1407 * If this is a Wifi interface, update the values in
1408 * if_link_status structure also.
1409 */
1410 if (IFNET_IS_WIFI(ifp) && ifp->if_link_status != NULL) {
1411 lck_rw_lock_exclusive(&ifp->if_link_status_lock);
1412 ifnet_set_link_status_outbw(ifp);
1413 lck_rw_done(&ifp->if_link_status_lock);
1414 }
1415
1416 return 0;
1417 }
1418
1419 static void
1420 ifnet_set_link_status_inbw(struct ifnet *ifp)
1421 {
1422 struct if_wifi_status_v1 *sr;
1423
1424 sr = &ifp->if_link_status->ifsr_u.ifsr_wifi.if_wifi_u.if_status_v1;
1425 if (ifp->if_input_bw.eff_bw != 0) {
1426 sr->valid_bitmask |=
1427 IF_WIFI_DL_EFFECTIVE_BANDWIDTH_VALID;
1428 sr->dl_effective_bandwidth =
1429 ifp->if_input_bw.eff_bw;
1430 }
1431 if (ifp->if_input_bw.max_bw != 0) {
1432 sr->valid_bitmask |=
1433 IF_WIFI_DL_MAX_BANDWIDTH_VALID;
1434 sr->dl_max_bandwidth = ifp->if_input_bw.max_bw;
1435 }
1436 }
1437
1438 errno_t
1439 ifnet_set_input_bandwidths(struct ifnet *ifp, struct if_bandwidths *bw)
1440 {
1441 struct if_bandwidths old_bw;
1442
1443 VERIFY(ifp != NULL && bw != NULL);
1444
1445 old_bw = ifp->if_input_bw;
1446 if (bw->eff_bw != 0) {
1447 ifp->if_input_bw.eff_bw = bw->eff_bw;
1448 }
1449 if (bw->max_bw != 0) {
1450 ifp->if_input_bw.max_bw = bw->max_bw;
1451 }
1452 if (ifp->if_input_bw.eff_bw > ifp->if_input_bw.max_bw) {
1453 ifp->if_input_bw.max_bw = ifp->if_input_bw.eff_bw;
1454 } else if (ifp->if_input_bw.eff_bw == 0) {
1455 ifp->if_input_bw.eff_bw = ifp->if_input_bw.max_bw;
1456 }
1457
1458 if (IFNET_IS_WIFI(ifp) && ifp->if_link_status != NULL) {
1459 lck_rw_lock_exclusive(&ifp->if_link_status_lock);
1460 ifnet_set_link_status_inbw(ifp);
1461 lck_rw_done(&ifp->if_link_status_lock);
1462 }
1463
1464 if (old_bw.eff_bw != ifp->if_input_bw.eff_bw ||
1465 old_bw.max_bw != ifp->if_input_bw.max_bw) {
1466 ifnet_update_rcv(ifp, CLASSQ_EV_LINK_BANDWIDTH);
1467 }
1468
1469 return 0;
1470 }
1471
1472 u_int64_t
1473 ifnet_output_linkrate(struct ifnet *ifp)
1474 {
1475 struct ifclassq *ifq = &ifp->if_snd;
1476 u_int64_t rate;
1477
1478 IFCQ_LOCK_ASSERT_HELD(ifq);
1479
1480 rate = ifp->if_output_bw.eff_bw;
1481 if (IFCQ_TBR_IS_ENABLED(ifq)) {
1482 u_int64_t tbr_rate = ifp->if_snd.ifcq_tbr.tbr_rate_raw;
1483 VERIFY(tbr_rate > 0);
1484 rate = MIN(rate, ifp->if_snd.ifcq_tbr.tbr_rate_raw);
1485 }
1486
1487 return rate;
1488 }
1489
1490 u_int64_t
1491 ifnet_input_linkrate(struct ifnet *ifp)
1492 {
1493 return ifp->if_input_bw.eff_bw;
1494 }
1495
1496 errno_t
1497 ifnet_bandwidths(struct ifnet *ifp, struct if_bandwidths *output_bw,
1498 struct if_bandwidths *input_bw)
1499 {
1500 if (ifp == NULL) {
1501 return EINVAL;
1502 }
1503
1504 if (output_bw != NULL) {
1505 *output_bw = ifp->if_output_bw;
1506 }
1507 if (input_bw != NULL) {
1508 *input_bw = ifp->if_input_bw;
1509 }
1510
1511 return 0;
1512 }
1513
1514 errno_t
1515 ifnet_set_latencies(struct ifnet *ifp, struct if_latencies *output_lt,
1516 struct if_latencies *input_lt)
1517 {
1518 if (ifp == NULL) {
1519 return EINVAL;
1520 }
1521
1522 if (output_lt != NULL) {
1523 (void) ifnet_set_output_latencies(ifp, output_lt, FALSE);
1524 }
1525
1526 if (input_lt != NULL) {
1527 (void) ifnet_set_input_latencies(ifp, input_lt);
1528 }
1529
1530 return 0;
1531 }
1532
1533 errno_t
1534 ifnet_set_output_latencies(struct ifnet *ifp, struct if_latencies *lt,
1535 boolean_t locked)
1536 {
1537 struct if_latencies old_lt;
1538 struct ifclassq *ifq;
1539
1540 VERIFY(ifp != NULL && lt != NULL);
1541
1542 ifq = &ifp->if_snd;
1543 if (!locked) {
1544 IFCQ_LOCK(ifq);
1545 }
1546 IFCQ_LOCK_ASSERT_HELD(ifq);
1547
1548 old_lt = ifp->if_output_lt;
1549 if (lt->eff_lt != 0) {
1550 ifp->if_output_lt.eff_lt = lt->eff_lt;
1551 }
1552 if (lt->max_lt != 0) {
1553 ifp->if_output_lt.max_lt = lt->max_lt;
1554 }
1555 if (ifp->if_output_lt.eff_lt > ifp->if_output_lt.max_lt) {
1556 ifp->if_output_lt.max_lt = ifp->if_output_lt.eff_lt;
1557 } else if (ifp->if_output_lt.eff_lt == 0) {
1558 ifp->if_output_lt.eff_lt = ifp->if_output_lt.max_lt;
1559 }
1560
1561 /* Adjust queue parameters if needed */
1562 if (old_lt.eff_lt != ifp->if_output_lt.eff_lt ||
1563 old_lt.max_lt != ifp->if_output_lt.max_lt) {
1564 ifnet_update_sndq(ifq, CLASSQ_EV_LINK_LATENCY);
1565 }
1566
1567 if (!locked) {
1568 IFCQ_UNLOCK(ifq);
1569 }
1570
1571 return 0;
1572 }
1573
1574 errno_t
1575 ifnet_set_input_latencies(struct ifnet *ifp, struct if_latencies *lt)
1576 {
1577 struct if_latencies old_lt;
1578
1579 VERIFY(ifp != NULL && lt != NULL);
1580
1581 old_lt = ifp->if_input_lt;
1582 if (lt->eff_lt != 0) {
1583 ifp->if_input_lt.eff_lt = lt->eff_lt;
1584 }
1585 if (lt->max_lt != 0) {
1586 ifp->if_input_lt.max_lt = lt->max_lt;
1587 }
1588 if (ifp->if_input_lt.eff_lt > ifp->if_input_lt.max_lt) {
1589 ifp->if_input_lt.max_lt = ifp->if_input_lt.eff_lt;
1590 } else if (ifp->if_input_lt.eff_lt == 0) {
1591 ifp->if_input_lt.eff_lt = ifp->if_input_lt.max_lt;
1592 }
1593
1594 if (old_lt.eff_lt != ifp->if_input_lt.eff_lt ||
1595 old_lt.max_lt != ifp->if_input_lt.max_lt) {
1596 ifnet_update_rcv(ifp, CLASSQ_EV_LINK_LATENCY);
1597 }
1598
1599 return 0;
1600 }
1601
1602 errno_t
1603 ifnet_latencies(struct ifnet *ifp, struct if_latencies *output_lt,
1604 struct if_latencies *input_lt)
1605 {
1606 if (ifp == NULL) {
1607 return EINVAL;
1608 }
1609
1610 if (output_lt != NULL) {
1611 *output_lt = ifp->if_output_lt;
1612 }
1613 if (input_lt != NULL) {
1614 *input_lt = ifp->if_input_lt;
1615 }
1616
1617 return 0;
1618 }
1619
1620 errno_t
1621 ifnet_set_poll_params(struct ifnet *ifp, struct ifnet_poll_params *p)
1622 {
1623 errno_t err;
1624
1625 if (ifp == NULL) {
1626 return EINVAL;
1627 } else if (!ifnet_is_attached(ifp, 1)) {
1628 return ENXIO;
1629 }
1630
1631 err = dlil_rxpoll_set_params(ifp, p, FALSE);
1632
1633 /* Release the io ref count */
1634 ifnet_decr_iorefcnt(ifp);
1635
1636 return err;
1637 }
1638
1639 errno_t
1640 ifnet_poll_params(struct ifnet *ifp, struct ifnet_poll_params *p)
1641 {
1642 errno_t err;
1643
1644 if (ifp == NULL || p == NULL) {
1645 return EINVAL;
1646 } else if (!ifnet_is_attached(ifp, 1)) {
1647 return ENXIO;
1648 }
1649
1650 err = dlil_rxpoll_get_params(ifp, p);
1651
1652 /* Release the io ref count */
1653 ifnet_decr_iorefcnt(ifp);
1654
1655 return err;
1656 }
1657
1658 errno_t
1659 ifnet_stat_increment(struct ifnet *ifp,
1660 const struct ifnet_stat_increment_param *s)
1661 {
1662 if (ifp == NULL) {
1663 return EINVAL;
1664 }
1665
1666 if (s->packets_in != 0) {
1667 atomic_add_64(&ifp->if_data.ifi_ipackets, s->packets_in);
1668 }
1669 if (s->bytes_in != 0) {
1670 atomic_add_64(&ifp->if_data.ifi_ibytes, s->bytes_in);
1671 }
1672 if (s->errors_in != 0) {
1673 atomic_add_64(&ifp->if_data.ifi_ierrors, s->errors_in);
1674 }
1675
1676 if (s->packets_out != 0) {
1677 atomic_add_64(&ifp->if_data.ifi_opackets, s->packets_out);
1678 }
1679 if (s->bytes_out != 0) {
1680 atomic_add_64(&ifp->if_data.ifi_obytes, s->bytes_out);
1681 }
1682 if (s->errors_out != 0) {
1683 atomic_add_64(&ifp->if_data.ifi_oerrors, s->errors_out);
1684 }
1685
1686 if (s->collisions != 0) {
1687 atomic_add_64(&ifp->if_data.ifi_collisions, s->collisions);
1688 }
1689 if (s->dropped != 0) {
1690 atomic_add_64(&ifp->if_data.ifi_iqdrops, s->dropped);
1691 }
1692
1693 /* Touch the last change time. */
1694 TOUCHLASTCHANGE(&ifp->if_lastchange);
1695
1696 if (ifp->if_data_threshold != 0) {
1697 ifnet_notify_data_threshold(ifp);
1698 }
1699
1700 return 0;
1701 }
1702
1703 errno_t
1704 ifnet_stat_increment_in(struct ifnet *ifp, u_int32_t packets_in,
1705 u_int32_t bytes_in, u_int32_t errors_in)
1706 {
1707 if (ifp == NULL) {
1708 return EINVAL;
1709 }
1710
1711 if (packets_in != 0) {
1712 atomic_add_64(&ifp->if_data.ifi_ipackets, packets_in);
1713 }
1714 if (bytes_in != 0) {
1715 atomic_add_64(&ifp->if_data.ifi_ibytes, bytes_in);
1716 }
1717 if (errors_in != 0) {
1718 atomic_add_64(&ifp->if_data.ifi_ierrors, errors_in);
1719 }
1720
1721 TOUCHLASTCHANGE(&ifp->if_lastchange);
1722
1723 if (ifp->if_data_threshold != 0) {
1724 ifnet_notify_data_threshold(ifp);
1725 }
1726
1727 return 0;
1728 }
1729
1730 errno_t
1731 ifnet_stat_increment_out(struct ifnet *ifp, u_int32_t packets_out,
1732 u_int32_t bytes_out, u_int32_t errors_out)
1733 {
1734 if (ifp == NULL) {
1735 return EINVAL;
1736 }
1737
1738 if (packets_out != 0) {
1739 atomic_add_64(&ifp->if_data.ifi_opackets, packets_out);
1740 }
1741 if (bytes_out != 0) {
1742 atomic_add_64(&ifp->if_data.ifi_obytes, bytes_out);
1743 }
1744 if (errors_out != 0) {
1745 atomic_add_64(&ifp->if_data.ifi_oerrors, errors_out);
1746 }
1747
1748 TOUCHLASTCHANGE(&ifp->if_lastchange);
1749
1750 if (ifp->if_data_threshold != 0) {
1751 ifnet_notify_data_threshold(ifp);
1752 }
1753
1754 return 0;
1755 }
1756
1757 errno_t
1758 ifnet_set_stat(struct ifnet *ifp, const struct ifnet_stats_param *s)
1759 {
1760 if (ifp == NULL) {
1761 return EINVAL;
1762 }
1763
1764 atomic_set_64(&ifp->if_data.ifi_ipackets, s->packets_in);
1765 atomic_set_64(&ifp->if_data.ifi_ibytes, s->bytes_in);
1766 atomic_set_64(&ifp->if_data.ifi_imcasts, s->multicasts_in);
1767 atomic_set_64(&ifp->if_data.ifi_ierrors, s->errors_in);
1768
1769 atomic_set_64(&ifp->if_data.ifi_opackets, s->packets_out);
1770 atomic_set_64(&ifp->if_data.ifi_obytes, s->bytes_out);
1771 atomic_set_64(&ifp->if_data.ifi_omcasts, s->multicasts_out);
1772 atomic_set_64(&ifp->if_data.ifi_oerrors, s->errors_out);
1773
1774 atomic_set_64(&ifp->if_data.ifi_collisions, s->collisions);
1775 atomic_set_64(&ifp->if_data.ifi_iqdrops, s->dropped);
1776 atomic_set_64(&ifp->if_data.ifi_noproto, s->no_protocol);
1777
1778 /* Touch the last change time. */
1779 TOUCHLASTCHANGE(&ifp->if_lastchange);
1780
1781 if (ifp->if_data_threshold != 0) {
1782 ifnet_notify_data_threshold(ifp);
1783 }
1784
1785 return 0;
1786 }
1787
1788 errno_t
1789 ifnet_stat(struct ifnet *ifp, struct ifnet_stats_param *s)
1790 {
1791 if (ifp == NULL) {
1792 return EINVAL;
1793 }
1794
1795 atomic_get_64(s->packets_in, &ifp->if_data.ifi_ipackets);
1796 atomic_get_64(s->bytes_in, &ifp->if_data.ifi_ibytes);
1797 atomic_get_64(s->multicasts_in, &ifp->if_data.ifi_imcasts);
1798 atomic_get_64(s->errors_in, &ifp->if_data.ifi_ierrors);
1799
1800 atomic_get_64(s->packets_out, &ifp->if_data.ifi_opackets);
1801 atomic_get_64(s->bytes_out, &ifp->if_data.ifi_obytes);
1802 atomic_get_64(s->multicasts_out, &ifp->if_data.ifi_omcasts);
1803 atomic_get_64(s->errors_out, &ifp->if_data.ifi_oerrors);
1804
1805 atomic_get_64(s->collisions, &ifp->if_data.ifi_collisions);
1806 atomic_get_64(s->dropped, &ifp->if_data.ifi_iqdrops);
1807 atomic_get_64(s->no_protocol, &ifp->if_data.ifi_noproto);
1808
1809 if (ifp->if_data_threshold != 0) {
1810 ifnet_notify_data_threshold(ifp);
1811 }
1812
1813 return 0;
1814 }
1815
1816 errno_t
1817 ifnet_touch_lastchange(ifnet_t interface)
1818 {
1819 if (interface == NULL) {
1820 return EINVAL;
1821 }
1822
1823 TOUCHLASTCHANGE(&interface->if_lastchange);
1824
1825 return 0;
1826 }
1827
1828 errno_t
1829 ifnet_lastchange(ifnet_t interface, struct timeval *last_change)
1830 {
1831 if (interface == NULL) {
1832 return EINVAL;
1833 }
1834
1835 *last_change = interface->if_data.ifi_lastchange;
1836 /* Crude conversion from uptime to calendar time */
1837 last_change->tv_sec += boottime_sec();
1838
1839 return 0;
1840 }
1841
1842 errno_t
1843 ifnet_touch_lastupdown(ifnet_t interface)
1844 {
1845 if (interface == NULL) {
1846 return EINVAL;
1847 }
1848
1849 TOUCHLASTCHANGE(&interface->if_lastupdown);
1850
1851 return 0;
1852 }
1853
1854 errno_t
1855 ifnet_updown_delta(ifnet_t interface, struct timeval *updown_delta)
1856 {
1857 if (interface == NULL) {
1858 return EINVAL;
1859 }
1860
1861 /* Calculate the delta */
1862 updown_delta->tv_sec = net_uptime();
1863 if (updown_delta->tv_sec > interface->if_data.ifi_lastupdown.tv_sec) {
1864 updown_delta->tv_sec -= interface->if_data.ifi_lastupdown.tv_sec;
1865 }
1866 updown_delta->tv_usec = 0;
1867
1868 return 0;
1869 }
1870
1871 errno_t
1872 ifnet_get_address_list(ifnet_t interface, ifaddr_t **addresses)
1873 {
1874 return addresses == NULL ? EINVAL :
1875 ifnet_get_address_list_family(interface, addresses, 0);
1876 }
1877
1878 struct ifnet_addr_list {
1879 SLIST_ENTRY(ifnet_addr_list) ifal_le;
1880 struct ifaddr *ifal_ifa;
1881 };
1882
1883 errno_t
1884 ifnet_get_address_list_family(ifnet_t interface, ifaddr_t **addresses,
1885 sa_family_t family)
1886 {
1887 return ifnet_get_address_list_family_internal(interface, addresses,
1888 family, 0, M_NOWAIT, 0);
1889 }
1890
1891 errno_t
1892 ifnet_get_inuse_address_list(ifnet_t interface, ifaddr_t **addresses)
1893 {
1894 return addresses == NULL ? EINVAL :
1895 ifnet_get_address_list_family_internal(interface, addresses,
1896 0, 0, M_NOWAIT, 1);
1897 }
1898
1899 extern uint32_t tcp_find_anypcb_byaddr(struct ifaddr *ifa);
1900
1901 extern uint32_t udp_find_anypcb_byaddr(struct ifaddr *ifa);
1902
1903 __private_extern__ errno_t
1904 ifnet_get_address_list_family_internal(ifnet_t interface, ifaddr_t **addresses,
1905 sa_family_t family, int detached, int how, int return_inuse_addrs)
1906 {
1907 SLIST_HEAD(, ifnet_addr_list) ifal_head;
1908 struct ifnet_addr_list *ifal, *ifal_tmp;
1909 struct ifnet *ifp;
1910 int count = 0;
1911 errno_t err = 0;
1912 int usecount = 0;
1913 int index = 0;
1914
1915 SLIST_INIT(&ifal_head);
1916
1917 if (addresses == NULL) {
1918 err = EINVAL;
1919 goto done;
1920 }
1921 *addresses = NULL;
1922
1923 if (detached) {
1924 /*
1925 * Interface has been detached, so skip the lookup
1926 * at ifnet_head and go directly to inner loop.
1927 */
1928 ifp = interface;
1929 if (ifp == NULL) {
1930 err = EINVAL;
1931 goto done;
1932 }
1933 goto one;
1934 }
1935
1936 ifnet_head_lock_shared();
1937 TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
1938 if (interface != NULL && ifp != interface) {
1939 continue;
1940 }
1941 one:
1942 ifnet_lock_shared(ifp);
1943 if (interface == NULL || interface == ifp) {
1944 struct ifaddr *ifa;
1945 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
1946 IFA_LOCK(ifa);
1947 if (family != 0 &&
1948 ifa->ifa_addr->sa_family != family) {
1949 IFA_UNLOCK(ifa);
1950 continue;
1951 }
1952 MALLOC(ifal, struct ifnet_addr_list *,
1953 sizeof(*ifal), M_TEMP, how);
1954 if (ifal == NULL) {
1955 IFA_UNLOCK(ifa);
1956 ifnet_lock_done(ifp);
1957 if (!detached) {
1958 ifnet_head_done();
1959 }
1960 err = ENOMEM;
1961 goto done;
1962 }
1963 ifal->ifal_ifa = ifa;
1964 IFA_ADDREF_LOCKED(ifa);
1965 SLIST_INSERT_HEAD(&ifal_head, ifal, ifal_le);
1966 ++count;
1967 IFA_UNLOCK(ifa);
1968 }
1969 }
1970 ifnet_lock_done(ifp);
1971 if (detached) {
1972 break;
1973 }
1974 }
1975 if (!detached) {
1976 ifnet_head_done();
1977 }
1978
1979 if (count == 0) {
1980 err = ENXIO;
1981 goto done;
1982 }
1983 MALLOC(*addresses, ifaddr_t *, sizeof(ifaddr_t) * (count + 1),
1984 M_TEMP, how);
1985 if (*addresses == NULL) {
1986 err = ENOMEM;
1987 goto done;
1988 }
1989 bzero(*addresses, sizeof(ifaddr_t) * (count + 1));
1990
1991 done:
1992 SLIST_FOREACH_SAFE(ifal, &ifal_head, ifal_le, ifal_tmp) {
1993 SLIST_REMOVE(&ifal_head, ifal, ifnet_addr_list, ifal_le);
1994 if (err == 0) {
1995 if (return_inuse_addrs) {
1996 usecount = tcp_find_anypcb_byaddr(ifal->ifal_ifa);
1997 usecount += udp_find_anypcb_byaddr(ifal->ifal_ifa);
1998 if (usecount) {
1999 (*addresses)[index] = ifal->ifal_ifa;
2000 index++;
2001 } else {
2002 IFA_REMREF(ifal->ifal_ifa);
2003 }
2004 } else {
2005 (*addresses)[--count] = ifal->ifal_ifa;
2006 }
2007 } else {
2008 IFA_REMREF(ifal->ifal_ifa);
2009 }
2010 FREE(ifal, M_TEMP);
2011 }
2012
2013 VERIFY(err == 0 || *addresses == NULL);
2014 if ((err == 0) && (count) && ((*addresses)[0] == NULL)) {
2015 VERIFY(return_inuse_addrs == 1);
2016 FREE(*addresses, M_TEMP);
2017 err = ENXIO;
2018 }
2019 return err;
2020 }
2021
2022 void
2023 ifnet_free_address_list(ifaddr_t *addresses)
2024 {
2025 int i;
2026
2027 if (addresses == NULL) {
2028 return;
2029 }
2030
2031 for (i = 0; addresses[i] != NULL; i++) {
2032 IFA_REMREF(addresses[i]);
2033 }
2034
2035 FREE(addresses, M_TEMP);
2036 }
2037
2038 void *
2039 ifnet_lladdr(ifnet_t interface)
2040 {
2041 struct ifaddr *ifa;
2042 void *lladdr;
2043
2044 if (interface == NULL) {
2045 return NULL;
2046 }
2047
2048 /*
2049 * if_lladdr points to the permanent link address of
2050 * the interface and it never gets deallocated; internal
2051 * code should simply use IF_LLADDR() for performance.
2052 */
2053 ifa = interface->if_lladdr;
2054 IFA_LOCK_SPIN(ifa);
2055 lladdr = LLADDR(SDL((void *)ifa->ifa_addr));
2056 IFA_UNLOCK(ifa);
2057
2058 return lladdr;
2059 }
2060
2061 errno_t
2062 ifnet_llbroadcast_copy_bytes(ifnet_t interface, void *addr, size_t buffer_len,
2063 size_t *out_len)
2064 {
2065 if (interface == NULL || addr == NULL || out_len == NULL) {
2066 return EINVAL;
2067 }
2068
2069 *out_len = interface->if_broadcast.length;
2070
2071 if (buffer_len < interface->if_broadcast.length) {
2072 return EMSGSIZE;
2073 }
2074
2075 if (interface->if_broadcast.length == 0) {
2076 return ENXIO;
2077 }
2078
2079 if (interface->if_broadcast.length <=
2080 sizeof(interface->if_broadcast.u.buffer)) {
2081 bcopy(interface->if_broadcast.u.buffer, addr,
2082 interface->if_broadcast.length);
2083 } else {
2084 bcopy(interface->if_broadcast.u.ptr, addr,
2085 interface->if_broadcast.length);
2086 }
2087
2088 return 0;
2089 }
2090
2091 static errno_t
2092 ifnet_lladdr_copy_bytes_internal(ifnet_t interface, void *lladdr,
2093 size_t lladdr_len, kauth_cred_t *credp)
2094 {
2095 const u_int8_t *bytes;
2096 size_t bytes_len;
2097 struct ifaddr *ifa;
2098 uint8_t sdlbuf[SOCK_MAXADDRLEN + 1];
2099 errno_t error = 0;
2100
2101 /*
2102 * Make sure to accomodate the largest possible
2103 * size of SA(if_lladdr)->sa_len.
2104 */
2105 _CASSERT(sizeof(sdlbuf) == (SOCK_MAXADDRLEN + 1));
2106
2107 if (interface == NULL || lladdr == NULL) {
2108 return EINVAL;
2109 }
2110
2111 ifa = interface->if_lladdr;
2112 IFA_LOCK_SPIN(ifa);
2113 bcopy(ifa->ifa_addr, &sdlbuf, SDL(ifa->ifa_addr)->sdl_len);
2114 IFA_UNLOCK(ifa);
2115
2116 bytes = dlil_ifaddr_bytes(SDL(&sdlbuf), &bytes_len, credp);
2117 if (bytes_len != lladdr_len) {
2118 bzero(lladdr, lladdr_len);
2119 error = EMSGSIZE;
2120 } else {
2121 bcopy(bytes, lladdr, bytes_len);
2122 }
2123
2124 return error;
2125 }
2126
2127 errno_t
2128 ifnet_lladdr_copy_bytes(ifnet_t interface, void *lladdr, size_t length)
2129 {
2130 return ifnet_lladdr_copy_bytes_internal(interface, lladdr, length,
2131 NULL);
2132 }
2133
2134 errno_t
2135 ifnet_guarded_lladdr_copy_bytes(ifnet_t interface, void *lladdr, size_t length)
2136 {
2137 #if CONFIG_MACF
2138 kauth_cred_t cred;
2139 net_thread_marks_t marks;
2140 #endif
2141 kauth_cred_t *credp;
2142 errno_t error;
2143
2144 credp = NULL;
2145 #if CONFIG_MACF
2146 marks = net_thread_marks_push(NET_THREAD_CKREQ_LLADDR);
2147 cred = kauth_cred_proc_ref(current_proc());
2148 credp = &cred;
2149 #else
2150 credp = NULL;
2151 #endif
2152
2153 error = ifnet_lladdr_copy_bytes_internal(interface, lladdr, length,
2154 credp);
2155
2156 #if CONFIG_MACF
2157 kauth_cred_unref(credp);
2158 net_thread_marks_pop(marks);
2159 #endif
2160
2161 return error;
2162 }
2163
2164 static errno_t
2165 ifnet_set_lladdr_internal(ifnet_t interface, const void *lladdr,
2166 size_t lladdr_len, u_char new_type, int apply_type)
2167 {
2168 struct ifaddr *ifa;
2169 errno_t error = 0;
2170
2171 if (interface == NULL) {
2172 return EINVAL;
2173 }
2174
2175 ifnet_head_lock_shared();
2176 ifnet_lock_exclusive(interface);
2177 if (lladdr_len != 0 &&
2178 (lladdr_len != interface->if_addrlen || lladdr == 0)) {
2179 ifnet_lock_done(interface);
2180 ifnet_head_done();
2181 return EINVAL;
2182 }
2183 ifa = ifnet_addrs[interface->if_index - 1];
2184 if (ifa != NULL) {
2185 struct sockaddr_dl *sdl;
2186
2187 IFA_LOCK_SPIN(ifa);
2188 sdl = (struct sockaddr_dl *)(void *)ifa->ifa_addr;
2189 if (lladdr_len != 0) {
2190 bcopy(lladdr, LLADDR(sdl), lladdr_len);
2191 } else {
2192 bzero(LLADDR(sdl), interface->if_addrlen);
2193 }
2194 sdl->sdl_alen = lladdr_len;
2195
2196 if (apply_type) {
2197 sdl->sdl_type = new_type;
2198 }
2199 IFA_UNLOCK(ifa);
2200 } else {
2201 error = ENXIO;
2202 }
2203 ifnet_lock_done(interface);
2204 ifnet_head_done();
2205
2206 /* Generate a kernel event */
2207 if (error == 0) {
2208 intf_event_enqueue_nwk_wq_entry(interface, NULL,
2209 INTF_EVENT_CODE_LLADDR_UPDATE);
2210 dlil_post_msg(interface, KEV_DL_SUBCLASS,
2211 KEV_DL_LINK_ADDRESS_CHANGED, NULL, 0);
2212 }
2213
2214 return error;
2215 }
2216
2217 errno_t
2218 ifnet_set_lladdr(ifnet_t interface, const void* lladdr, size_t lladdr_len)
2219 {
2220 return ifnet_set_lladdr_internal(interface, lladdr, lladdr_len, 0, 0);
2221 }
2222
2223 errno_t
2224 ifnet_set_lladdr_and_type(ifnet_t interface, const void* lladdr,
2225 size_t lladdr_len, u_char type)
2226 {
2227 return ifnet_set_lladdr_internal(interface, lladdr,
2228 lladdr_len, type, 1);
2229 }
2230
2231 errno_t
2232 ifnet_add_multicast(ifnet_t interface, const struct sockaddr *maddr,
2233 ifmultiaddr_t *ifmap)
2234 {
2235 if (interface == NULL || maddr == NULL) {
2236 return EINVAL;
2237 }
2238
2239 /* Don't let users screw up protocols' entries. */
2240 switch (maddr->sa_family) {
2241 case AF_LINK: {
2242 const struct sockaddr_dl *sdl =
2243 (const struct sockaddr_dl *)(uintptr_t)maddr;
2244 if (sdl->sdl_len < sizeof(struct sockaddr_dl) ||
2245 (sdl->sdl_nlen + sdl->sdl_alen + sdl->sdl_slen +
2246 offsetof(struct sockaddr_dl, sdl_data) > sdl->sdl_len)) {
2247 return EINVAL;
2248 }
2249 break;
2250 }
2251 case AF_UNSPEC:
2252 if (maddr->sa_len < ETHER_ADDR_LEN +
2253 offsetof(struct sockaddr, sa_data)) {
2254 return EINVAL;
2255 }
2256 break;
2257 default:
2258 return EINVAL;
2259 }
2260
2261 return if_addmulti_anon(interface, maddr, ifmap);
2262 }
2263
2264 errno_t
2265 ifnet_remove_multicast(ifmultiaddr_t ifma)
2266 {
2267 struct sockaddr *maddr;
2268
2269 if (ifma == NULL) {
2270 return EINVAL;
2271 }
2272
2273 maddr = ifma->ifma_addr;
2274 /* Don't let users screw up protocols' entries. */
2275 if (maddr->sa_family != AF_UNSPEC && maddr->sa_family != AF_LINK) {
2276 return EINVAL;
2277 }
2278
2279 return if_delmulti_anon(ifma->ifma_ifp, maddr);
2280 }
2281
2282 errno_t
2283 ifnet_get_multicast_list(ifnet_t ifp, ifmultiaddr_t **addresses)
2284 {
2285 int count = 0;
2286 int cmax = 0;
2287 struct ifmultiaddr *addr;
2288
2289 if (ifp == NULL || addresses == NULL) {
2290 return EINVAL;
2291 }
2292
2293 ifnet_lock_shared(ifp);
2294 LIST_FOREACH(addr, &ifp->if_multiaddrs, ifma_link) {
2295 cmax++;
2296 }
2297
2298 MALLOC(*addresses, ifmultiaddr_t *, sizeof(ifmultiaddr_t) * (cmax + 1),
2299 M_TEMP, M_NOWAIT);
2300 if (*addresses == NULL) {
2301 ifnet_lock_done(ifp);
2302 return ENOMEM;
2303 }
2304
2305 LIST_FOREACH(addr, &ifp->if_multiaddrs, ifma_link) {
2306 if (count + 1 > cmax) {
2307 break;
2308 }
2309 (*addresses)[count] = (ifmultiaddr_t)addr;
2310 ifmaddr_reference((*addresses)[count]);
2311 count++;
2312 }
2313 (*addresses)[cmax] = NULL;
2314 ifnet_lock_done(ifp);
2315
2316 return 0;
2317 }
2318
2319 void
2320 ifnet_free_multicast_list(ifmultiaddr_t *addresses)
2321 {
2322 int i;
2323
2324 if (addresses == NULL) {
2325 return;
2326 }
2327
2328 for (i = 0; addresses[i] != NULL; i++) {
2329 ifmaddr_release(addresses[i]);
2330 }
2331
2332 FREE(addresses, M_TEMP);
2333 }
2334
2335 errno_t
2336 ifnet_find_by_name(const char *ifname, ifnet_t *ifpp)
2337 {
2338 struct ifnet *ifp;
2339 int namelen;
2340
2341 if (ifname == NULL) {
2342 return EINVAL;
2343 }
2344
2345 namelen = strlen(ifname);
2346
2347 *ifpp = NULL;
2348
2349 ifnet_head_lock_shared();
2350 TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
2351 struct ifaddr *ifa;
2352 struct sockaddr_dl *ll_addr;
2353
2354 ifa = ifnet_addrs[ifp->if_index - 1];
2355 if (ifa == NULL) {
2356 continue;
2357 }
2358
2359 IFA_LOCK(ifa);
2360 ll_addr = (struct sockaddr_dl *)(void *)ifa->ifa_addr;
2361
2362 if (namelen == ll_addr->sdl_nlen && strncmp(ll_addr->sdl_data,
2363 ifname, ll_addr->sdl_nlen) == 0) {
2364 IFA_UNLOCK(ifa);
2365 *ifpp = ifp;
2366 ifnet_reference(*ifpp);
2367 break;
2368 }
2369 IFA_UNLOCK(ifa);
2370 }
2371 ifnet_head_done();
2372
2373 return (ifp == NULL) ? ENXIO : 0;
2374 }
2375
2376 errno_t
2377 ifnet_list_get(ifnet_family_t family, ifnet_t **list, u_int32_t *count)
2378 {
2379 return ifnet_list_get_common(family, FALSE, list, count);
2380 }
2381
2382 __private_extern__ errno_t
2383 ifnet_list_get_all(ifnet_family_t family, ifnet_t **list, u_int32_t *count)
2384 {
2385 return ifnet_list_get_common(family, TRUE, list, count);
2386 }
2387
2388 struct ifnet_list {
2389 SLIST_ENTRY(ifnet_list) ifl_le;
2390 struct ifnet *ifl_ifp;
2391 };
2392
2393 static errno_t
2394 ifnet_list_get_common(ifnet_family_t family, boolean_t get_all, ifnet_t **list,
2395 u_int32_t *count)
2396 {
2397 #pragma unused(get_all)
2398 SLIST_HEAD(, ifnet_list) ifl_head;
2399 struct ifnet_list *ifl, *ifl_tmp;
2400 struct ifnet *ifp;
2401 int cnt = 0;
2402 errno_t err = 0;
2403
2404 SLIST_INIT(&ifl_head);
2405
2406 if (list == NULL || count == NULL) {
2407 err = EINVAL;
2408 goto done;
2409 }
2410 *count = 0;
2411 *list = NULL;
2412
2413 ifnet_head_lock_shared();
2414 TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
2415 if (family == IFNET_FAMILY_ANY || ifp->if_family == family) {
2416 MALLOC(ifl, struct ifnet_list *, sizeof(*ifl),
2417 M_TEMP, M_NOWAIT);
2418 if (ifl == NULL) {
2419 ifnet_head_done();
2420 err = ENOMEM;
2421 goto done;
2422 }
2423 ifl->ifl_ifp = ifp;
2424 ifnet_reference(ifp);
2425 SLIST_INSERT_HEAD(&ifl_head, ifl, ifl_le);
2426 ++cnt;
2427 }
2428 }
2429 ifnet_head_done();
2430
2431 if (cnt == 0) {
2432 err = ENXIO;
2433 goto done;
2434 }
2435
2436 MALLOC(*list, ifnet_t *, sizeof(ifnet_t) * (cnt + 1),
2437 M_TEMP, M_NOWAIT);
2438 if (*list == NULL) {
2439 err = ENOMEM;
2440 goto done;
2441 }
2442 bzero(*list, sizeof(ifnet_t) * (cnt + 1));
2443 *count = cnt;
2444
2445 done:
2446 SLIST_FOREACH_SAFE(ifl, &ifl_head, ifl_le, ifl_tmp) {
2447 SLIST_REMOVE(&ifl_head, ifl, ifnet_list, ifl_le);
2448 if (err == 0) {
2449 (*list)[--cnt] = ifl->ifl_ifp;
2450 } else {
2451 ifnet_release(ifl->ifl_ifp);
2452 }
2453 FREE(ifl, M_TEMP);
2454 }
2455
2456 return err;
2457 }
2458
2459 void
2460 ifnet_list_free(ifnet_t *interfaces)
2461 {
2462 int i;
2463
2464 if (interfaces == NULL) {
2465 return;
2466 }
2467
2468 for (i = 0; interfaces[i]; i++) {
2469 ifnet_release(interfaces[i]);
2470 }
2471
2472 FREE(interfaces, M_TEMP);
2473 }
2474
2475 /*************************************************************************/
2476 /* ifaddr_t accessors */
2477 /*************************************************************************/
2478
2479 errno_t
2480 ifaddr_reference(ifaddr_t ifa)
2481 {
2482 if (ifa == NULL) {
2483 return EINVAL;
2484 }
2485
2486 IFA_ADDREF(ifa);
2487 return 0;
2488 }
2489
2490 errno_t
2491 ifaddr_release(ifaddr_t ifa)
2492 {
2493 if (ifa == NULL) {
2494 return EINVAL;
2495 }
2496
2497 IFA_REMREF(ifa);
2498 return 0;
2499 }
2500
2501 sa_family_t
2502 ifaddr_address_family(ifaddr_t ifa)
2503 {
2504 sa_family_t family = 0;
2505
2506 if (ifa != NULL) {
2507 IFA_LOCK_SPIN(ifa);
2508 if (ifa->ifa_addr != NULL) {
2509 family = ifa->ifa_addr->sa_family;
2510 }
2511 IFA_UNLOCK(ifa);
2512 }
2513 return family;
2514 }
2515
2516 errno_t
2517 ifaddr_address(ifaddr_t ifa, struct sockaddr *out_addr, u_int32_t addr_size)
2518 {
2519 u_int32_t copylen;
2520
2521 if (ifa == NULL || out_addr == NULL) {
2522 return EINVAL;
2523 }
2524
2525 IFA_LOCK_SPIN(ifa);
2526 if (ifa->ifa_addr == NULL) {
2527 IFA_UNLOCK(ifa);
2528 return ENOTSUP;
2529 }
2530
2531 copylen = (addr_size >= ifa->ifa_addr->sa_len) ?
2532 ifa->ifa_addr->sa_len : addr_size;
2533 bcopy(ifa->ifa_addr, out_addr, copylen);
2534
2535 if (ifa->ifa_addr->sa_len > addr_size) {
2536 IFA_UNLOCK(ifa);
2537 return EMSGSIZE;
2538 }
2539
2540 IFA_UNLOCK(ifa);
2541 return 0;
2542 }
2543
2544 errno_t
2545 ifaddr_dstaddress(ifaddr_t ifa, struct sockaddr *out_addr, u_int32_t addr_size)
2546 {
2547 u_int32_t copylen;
2548
2549 if (ifa == NULL || out_addr == NULL) {
2550 return EINVAL;
2551 }
2552
2553 IFA_LOCK_SPIN(ifa);
2554 if (ifa->ifa_dstaddr == NULL) {
2555 IFA_UNLOCK(ifa);
2556 return ENOTSUP;
2557 }
2558
2559 copylen = (addr_size >= ifa->ifa_dstaddr->sa_len) ?
2560 ifa->ifa_dstaddr->sa_len : addr_size;
2561 bcopy(ifa->ifa_dstaddr, out_addr, copylen);
2562
2563 if (ifa->ifa_dstaddr->sa_len > addr_size) {
2564 IFA_UNLOCK(ifa);
2565 return EMSGSIZE;
2566 }
2567
2568 IFA_UNLOCK(ifa);
2569 return 0;
2570 }
2571
2572 errno_t
2573 ifaddr_netmask(ifaddr_t ifa, struct sockaddr *out_addr, u_int32_t addr_size)
2574 {
2575 u_int32_t copylen;
2576
2577 if (ifa == NULL || out_addr == NULL) {
2578 return EINVAL;
2579 }
2580
2581 IFA_LOCK_SPIN(ifa);
2582 if (ifa->ifa_netmask == NULL) {
2583 IFA_UNLOCK(ifa);
2584 return ENOTSUP;
2585 }
2586
2587 copylen = addr_size >= ifa->ifa_netmask->sa_len ?
2588 ifa->ifa_netmask->sa_len : addr_size;
2589 bcopy(ifa->ifa_netmask, out_addr, copylen);
2590
2591 if (ifa->ifa_netmask->sa_len > addr_size) {
2592 IFA_UNLOCK(ifa);
2593 return EMSGSIZE;
2594 }
2595
2596 IFA_UNLOCK(ifa);
2597 return 0;
2598 }
2599
2600 ifnet_t
2601 ifaddr_ifnet(ifaddr_t ifa)
2602 {
2603 struct ifnet *ifp;
2604
2605 if (ifa == NULL) {
2606 return NULL;
2607 }
2608
2609 /* ifa_ifp is set once at creation time; it is never changed */
2610 ifp = ifa->ifa_ifp;
2611
2612 return ifp;
2613 }
2614
2615 ifaddr_t
2616 ifaddr_withaddr(const struct sockaddr *address)
2617 {
2618 if (address == NULL) {
2619 return NULL;
2620 }
2621
2622 return ifa_ifwithaddr(address);
2623 }
2624
2625 ifaddr_t
2626 ifaddr_withdstaddr(const struct sockaddr *address)
2627 {
2628 if (address == NULL) {
2629 return NULL;
2630 }
2631
2632 return ifa_ifwithdstaddr(address);
2633 }
2634
2635 ifaddr_t
2636 ifaddr_withnet(const struct sockaddr *net)
2637 {
2638 if (net == NULL) {
2639 return NULL;
2640 }
2641
2642 return ifa_ifwithnet(net);
2643 }
2644
2645 ifaddr_t
2646 ifaddr_withroute(int flags, const struct sockaddr *destination,
2647 const struct sockaddr *gateway)
2648 {
2649 if (destination == NULL || gateway == NULL) {
2650 return NULL;
2651 }
2652
2653 return ifa_ifwithroute(flags, destination, gateway);
2654 }
2655
2656 ifaddr_t
2657 ifaddr_findbestforaddr(const struct sockaddr *addr, ifnet_t interface)
2658 {
2659 if (addr == NULL || interface == NULL) {
2660 return NULL;
2661 }
2662
2663 return ifaof_ifpforaddr_select(addr, interface);
2664 }
2665
2666 errno_t
2667 ifmaddr_reference(ifmultiaddr_t ifmaddr)
2668 {
2669 if (ifmaddr == NULL) {
2670 return EINVAL;
2671 }
2672
2673 IFMA_ADDREF(ifmaddr);
2674 return 0;
2675 }
2676
2677 errno_t
2678 ifmaddr_release(ifmultiaddr_t ifmaddr)
2679 {
2680 if (ifmaddr == NULL) {
2681 return EINVAL;
2682 }
2683
2684 IFMA_REMREF(ifmaddr);
2685 return 0;
2686 }
2687
2688 errno_t
2689 ifmaddr_address(ifmultiaddr_t ifma, struct sockaddr *out_addr,
2690 u_int32_t addr_size)
2691 {
2692 u_int32_t copylen;
2693
2694 if (ifma == NULL || out_addr == NULL) {
2695 return EINVAL;
2696 }
2697
2698 IFMA_LOCK(ifma);
2699 if (ifma->ifma_addr == NULL) {
2700 IFMA_UNLOCK(ifma);
2701 return ENOTSUP;
2702 }
2703
2704 copylen = (addr_size >= ifma->ifma_addr->sa_len ?
2705 ifma->ifma_addr->sa_len : addr_size);
2706 bcopy(ifma->ifma_addr, out_addr, copylen);
2707
2708 if (ifma->ifma_addr->sa_len > addr_size) {
2709 IFMA_UNLOCK(ifma);
2710 return EMSGSIZE;
2711 }
2712 IFMA_UNLOCK(ifma);
2713 return 0;
2714 }
2715
2716 errno_t
2717 ifmaddr_lladdress(ifmultiaddr_t ifma, struct sockaddr *out_addr,
2718 u_int32_t addr_size)
2719 {
2720 struct ifmultiaddr *ifma_ll;
2721
2722 if (ifma == NULL || out_addr == NULL) {
2723 return EINVAL;
2724 }
2725 if ((ifma_ll = ifma->ifma_ll) == NULL) {
2726 return ENOTSUP;
2727 }
2728
2729 return ifmaddr_address(ifma_ll, out_addr, addr_size);
2730 }
2731
2732 ifnet_t
2733 ifmaddr_ifnet(ifmultiaddr_t ifma)
2734 {
2735 return (ifma == NULL) ? NULL : ifma->ifma_ifp;
2736 }
2737
2738 /**************************************************************************/
2739 /* interface cloner */
2740 /**************************************************************************/
2741
2742 errno_t
2743 ifnet_clone_attach(struct ifnet_clone_params *cloner_params,
2744 if_clone_t *ifcloner)
2745 {
2746 errno_t error = 0;
2747 struct if_clone *ifc = NULL;
2748 size_t namelen;
2749
2750 if (cloner_params == NULL || ifcloner == NULL ||
2751 cloner_params->ifc_name == NULL ||
2752 cloner_params->ifc_create == NULL ||
2753 cloner_params->ifc_destroy == NULL ||
2754 (namelen = strlen(cloner_params->ifc_name)) >= IFNAMSIZ) {
2755 error = EINVAL;
2756 goto fail;
2757 }
2758
2759 if (if_clone_lookup(cloner_params->ifc_name, NULL) != NULL) {
2760 printf("%s: already a cloner for %s\n", __func__,
2761 cloner_params->ifc_name);
2762 error = EEXIST;
2763 goto fail;
2764 }
2765
2766 /* Make room for name string */
2767 ifc = _MALLOC(sizeof(struct if_clone) + IFNAMSIZ + 1, M_CLONE,
2768 M_WAITOK | M_ZERO);
2769 if (ifc == NULL) {
2770 printf("%s: _MALLOC failed\n", __func__);
2771 error = ENOBUFS;
2772 goto fail;
2773 }
2774 strlcpy((char *)(ifc + 1), cloner_params->ifc_name, IFNAMSIZ + 1);
2775 ifc->ifc_name = (char *)(ifc + 1);
2776 ifc->ifc_namelen = namelen;
2777 ifc->ifc_maxunit = IF_MAXUNIT;
2778 ifc->ifc_create = cloner_params->ifc_create;
2779 ifc->ifc_destroy = cloner_params->ifc_destroy;
2780
2781 error = if_clone_attach(ifc);
2782 if (error != 0) {
2783 printf("%s: if_clone_attach failed %d\n", __func__, error);
2784 goto fail;
2785 }
2786 *ifcloner = ifc;
2787
2788 return 0;
2789 fail:
2790 if (ifc != NULL) {
2791 FREE(ifc, M_CLONE);
2792 }
2793 return error;
2794 }
2795
2796 errno_t
2797 ifnet_clone_detach(if_clone_t ifcloner)
2798 {
2799 errno_t error = 0;
2800 struct if_clone *ifc = ifcloner;
2801
2802 if (ifc == NULL || ifc->ifc_name == NULL) {
2803 return EINVAL;
2804 }
2805
2806 if ((if_clone_lookup(ifc->ifc_name, NULL)) == NULL) {
2807 printf("%s: no cloner for %s\n", __func__, ifc->ifc_name);
2808 error = EINVAL;
2809 goto fail;
2810 }
2811
2812 if_clone_detach(ifc);
2813
2814 FREE(ifc, M_CLONE);
2815
2816 fail:
2817 return error;
2818 }
2819
2820 /**************************************************************************/
2821 /* misc */
2822 /**************************************************************************/
2823
2824 errno_t
2825 ifnet_get_local_ports_extended(ifnet_t ifp, protocol_family_t protocol,
2826 u_int32_t flags, u_int8_t *bitfield)
2827 {
2828 u_int32_t ifindex;
2829
2830 if (bitfield == NULL) {
2831 return EINVAL;
2832 }
2833
2834 switch (protocol) {
2835 case PF_UNSPEC:
2836 case PF_INET:
2837 case PF_INET6:
2838 break;
2839 default:
2840 return EINVAL;
2841 }
2842
2843 /* bit string is long enough to hold 16-bit port values */
2844 bzero(bitfield, bitstr_size(IP_PORTRANGE_SIZE));
2845
2846 if_ports_used_update_wakeuuid(ifp);
2847
2848
2849 ifindex = (ifp != NULL) ? ifp->if_index : 0;
2850
2851 if (!(flags & IFNET_GET_LOCAL_PORTS_TCPONLY)) {
2852 udp_get_ports_used(ifindex, protocol, flags,
2853 bitfield);
2854 }
2855
2856 if (!(flags & IFNET_GET_LOCAL_PORTS_UDPONLY)) {
2857 tcp_get_ports_used(ifindex, protocol, flags,
2858 bitfield);
2859 }
2860
2861 return 0;
2862 }
2863
2864 errno_t
2865 ifnet_get_local_ports(ifnet_t ifp, u_int8_t *bitfield)
2866 {
2867 u_int32_t flags = IFNET_GET_LOCAL_PORTS_WILDCARDOK;
2868 return ifnet_get_local_ports_extended(ifp, PF_UNSPEC, flags,
2869 bitfield);
2870 }
2871
2872 errno_t
2873 ifnet_notice_node_presence(ifnet_t ifp, struct sockaddr *sa, int32_t rssi,
2874 int lqm, int npm, u_int8_t srvinfo[48])
2875 {
2876 if (ifp == NULL || sa == NULL || srvinfo == NULL) {
2877 return EINVAL;
2878 }
2879 if (sa->sa_len > sizeof(struct sockaddr_storage)) {
2880 return EINVAL;
2881 }
2882 if (sa->sa_family != AF_LINK && sa->sa_family != AF_INET6) {
2883 return EINVAL;
2884 }
2885
2886 return dlil_node_present(ifp, sa, rssi, lqm, npm, srvinfo);
2887 }
2888
2889 errno_t
2890 ifnet_notice_node_presence_v2(ifnet_t ifp, struct sockaddr *sa, struct sockaddr_dl *sdl,
2891 int32_t rssi, int lqm, int npm, u_int8_t srvinfo[48])
2892 {
2893 /* Support older version if sdl is NULL */
2894 if (sdl == NULL) {
2895 return ifnet_notice_node_presence(ifp, sa, rssi, lqm, npm, srvinfo);
2896 }
2897
2898 if (ifp == NULL || sa == NULL || srvinfo == NULL) {
2899 return EINVAL;
2900 }
2901 if (sa->sa_len > sizeof(struct sockaddr_storage)) {
2902 return EINVAL;
2903 }
2904
2905 if (sa->sa_family != AF_INET6) {
2906 return EINVAL;
2907 }
2908
2909 if (sdl->sdl_family != AF_LINK) {
2910 return EINVAL;
2911 }
2912
2913 return dlil_node_present_v2(ifp, sa, sdl, rssi, lqm, npm, srvinfo);
2914 }
2915
2916 errno_t
2917 ifnet_notice_node_absence(ifnet_t ifp, struct sockaddr *sa)
2918 {
2919 if (ifp == NULL || sa == NULL) {
2920 return EINVAL;
2921 }
2922 if (sa->sa_len > sizeof(struct sockaddr_storage)) {
2923 return EINVAL;
2924 }
2925 if (sa->sa_family != AF_LINK && sa->sa_family != AF_INET6) {
2926 return EINVAL;
2927 }
2928
2929 dlil_node_absent(ifp, sa);
2930 return 0;
2931 }
2932
2933 errno_t
2934 ifnet_notice_master_elected(ifnet_t ifp)
2935 {
2936 if (ifp == NULL) {
2937 return EINVAL;
2938 }
2939
2940 dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_MASTER_ELECTED, NULL, 0);
2941 return 0;
2942 }
2943
2944 errno_t
2945 ifnet_tx_compl_status(ifnet_t ifp, mbuf_t m, tx_compl_val_t val)
2946 {
2947 #pragma unused(val)
2948
2949 m_do_tx_compl_callback(m, ifp);
2950
2951 return 0;
2952 }
2953
2954 errno_t
2955 ifnet_tx_compl(ifnet_t ifp, mbuf_t m)
2956 {
2957 m_do_tx_compl_callback(m, ifp);
2958
2959 return 0;
2960 }
2961
2962 errno_t
2963 ifnet_report_issues(ifnet_t ifp, u_int8_t modid[IFNET_MODIDLEN],
2964 u_int8_t info[IFNET_MODARGLEN])
2965 {
2966 if (ifp == NULL || modid == NULL) {
2967 return EINVAL;
2968 }
2969
2970 dlil_report_issues(ifp, modid, info);
2971 return 0;
2972 }
2973
2974 errno_t
2975 ifnet_set_delegate(ifnet_t ifp, ifnet_t delegated_ifp)
2976 {
2977 ifnet_t odifp = NULL;
2978
2979 if (ifp == NULL) {
2980 return EINVAL;
2981 } else if (!ifnet_is_attached(ifp, 1)) {
2982 return ENXIO;
2983 }
2984
2985 ifnet_lock_exclusive(ifp);
2986 odifp = ifp->if_delegated.ifp;
2987 if (odifp != NULL && odifp == delegated_ifp) {
2988 /* delegate info is unchanged; nothing more to do */
2989 ifnet_lock_done(ifp);
2990 goto done;
2991 }
2992 // Test if this delegate interface would cause a loop
2993 ifnet_t delegate_check_ifp = delegated_ifp;
2994 while (delegate_check_ifp != NULL) {
2995 if (delegate_check_ifp == ifp) {
2996 printf("%s: delegating to %s would cause a loop\n",
2997 ifp->if_xname, delegated_ifp->if_xname);
2998 ifnet_lock_done(ifp);
2999 goto done;
3000 }
3001 delegate_check_ifp = delegate_check_ifp->if_delegated.ifp;
3002 }
3003 bzero(&ifp->if_delegated, sizeof(ifp->if_delegated));
3004 if (delegated_ifp != NULL && ifp != delegated_ifp) {
3005 ifp->if_delegated.ifp = delegated_ifp;
3006 ifnet_reference(delegated_ifp);
3007 ifp->if_delegated.type = delegated_ifp->if_type;
3008 ifp->if_delegated.family = delegated_ifp->if_family;
3009 ifp->if_delegated.subfamily = delegated_ifp->if_subfamily;
3010 ifp->if_delegated.expensive =
3011 delegated_ifp->if_eflags & IFEF_EXPENSIVE ? 1 : 0;
3012 ifp->if_delegated.constrained =
3013 delegated_ifp->if_xflags & IFXF_CONSTRAINED ? 1 : 0;
3014
3015 /*
3016 * Propogate flags related to ECN from delegated interface
3017 */
3018 ifp->if_eflags &= ~(IFEF_ECN_ENABLE | IFEF_ECN_DISABLE);
3019 ifp->if_eflags |= (delegated_ifp->if_eflags &
3020 (IFEF_ECN_ENABLE | IFEF_ECN_DISABLE));
3021
3022 printf("%s: is now delegating %s (type 0x%x, family %u, "
3023 "sub-family %u)\n", ifp->if_xname, delegated_ifp->if_xname,
3024 delegated_ifp->if_type, delegated_ifp->if_family,
3025 delegated_ifp->if_subfamily);
3026 }
3027
3028 ifnet_lock_done(ifp);
3029
3030 if (odifp != NULL) {
3031 if (odifp != delegated_ifp) {
3032 printf("%s: is no longer delegating %s\n",
3033 ifp->if_xname, odifp->if_xname);
3034 }
3035 ifnet_release(odifp);
3036 }
3037
3038 /* Generate a kernel event */
3039 dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IFDELEGATE_CHANGED, NULL, 0);
3040
3041 done:
3042 /* Release the io ref count */
3043 ifnet_decr_iorefcnt(ifp);
3044
3045 return 0;
3046 }
3047
3048 errno_t
3049 ifnet_get_delegate(ifnet_t ifp, ifnet_t *pdelegated_ifp)
3050 {
3051 if (ifp == NULL || pdelegated_ifp == NULL) {
3052 return EINVAL;
3053 } else if (!ifnet_is_attached(ifp, 1)) {
3054 return ENXIO;
3055 }
3056
3057 ifnet_lock_shared(ifp);
3058 if (ifp->if_delegated.ifp != NULL) {
3059 ifnet_reference(ifp->if_delegated.ifp);
3060 }
3061 *pdelegated_ifp = ifp->if_delegated.ifp;
3062 ifnet_lock_done(ifp);
3063
3064 /* Release the io ref count */
3065 ifnet_decr_iorefcnt(ifp);
3066
3067 return 0;
3068 }
3069
3070 errno_t
3071 ifnet_get_keepalive_offload_frames(ifnet_t ifp,
3072 struct ifnet_keepalive_offload_frame *frames_array,
3073 u_int32_t frames_array_count, size_t frame_data_offset,
3074 u_int32_t *used_frames_count)
3075 {
3076 u_int32_t i;
3077
3078 if (frames_array == NULL || used_frames_count == NULL ||
3079 frame_data_offset >= IFNET_KEEPALIVE_OFFLOAD_FRAME_DATA_SIZE) {
3080 return EINVAL;
3081 }
3082
3083 /* frame_data_offset should be 32-bit aligned */
3084 if (P2ROUNDUP(frame_data_offset, sizeof(u_int32_t)) !=
3085 frame_data_offset) {
3086 return EINVAL;
3087 }
3088
3089 *used_frames_count = 0;
3090 if (frames_array_count == 0) {
3091 return 0;
3092 }
3093
3094 /* Keep-alive offload not required for CLAT interface */
3095 if (IS_INTF_CLAT46(ifp)) {
3096 return 0;
3097 }
3098
3099 for (i = 0; i < frames_array_count; i++) {
3100 struct ifnet_keepalive_offload_frame *frame = frames_array + i;
3101
3102 bzero(frame, sizeof(struct ifnet_keepalive_offload_frame));
3103 }
3104
3105 /* First collect IPsec related keep-alive frames */
3106 *used_frames_count = key_fill_offload_frames_for_savs(ifp,
3107 frames_array, frames_array_count, frame_data_offset);
3108
3109 /* If there is more room, collect other UDP keep-alive frames */
3110 if (*used_frames_count < frames_array_count) {
3111 udp_fill_keepalive_offload_frames(ifp, frames_array,
3112 frames_array_count, frame_data_offset,
3113 used_frames_count);
3114 }
3115
3116 /* If there is more room, collect other TCP keep-alive frames */
3117 if (*used_frames_count < frames_array_count) {
3118 tcp_fill_keepalive_offload_frames(ifp, frames_array,
3119 frames_array_count, frame_data_offset,
3120 used_frames_count);
3121 }
3122
3123 VERIFY(*used_frames_count <= frames_array_count);
3124
3125 return 0;
3126 }
3127
3128 errno_t
3129 ifnet_notify_tcp_keepalive_offload_timeout(ifnet_t ifp,
3130 struct ifnet_keepalive_offload_frame *frame)
3131 {
3132 errno_t error = 0;
3133
3134 if (ifp == NULL || frame == NULL) {
3135 return EINVAL;
3136 }
3137
3138 if (frame->type != IFNET_KEEPALIVE_OFFLOAD_FRAME_TCP) {
3139 return EINVAL;
3140 }
3141 if (frame->ether_type != IFNET_KEEPALIVE_OFFLOAD_FRAME_ETHERTYPE_IPV4 &&
3142 frame->ether_type != IFNET_KEEPALIVE_OFFLOAD_FRAME_ETHERTYPE_IPV6) {
3143 return EINVAL;
3144 }
3145 if (frame->local_port == 0 || frame->remote_port == 0) {
3146 return EINVAL;
3147 }
3148
3149 error = tcp_notify_kao_timeout(ifp, frame);
3150
3151 return error;
3152 }
3153
3154 errno_t
3155 ifnet_link_status_report(ifnet_t ifp, const void *buffer,
3156 size_t buffer_len)
3157 {
3158 struct if_link_status *ifsr;
3159 errno_t err = 0;
3160
3161 if (ifp == NULL || buffer == NULL || buffer_len == 0) {
3162 return EINVAL;
3163 }
3164
3165 ifnet_lock_shared(ifp);
3166
3167 /*
3168 * Make sure that the interface is attached but there is no need
3169 * to take a reference because this call is coming from the driver.
3170 */
3171 if (!ifnet_is_attached(ifp, 0)) {
3172 ifnet_lock_done(ifp);
3173 return ENXIO;
3174 }
3175
3176 lck_rw_lock_exclusive(&ifp->if_link_status_lock);
3177
3178 /*
3179 * If this is the first status report then allocate memory
3180 * to store it.
3181 */
3182 if (ifp->if_link_status == NULL) {
3183 MALLOC(ifp->if_link_status, struct if_link_status *,
3184 sizeof(struct if_link_status), M_TEMP, M_ZERO);
3185 if (ifp->if_link_status == NULL) {
3186 err = ENOMEM;
3187 goto done;
3188 }
3189 }
3190
3191 ifsr = __DECONST(struct if_link_status *, buffer);
3192
3193 if (ifp->if_type == IFT_CELLULAR) {
3194 struct if_cellular_status_v1 *if_cell_sr, *new_cell_sr;
3195 /*
3196 * Currently we have a single version -- if it does
3197 * not match, just return.
3198 */
3199 if (ifsr->ifsr_version !=
3200 IF_CELLULAR_STATUS_REPORT_CURRENT_VERSION) {
3201 err = ENOTSUP;
3202 goto done;
3203 }
3204
3205 if (ifsr->ifsr_len != sizeof(*if_cell_sr)) {
3206 err = EINVAL;
3207 goto done;
3208 }
3209
3210 if_cell_sr =
3211 &ifp->if_link_status->ifsr_u.ifsr_cell.if_cell_u.if_status_v1;
3212 new_cell_sr = &ifsr->ifsr_u.ifsr_cell.if_cell_u.if_status_v1;
3213 /* Check if we need to act on any new notifications */
3214 if ((new_cell_sr->valid_bitmask &
3215 IF_CELL_UL_MSS_RECOMMENDED_VALID) &&
3216 new_cell_sr->mss_recommended !=
3217 if_cell_sr->mss_recommended) {
3218 atomic_bitset_32(&tcbinfo.ipi_flags,
3219 INPCBINFO_UPDATE_MSS);
3220 inpcb_timer_sched(&tcbinfo, INPCB_TIMER_FAST);
3221 #if NECP
3222 necp_update_all_clients();
3223 #endif
3224 }
3225
3226 /* Finally copy the new information */
3227 ifp->if_link_status->ifsr_version = ifsr->ifsr_version;
3228 ifp->if_link_status->ifsr_len = ifsr->ifsr_len;
3229 if_cell_sr->valid_bitmask = 0;
3230 bcopy(new_cell_sr, if_cell_sr, sizeof(*if_cell_sr));
3231 } else if (IFNET_IS_WIFI(ifp)) {
3232 struct if_wifi_status_v1 *if_wifi_sr, *new_wifi_sr;
3233
3234 /* Check version */
3235 if (ifsr->ifsr_version !=
3236 IF_WIFI_STATUS_REPORT_CURRENT_VERSION) {
3237 err = ENOTSUP;
3238 goto done;
3239 }
3240
3241 if (ifsr->ifsr_len != sizeof(*if_wifi_sr)) {
3242 err = EINVAL;
3243 goto done;
3244 }
3245
3246 if_wifi_sr =
3247 &ifp->if_link_status->ifsr_u.ifsr_wifi.if_wifi_u.if_status_v1;
3248 new_wifi_sr =
3249 &ifsr->ifsr_u.ifsr_wifi.if_wifi_u.if_status_v1;
3250 ifp->if_link_status->ifsr_version = ifsr->ifsr_version;
3251 ifp->if_link_status->ifsr_len = ifsr->ifsr_len;
3252 if_wifi_sr->valid_bitmask = 0;
3253 bcopy(new_wifi_sr, if_wifi_sr, sizeof(*if_wifi_sr));
3254
3255 /*
3256 * Update the bandwidth values if we got recent values
3257 * reported through the other KPI.
3258 */
3259 if (!(new_wifi_sr->valid_bitmask &
3260 IF_WIFI_UL_MAX_BANDWIDTH_VALID) &&
3261 ifp->if_output_bw.max_bw > 0) {
3262 if_wifi_sr->valid_bitmask |=
3263 IF_WIFI_UL_MAX_BANDWIDTH_VALID;
3264 if_wifi_sr->ul_max_bandwidth =
3265 ifp->if_output_bw.max_bw;
3266 }
3267 if (!(new_wifi_sr->valid_bitmask &
3268 IF_WIFI_UL_EFFECTIVE_BANDWIDTH_VALID) &&
3269 ifp->if_output_bw.eff_bw > 0) {
3270 if_wifi_sr->valid_bitmask |=
3271 IF_WIFI_UL_EFFECTIVE_BANDWIDTH_VALID;
3272 if_wifi_sr->ul_effective_bandwidth =
3273 ifp->if_output_bw.eff_bw;
3274 }
3275 if (!(new_wifi_sr->valid_bitmask &
3276 IF_WIFI_DL_MAX_BANDWIDTH_VALID) &&
3277 ifp->if_input_bw.max_bw > 0) {
3278 if_wifi_sr->valid_bitmask |=
3279 IF_WIFI_DL_MAX_BANDWIDTH_VALID;
3280 if_wifi_sr->dl_max_bandwidth =
3281 ifp->if_input_bw.max_bw;
3282 }
3283 if (!(new_wifi_sr->valid_bitmask &
3284 IF_WIFI_DL_EFFECTIVE_BANDWIDTH_VALID) &&
3285 ifp->if_input_bw.eff_bw > 0) {
3286 if_wifi_sr->valid_bitmask |=
3287 IF_WIFI_DL_EFFECTIVE_BANDWIDTH_VALID;
3288 if_wifi_sr->dl_effective_bandwidth =
3289 ifp->if_input_bw.eff_bw;
3290 }
3291 }
3292
3293 done:
3294 lck_rw_done(&ifp->if_link_status_lock);
3295 ifnet_lock_done(ifp);
3296 return err;
3297 }
3298
3299 /*************************************************************************/
3300 /* Fastlane QoS Ca */
3301 /*************************************************************************/
3302
3303 errno_t
3304 ifnet_set_fastlane_capable(ifnet_t interface, boolean_t capable)
3305 {
3306 if (interface == NULL) {
3307 return EINVAL;
3308 }
3309
3310 if_set_qosmarking_mode(interface,
3311 capable ? IFRTYPE_QOSMARKING_FASTLANE : IFRTYPE_QOSMARKING_MODE_NONE);
3312
3313 return 0;
3314 }
3315
3316 errno_t
3317 ifnet_get_fastlane_capable(ifnet_t interface, boolean_t *capable)
3318 {
3319 if (interface == NULL || capable == NULL) {
3320 return EINVAL;
3321 }
3322 if (interface->if_qosmarking_mode == IFRTYPE_QOSMARKING_FASTLANE) {
3323 *capable = true;
3324 } else {
3325 *capable = false;
3326 }
3327 return 0;
3328 }
3329
3330 errno_t
3331 ifnet_get_unsent_bytes(ifnet_t interface, int64_t *unsent_bytes)
3332 {
3333 int64_t bytes;
3334
3335 if (interface == NULL || unsent_bytes == NULL) {
3336 return EINVAL;
3337 }
3338
3339 bytes = *unsent_bytes = 0;
3340
3341 if (!IF_FULLY_ATTACHED(interface)) {
3342 return ENXIO;
3343 }
3344
3345 bytes = interface->if_sndbyte_unsent;
3346
3347 if (interface->if_eflags & IFEF_TXSTART) {
3348 bytes += IFCQ_BYTES(&interface->if_snd);
3349 }
3350 *unsent_bytes = bytes;
3351
3352 return 0;
3353 }
3354
3355 errno_t
3356 ifnet_get_buffer_status(const ifnet_t ifp, ifnet_buffer_status_t *buf_status)
3357 {
3358 if (ifp == NULL || buf_status == NULL) {
3359 return EINVAL;
3360 }
3361
3362 bzero(buf_status, sizeof(*buf_status));
3363
3364 if (!IF_FULLY_ATTACHED(ifp)) {
3365 return ENXIO;
3366 }
3367
3368 if (ifp->if_eflags & IFEF_TXSTART) {
3369 buf_status->buf_interface = IFCQ_BYTES(&ifp->if_snd);
3370 }
3371
3372 buf_status->buf_sndbuf = ((buf_status->buf_interface != 0) ||
3373 (ifp->if_sndbyte_unsent != 0)) ? 1 : 0;
3374
3375 return 0;
3376 }
3377
3378 void
3379 ifnet_normalise_unsent_data(void)
3380 {
3381 struct ifnet *ifp;
3382
3383 ifnet_head_lock_shared();
3384 TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
3385 ifnet_lock_exclusive(ifp);
3386 if (!IF_FULLY_ATTACHED(ifp)) {
3387 ifnet_lock_done(ifp);
3388 continue;
3389 }
3390 if (!(ifp->if_eflags & IFEF_TXSTART)) {
3391 ifnet_lock_done(ifp);
3392 continue;
3393 }
3394
3395 if (ifp->if_sndbyte_total > 0 ||
3396 IFCQ_BYTES(&ifp->if_snd) > 0) {
3397 ifp->if_unsent_data_cnt++;
3398 }
3399
3400 ifnet_lock_done(ifp);
3401 }
3402 ifnet_head_done();
3403 }
3404
3405 errno_t
3406 ifnet_set_low_power_mode(ifnet_t ifp, boolean_t on)
3407 {
3408 errno_t error;
3409
3410 error = if_set_low_power(ifp, on);
3411
3412 return error;
3413 }
3414
3415 errno_t
3416 ifnet_get_low_power_mode(ifnet_t ifp, boolean_t *on)
3417 {
3418 if (ifp == NULL || on == NULL) {
3419 return EINVAL;
3420 }
3421
3422 *on = !!(ifp->if_xflags & IFXF_LOW_POWER);
3423
3424 return 0;
3425 }
3426
3427 /*************************************************************************/
3428 /* Interface advisory notifications */
3429 /*************************************************************************/
3430 errno_t
3431 ifnet_interface_advisory_report(ifnet_t ifp,
3432 const struct ifnet_interface_advisory *advisory)
3433 {
3434
3435 #pragma unused(ifp)
3436 #pragma unused(advisory)
3437 return ENOTSUP;
3438
3439 }
mirror of XNU