]> git.saurik.com Git - apple/configd.git/blob - SystemConfiguration.fproj/BridgeConfiguration.c
projects / apple / configd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
configd-888.1.2.tar.gz
[apple/configd.git] / SystemConfiguration.fproj / BridgeConfiguration.c
1 /*
2 * Copyright (c) 2009-2016 Apple Inc. All rights reserved.
3 *
4 * @APPLE_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. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24 /*
25 * Modification History
26 *
27 * July 27, 2009 Allan Nathanson <ajn@apple.com>
28 * - initial revision
29 */
30
31
32 #include <CoreFoundation/CoreFoundation.h>
33 #include <CoreFoundation/CFRuntime.h>
34
35 #include "SCNetworkConfigurationInternal.h"
36 #include "SCPreferencesInternal.h"
37
38 #include <ifaddrs.h>
39 #include <pthread.h>
40 #include <unistd.h>
41 #include <sys/types.h>
42 #include <sys/ioctl.h>
43 #include <sys/socket.h>
44 #include <sys/sysctl.h>
45 #include <net/ethernet.h>
46 #define KERNEL_PRIVATE
47 #include <net/if.h>
48 #include <net/if_var.h>
49 #undef KERNEL_PRIVATE
50 #include <net/if_types.h>
51 #include <net/if_media.h>
52 #include <net/route.h>
53
54 #ifdef IFT_BRIDGE
55 #include <net/if_bridgevar.h>
56 #endif // IFT_BRIDGE
57
58 /* ---------- Bridge support ---------- */
59
60 static int
61 inet_dgram_socket()
62 {
63 int s;
64
65 s = socket(AF_INET, SOCK_DGRAM, 0);
66 if (s == -1) {
67 SC_log(LOG_ERR, "socket() failed: %s", strerror(errno));
68 }
69
70 return s;
71 }
72
73 #ifdef IFT_BRIDGE
74 static struct ifbifconf *
75 ifbifconf_copy(int s, const char * ifname)
76 {
77 void * buf;
78 size_t buflen;
79 struct ifbifconf * ibc_p = NULL;
80 struct ifdrv ifd;
81 uint32_t len = sizeof(struct ifbreq) * 16;
82
83 bzero(&ifd, sizeof(ifd));
84 strlcpy(ifd.ifd_name, ifname, sizeof(ifd.ifd_name));
85 ifd.ifd_cmd = BRDGGIFS;
86
87 buflen = sizeof(struct ifbifconf) + len;
88 buf = malloc(buflen);
89 while (buf != NULL) {
90 bzero(buf, buflen);
91 ibc_p = (struct ifbifconf *)buf;
92 ibc_p->ifbic_len = len;
93 ibc_p->ifbic_buf = buf + sizeof(*ibc_p);
94
95 ifd.ifd_len = sizeof(*ibc_p);
96 ifd.ifd_data = ibc_p;
97 if (ioctl(s, SIOCGDRVSPEC, (caddr_t)&ifd) == -1) {
98 goto failed;
99 }
100
101 if ((ibc_p->ifbic_len + sizeof(struct ifbreq)) < len) {
102 // if we have room for all of the member interfaces
103 break;
104 }
105
106 len *= 2;
107 buflen = sizeof(struct ifbifconf) + len;
108 buf = reallocf(buf, buflen);
109 }
110
111 if (buf == NULL) {
112 goto failed;
113 }
114
115 return ibc_p;
116
117 failed:
118 if (buf != NULL) {
119 free(buf);
120 }
121 return NULL;
122 }
123 #endif // IFT_BRIDGE
124
125
126 static void
127 add_interface(CFMutableArrayRef *interfaces, CFStringRef if_name, SCPreferencesRef ni_prefs)
128 {
129 SCNetworkInterfaceRef interface = NULL;
130
131 if (*interfaces == NULL) {
132 *interfaces = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
133 }
134 if (ni_prefs != NULL) {
135 interface = __SCNetworkInterfaceCreateWithNIPreferencesUsingBSDName(NULL, ni_prefs, if_name);
136 }
137 if (interface == NULL) {
138 interface = _SCNetworkInterfaceCreateWithBSDName(NULL, if_name,
139 kIncludeNoVirtualInterfaces);
140 }
141
142 if (interface != NULL) {
143 CFArrayAppendValue(*interfaces, interface);
144 CFRelease(interface);
145 }
146 }
147
148 typedef struct {
149 CFMutableArrayRef bridges;
150 SCPreferencesRef ni_prefs;
151 SCPreferencesRef prefs;
152 } addContext, *addContextRef;
153
154
155 static void
156 add_configured_interface(const void *key, const void *value, void *context)
157 {
158 SCBridgeInterfaceRef bridge;
159 CFStringRef bridge_if = (CFStringRef)key;
160 CFDictionaryRef bridge_info = (CFDictionaryRef)value;
161 CFDictionaryRef bridge_options;
162 CFIndex i;
163 CFArrayRef interfaces;
164 SCNetworkInterfacePrivateRef interfacePrivate;
165 CFMutableArrayRef members = NULL;
166 addContextRef myContext = (addContextRef)context;
167 CFStringRef name;
168 CFStringRef name_auto = NULL;
169 CFIndex n;
170
171 // create the bridge interface
172 bridge = (SCBridgeInterfaceRef)_SCBridgeInterfaceCreatePrivate(NULL, bridge_if);
173 assert(bridge != NULL);
174
175 // estabish link to the stored configuration
176 interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
177 interfacePrivate->prefs = CFRetain(myContext->prefs);
178
179 // add member interfaces
180 interfaces = CFDictionaryGetValue(bridge_info, kSCPropVirtualNetworkInterfacesBridgeInterfaces);
181 n = isA_CFArray(interfaces) ? CFArrayGetCount(interfaces) : 0;
182 for (i = 0; i < n; i++) {
183 CFStringRef member;
184
185 member = CFArrayGetValueAtIndex(interfaces, i);
186 if (isA_CFString(member)) {
187 add_interface(&members, member, myContext->ni_prefs);
188 }
189 }
190 if (members != NULL) {
191 __SCBridgeInterfaceSetMemberInterfaces(bridge, members);
192 CFRelease(members);
193 }
194
195 // set options
196 bridge_options = CFDictionaryGetValue(bridge_info, kSCPropVirtualNetworkInterfacesBridgeOptions);
197 if (isA_CFDictionary(bridge_options)) {
198 SCBridgeInterfaceSetOptions(bridge, bridge_options);
199 name_auto = CFDictionaryGetValue(bridge_options, CFSTR("__AUTO__"));
200 }
201
202 // set display name
203 name = CFDictionaryGetValue(bridge_info, kSCPropUserDefinedName);
204 if (isA_CFString(name)) {
205 SCBridgeInterfaceSetLocalizedDisplayName(bridge, name);
206 } else if (isA_CFString(name_auto)) {
207 interfacePrivate->localized_key = name_auto;
208 if (interfacePrivate->localized_arg1 != NULL) {
209 CFRelease(interfacePrivate->localized_arg1);
210 interfacePrivate->localized_arg1 = NULL;
211 }
212 }
213
214 CFArrayAppendValue(myContext->bridges, bridge);
215 CFRelease(bridge);
216
217 return;
218 }
219
220
221 #pragma mark -
222 #pragma mark SCBridgeInterface APIs
223
224
225 static __inline__ void
226 my_CFDictionaryApplyFunction(CFDictionaryRef theDict,
227 CFDictionaryApplierFunction applier,
228 void *context)
229 {
230 CFAllocatorRef myAllocator;
231 CFDictionaryRef myDict;
232
233 myAllocator = CFGetAllocator(theDict);
234 myDict = CFDictionaryCreateCopy(myAllocator, theDict);
235 CFDictionaryApplyFunction(myDict, applier, context);
236 CFRelease(myDict);
237 return;
238 }
239
240
241 CFArrayRef
242 SCBridgeInterfaceCopyAll(SCPreferencesRef prefs)
243 {
244 addContext context;
245 CFDictionaryRef dict;
246 SCPreferencesRef ni_prefs;
247 CFStringRef path;
248
249 if (__SCPreferencesUsingDefaultPrefs(prefs)) {
250 ni_prefs = NULL;
251 } else {
252 ni_prefs = __SCPreferencesCreateNIPrefsFromPrefs(prefs);
253 }
254 context.bridges = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
255 context.prefs = prefs;
256 context.ni_prefs = ni_prefs;
257
258 path = CFStringCreateWithFormat(NULL,
259 NULL,
260 CFSTR("/%@/%@"),
261 kSCPrefVirtualNetworkInterfaces,
262 kSCNetworkInterfaceTypeBridge);
263 dict = SCPreferencesPathGetValue(prefs, path);
264 if (isA_CFDictionary(dict)) {
265 my_CFDictionaryApplyFunction(dict, add_configured_interface, &context);
266 }
267 CFRelease(path);
268 if (ni_prefs != NULL) {
269 CFRelease(ni_prefs);
270 }
271 return context.bridges;
272 }
273
274
275 __private_extern__ void
276 __SCBridgeInterfaceListCollectMembers(CFArrayRef interfaces, CFMutableSetRef set)
277 {
278 CFIndex i;
279 CFIndex n;
280
281 n = CFArrayGetCount(interfaces);
282 for (i = 0; i < n; i++) {
283 SCBridgeInterfaceRef bridgeInterface;
284 CFArrayRef members;
285
286 bridgeInterface = CFArrayGetValueAtIndex(interfaces, i);
287 members = SCBridgeInterfaceGetMemberInterfaces(bridgeInterface);
288 if (members != NULL) {
289 CFIndex j;
290 CFIndex n_members;
291
292 // exclude the member interfaces of this bridge
293 n_members = CFArrayGetCount(members);
294 for (j = 0; j < n_members; j++) {
295 SCNetworkInterfaceRef member;
296
297 member = CFArrayGetValueAtIndex(members, j);
298 CFSetAddValue(set, member);
299 }
300 }
301
302 }
303 return;
304 }
305
306
307 CFArrayRef /* of SCNetworkInterfaceRef's */
308 SCBridgeInterfaceCopyAvailableMemberInterfaces(SCPreferencesRef prefs)
309 {
310 CFMutableArrayRef available;
311 CFMutableSetRef excluded;
312 CFArrayRef interfaces;
313
314 available = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
315 excluded = CFSetCreateMutable (NULL, 0, &kCFTypeSetCallBacks);
316
317 #if !TARGET_OS_IPHONE
318 // exclude Bond [member] interfaces
319 interfaces = SCBondInterfaceCopyAll(prefs);
320 if (interfaces != NULL) {
321 __SCBondInterfaceListCollectMembers(interfaces, excluded);
322 CFRelease(interfaces);
323 }
324 #endif // !TARGET_OS_IPHONE
325
326 // exclude Bridge [member] interfaces
327 interfaces = SCBridgeInterfaceCopyAll(prefs);
328 if (interfaces != NULL) {
329 __SCBridgeInterfaceListCollectMembers(interfaces, excluded);
330 CFRelease(interfaces);
331 }
332
333 // exclude VLAN [physical] interfaces
334 interfaces = SCVLANInterfaceCopyAll(prefs);
335 if (interfaces != NULL) {
336 CFIndex i;
337 CFIndex n;
338
339 n = CFArrayGetCount(interfaces);
340 for (i = 0; i < n; i++) {
341 SCVLANInterfaceRef vlanInterface;
342 SCNetworkInterfaceRef physical;
343
344 // exclude the physical interface of this VLAN
345 vlanInterface = CFArrayGetValueAtIndex(interfaces, i);
346 physical = SCVLANInterfaceGetPhysicalInterface(vlanInterface);
347 CFSetAddValue(excluded, physical);
348 }
349 CFRelease(interfaces);
350 }
351
352 // identify available interfaces
353 interfaces = __SCNetworkInterfaceCopyAll_IONetworkInterface();
354 if (interfaces != NULL) {
355 CFIndex i;
356 CFIndex n;
357
358 n = CFArrayGetCount(interfaces);
359 for (i = 0; i < n; i++) {
360 SCNetworkInterfaceRef interface;
361 SCNetworkInterfacePrivateRef interfacePrivate;
362
363 interface = CFArrayGetValueAtIndex(interfaces, i);
364 interfacePrivate = (SCNetworkInterfacePrivateRef)interface;
365
366 if (!interfacePrivate->supportsBridge) {
367 // if this interface is not available
368 continue;
369 }
370
371 if (CFSetContainsValue(excluded, interface)) {
372 // if excluded
373 continue;
374 }
375
376 CFArrayAppendValue(available, interface);
377 }
378 CFRelease(interfaces);
379 }
380
381 CFRelease(excluded);
382
383 return available;
384 }
385
386
387 CFArrayRef
388 _SCBridgeInterfaceCopyActive(void)
389 {
390 struct ifaddrs *ifap;
391 struct ifaddrs *ifp;
392 int s;
393 CFMutableArrayRef bridges = NULL;
394
395 if (getifaddrs(&ifap) == -1) {
396 _SCErrorSet(errno);
397 SC_log(LOG_NOTICE, "getifaddrs() failed: %s", strerror(errno));
398 return NULL;
399 }
400
401 s = inet_dgram_socket();
402 if (s == -1) {
403 _SCErrorSet(errno);
404 goto done;
405 }
406
407 bridges = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
408
409 for (ifp = ifap; ifp != NULL; ifp = ifp->ifa_next) {
410 #ifdef IFT_BRIDGE
411 SCBridgeInterfaceRef bridge;
412 CFStringRef bridge_if;
413 struct ifbifconf *ibc_p;
414 struct if_data *if_data;
415 CFMutableArrayRef members = NULL;
416 size_t n;
417
418 if_data = (struct if_data *)ifp->ifa_data;
419 if (if_data == NULL
420 || ifp->ifa_addr->sa_family != AF_LINK
421 || if_data->ifi_type != IFT_BRIDGE) {
422 continue;
423 }
424
425 // make sure that we leave non-SC configured bridge
426 // interfaces (those with unit #'s >= 100) alone.
427 n = strlen(ifp->ifa_name);
428 if ((n > 3) &&
429 isdigit(ifp->ifa_name[n - 1]) &&
430 isdigit(ifp->ifa_name[n - 2]) &&
431 isdigit(ifp->ifa_name[n - 3])) {
432 // if not SC managed bridge interface
433 continue;
434 }
435
436 ibc_p = ifbifconf_copy(s, ifp->ifa_name);
437 if (ibc_p == NULL) {
438 if (errno == EBUSY) {
439 continue;
440 }
441 _SCErrorSet(errno);
442 SC_log(LOG_NOTICE, "ifbifconf_copy(%s) failed: %s",
443 ifp->ifa_name,
444 strerror(errno));
445 CFRelease(bridges);
446 bridges = NULL;
447 goto done;
448 }
449
450 // create the bridge interface
451 bridge_if = CFStringCreateWithCString(NULL, ifp->ifa_name, kCFStringEncodingASCII);
452 bridge = (SCBridgeInterfaceRef)_SCBridgeInterfaceCreatePrivate(NULL, bridge_if);
453 CFRelease(bridge_if);
454
455 // add member interfaces
456 if (ibc_p->ifbic_len > 0) {
457 int i;
458
459 // iterate over each member interface
460 for (i = 0; i < ibc_p->ifbic_len / sizeof(struct ifbreq); i++) {
461 struct ifbreq *ibr_p;
462 CFStringRef member;
463
464 ibr_p = ibc_p->ifbic_req + i;
465 member = CFStringCreateWithCString(NULL, ibr_p->ifbr_ifsname, kCFStringEncodingASCII);
466 add_interface(&members, member, NULL);
467 CFRelease(member);
468 }
469 }
470 free(ibc_p);
471
472 if (members != NULL) {
473 __SCBridgeInterfaceSetMemberInterfaces(bridge, members);
474 CFRelease(members);
475 }
476
477 // add bridge
478 CFArrayAppendValue(bridges, bridge);
479 CFRelease(bridge);
480 #endif // IFT_BRIDGE
481 }
482
483 done :
484
485 if (s != -1) {
486 (void) close(s);
487 }
488 freeifaddrs(ifap);
489 return bridges;
490 }
491
492
493 SCBridgeInterfaceRef
494 SCBridgeInterfaceCreate(SCPreferencesRef prefs)
495 {
496 CFAllocatorRef allocator;
497 SCBridgeInterfaceRef bridge = NULL;
498 CFIndex i;
499
500 if (prefs == NULL) {
501 _SCErrorSet(kSCStatusInvalidArgument);
502 return NULL;
503 }
504
505 allocator = CFGetAllocator(prefs);
506
507 // create a new bridge using an unused interface name
508 for (i = 0; bridge == NULL; i++) {
509 CFDictionaryRef dict;
510 CFStringRef bridge_if;
511 SCNetworkInterfacePrivateRef interfacePrivate;
512 CFMutableDictionaryRef newDict;
513 CFArrayRef newInterfaces;
514 Boolean ok;
515 CFStringRef path;
516
517 bridge_if = CFStringCreateWithFormat(allocator, NULL, CFSTR("bridge%ld"), i);
518 path = CFStringCreateWithFormat(allocator,
519 NULL,
520 CFSTR("/%@/%@/%@"),
521 kSCPrefVirtualNetworkInterfaces,
522 kSCNetworkInterfaceTypeBridge,
523 bridge_if);
524 dict = SCPreferencesPathGetValue(prefs, path);
525 if (dict != NULL) {
526 // if bridge interface name not available
527 CFRelease(path);
528 CFRelease(bridge_if);
529 continue;
530 }
531
532 // add the bridge to the stored preferences
533 newDict = CFDictionaryCreateMutable(allocator,
534 0,
535 &kCFTypeDictionaryKeyCallBacks,
536 &kCFTypeDictionaryValueCallBacks);
537 newInterfaces = CFArrayCreate(allocator, NULL, 0, &kCFTypeArrayCallBacks);
538 CFDictionaryAddValue(newDict, kSCPropVirtualNetworkInterfacesBridgeInterfaces, newInterfaces);
539 CFRelease(newInterfaces);
540 ok = SCPreferencesPathSetValue(prefs, path, newDict);
541 CFRelease(newDict);
542 CFRelease(path);
543 if (!ok) {
544 // if the bridge could not be saved
545 CFRelease(bridge_if);
546 break;
547 }
548
549 // create the SCBridgeInterfaceRef
550 bridge = (SCBridgeInterfaceRef)_SCBridgeInterfaceCreatePrivate(allocator, bridge_if);
551 CFRelease(bridge_if);
552
553 // estabish link to the stored configuration
554 interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
555 interfacePrivate->prefs = CFRetain(prefs);
556 }
557
558 return bridge;
559 }
560
561
562 Boolean
563 SCBridgeInterfaceRemove(SCBridgeInterfaceRef bridge)
564 {
565 CFStringRef bridge_if;
566 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
567 Boolean ok;
568 CFStringRef path;
569
570 if (!isA_SCBridgeInterface(bridge)) {
571 _SCErrorSet(kSCStatusInvalidArgument);
572 return FALSE;
573 }
574
575 if (interfacePrivate->prefs == NULL) {
576 _SCErrorSet(kSCStatusInvalidArgument);
577 return FALSE;
578 }
579
580 bridge_if = SCNetworkInterfaceGetBSDName(bridge);
581 path = CFStringCreateWithFormat(NULL,
582 NULL,
583 CFSTR("/%@/%@/%@"),
584 kSCPrefVirtualNetworkInterfaces,
585 kSCNetworkInterfaceTypeBridge,
586 bridge_if);
587 ok = SCPreferencesPathRemoveValue(interfacePrivate->prefs, path);
588 CFRelease(path);
589
590 return ok;
591 }
592
593
594 CFArrayRef
595 SCBridgeInterfaceGetMemberInterfaces(SCBridgeInterfaceRef bridge)
596 {
597 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
598
599 if (!isA_SCBridgeInterface(bridge)) {
600 _SCErrorSet(kSCStatusInvalidArgument);
601 return NULL;
602 }
603
604 return interfacePrivate->bridge.interfaces;
605 }
606
607
608 CFDictionaryRef
609 SCBridgeInterfaceGetOptions(SCBridgeInterfaceRef bridge)
610 {
611 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
612
613 if (!isA_SCBridgeInterface(bridge)) {
614 _SCErrorSet(kSCStatusInvalidArgument);
615 return NULL;
616 }
617
618 return interfacePrivate->bridge.options;
619 }
620
621
622 __private_extern__
623 Boolean
624 __SCBridgeInterfaceSetMemberInterfaces(SCBridgeInterfaceRef bridge, CFArrayRef members)
625 {
626 CFIndex i;
627 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
628 CFIndex n;
629 CFMutableArrayRef newMembers;
630 Boolean ok = TRUE;
631
632 n = (members != NULL) ? CFArrayGetCount(members) : 0;
633
634 // set member interfaces in the stored preferences
635 if (interfacePrivate->prefs != NULL) {
636 CFDictionaryRef dict;
637 CFMutableDictionaryRef newDict;
638 CFStringRef path;
639
640 path = CFStringCreateWithFormat(NULL,
641 NULL,
642 CFSTR("/%@/%@/%@"),
643 kSCPrefVirtualNetworkInterfaces,
644 kSCNetworkInterfaceTypeBridge,
645 interfacePrivate->entity_device);
646 dict = SCPreferencesPathGetValue(interfacePrivate->prefs, path);
647 if (!isA_CFDictionary(dict)) {
648 // if the prefs are confused
649 CFRelease(path);
650 _SCErrorSet(kSCStatusFailed);
651 return FALSE;
652 }
653
654 newMembers = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
655 for (i = 0; i < n; i++) {
656 SCNetworkInterfaceRef interface;
657 CFStringRef memberName;
658
659 interface = CFArrayGetValueAtIndex(members, i);
660 memberName = SCNetworkInterfaceGetBSDName(interface);
661 CFArrayAppendValue(newMembers, memberName);
662 }
663
664 newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
665 CFDictionarySetValue(newDict, kSCPropVirtualNetworkInterfacesBridgeInterfaces, newMembers);
666 CFRelease(newMembers);
667 if (!CFEqual(dict, newDict)) {
668 ok = SCPreferencesPathSetValue(interfacePrivate->prefs, path, newDict);
669 }
670 CFRelease(newDict);
671 CFRelease(path);
672 }
673
674 if (ok) {
675 newMembers = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
676 for (i = 0; i < n; i++) {
677 SCNetworkInterfaceRef member;
678 SCNetworkInterfacePrivateRef newMember;
679
680 member = CFArrayGetValueAtIndex(members, i);
681 newMember = __SCNetworkInterfaceCreateCopy(NULL,
682 member,
683 interfacePrivate->prefs,
684 interfacePrivate->serviceID);
685 CFArrayAppendValue(newMembers, newMember);
686 CFRelease(newMember);
687 }
688 CFRelease(interfacePrivate->bridge.interfaces);
689 interfacePrivate->bridge.interfaces = newMembers;
690 }
691
692 return ok;
693 }
694
695
696 Boolean
697 SCBridgeInterfaceSetMemberInterfaces(SCBridgeInterfaceRef bridge, CFArrayRef members)
698 {
699 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
700 Boolean ok;
701 int sc_status = kSCStatusOK;
702
703 if (!isA_SCBridgeInterface(bridge)) {
704 _SCErrorSet(kSCStatusInvalidArgument);
705 return FALSE;
706 }
707
708 if ((members != NULL) && !isA_CFArray(members)) {
709 _SCErrorSet(kSCStatusInvalidArgument);
710 return FALSE;
711 }
712
713 if (interfacePrivate->prefs != NULL) {
714 CFArrayRef available;
715 CFArrayRef current;
716 CFIndex i;
717 CFIndex n_available;
718 CFIndex n_current;
719 CFIndex n_members;
720 CFArrayRef services = NULL;
721
722 current = SCBridgeInterfaceGetMemberInterfaces(bridge);
723 n_current = (current != NULL) ? CFArrayGetCount(current) : 0;
724
725 available = SCBridgeInterfaceCopyAvailableMemberInterfaces(interfacePrivate->prefs);
726 n_available = (available != NULL) ? CFArrayGetCount(available) : 0;
727
728 n_members = (members != NULL) ? CFArrayGetCount(members) : 0;
729 for (i = 0; i < n_members; i++) {
730 SCNetworkInterfaceRef member;
731
732 member = CFArrayGetValueAtIndex(members, i);
733
734 if ((current != NULL) &&
735 CFArrayContainsValue(current, CFRangeMake(0, n_current), member)) {
736 // current members are allowed
737 continue;
738 }
739
740 if ((available != NULL) &&
741 CFArrayContainsValue(available, CFRangeMake(0, n_available), member)) {
742 // available members are allowed but cannot be associated
743 // with any other network services.
744
745 if (services == NULL) {
746 services = __SCNetworkServiceCopyAllEnabled(interfacePrivate->prefs);
747 }
748 if ((services != NULL) &&
749 __SCNetworkServiceExistsForInterface(services, member)) {
750 sc_status = kSCStatusKeyExists;
751 break;
752 }
753
754 // if available
755 continue;
756 }
757
758 // if member not allowed
759 sc_status = kSCStatusInvalidArgument;
760 break;
761 }
762
763 if (available != NULL) CFRelease(available);
764 if (services != NULL) CFRelease(services);
765 }
766
767 if (sc_status != kSCStatusOK) {
768 _SCErrorSet(sc_status);
769 return FALSE;
770 }
771
772 ok = __SCBridgeInterfaceSetMemberInterfaces(bridge, members);
773 return ok;
774 }
775
776
777 Boolean
778 SCBridgeInterfaceSetLocalizedDisplayName(SCBridgeInterfaceRef bridge, CFStringRef newName)
779 {
780 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
781 Boolean ok = TRUE;
782
783 if (!isA_SCBridgeInterface(bridge)) {
784 _SCErrorSet(kSCStatusInvalidArgument);
785 return FALSE;
786 }
787
788 if ((newName != NULL) && !isA_CFString(newName)) {
789 _SCErrorSet(kSCStatusInvalidArgument);
790 return FALSE;
791 }
792
793 // set name in the stored preferences
794 if (interfacePrivate->prefs != NULL) {
795 CFDictionaryRef dict;
796 CFMutableDictionaryRef newDict;
797 CFStringRef path;
798
799 path = CFStringCreateWithFormat(NULL,
800 NULL,
801 CFSTR("/%@/%@/%@"),
802 kSCPrefVirtualNetworkInterfaces,
803 kSCNetworkInterfaceTypeBridge,
804 interfacePrivate->entity_device);
805 dict = SCPreferencesPathGetValue(interfacePrivate->prefs, path);
806 if (!isA_CFDictionary(dict)) {
807 // if the prefs are confused
808 CFRelease(path);
809 _SCErrorSet(kSCStatusFailed);
810 return FALSE;
811 }
812
813 newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
814 if (newName != NULL) {
815 CFDictionarySetValue(newDict, kSCPropUserDefinedName, newName);
816 } else {
817 CFDictionaryRemoveValue(newDict, kSCPropUserDefinedName);
818 }
819 if (!CFEqual(dict, newDict)) {
820 ok = SCPreferencesPathSetValue(interfacePrivate->prefs, path, newDict);
821 }
822 CFRelease(newDict);
823 CFRelease(path);
824 }
825
826 // set name in the SCBridgeInterfaceRef
827 if (ok) {
828 if (interfacePrivate->localized_name != NULL) {
829 CFRelease(interfacePrivate->localized_name);
830 interfacePrivate->localized_name = NULL;
831 }
832 if (newName != NULL) {
833 interfacePrivate->localized_name = CFStringCreateCopy(NULL, newName);
834 }
835 }
836
837 return ok;
838 }
839
840
841 Boolean
842 SCBridgeInterfaceSetOptions(SCBridgeInterfaceRef bridge, CFDictionaryRef newOptions)
843 {
844 SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bridge;
845 Boolean ok = TRUE;
846
847 if (!isA_SCBridgeInterface(bridge)) {
848 _SCErrorSet(kSCStatusInvalidArgument);
849 return FALSE;
850 }
851
852 if ((newOptions != NULL) && !isA_CFDictionary(newOptions)) {
853 _SCErrorSet(kSCStatusInvalidArgument);
854 return FALSE;
855 }
856
857 // set options in the stored preferences
858 if (interfacePrivate->prefs != NULL) {
859 CFDictionaryRef dict;
860 CFMutableDictionaryRef newDict;
861 CFStringRef path;
862
863 path = CFStringCreateWithFormat(NULL,
864 NULL,
865 CFSTR("/%@/%@/%@"),
866 kSCPrefVirtualNetworkInterfaces,
867 kSCNetworkInterfaceTypeBridge,
868 interfacePrivate->entity_device);
869 dict = SCPreferencesPathGetValue(interfacePrivate->prefs, path);
870 if (!isA_CFDictionary(dict)) {
871 // if the prefs are confused
872 CFRelease(path);
873 _SCErrorSet(kSCStatusFailed);
874 return FALSE;
875 }
876
877 newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
878 if (newOptions != NULL) {
879 CFDictionarySetValue(newDict, kSCPropVirtualNetworkInterfacesBridgeOptions, newOptions);
880 } else {
881 CFDictionaryRemoveValue(newDict, kSCPropVirtualNetworkInterfacesBridgeOptions);
882 }
883 if (!CFEqual(dict, newDict)) {
884 ok = SCPreferencesPathSetValue(interfacePrivate->prefs, path, newDict);
885 }
886 CFRelease(newDict);
887 CFRelease(path);
888 }
889
890 // set options in the SCBridgeInterfaceRef
891 if (ok) {
892 if (interfacePrivate->bridge.options != NULL) {
893 CFRelease(interfacePrivate->bridge.options);
894 interfacePrivate->bridge.options = NULL;
895 }
896 if (newOptions != NULL) {
897 CFStringRef name_auto = NULL;
898
899 interfacePrivate->bridge.options = CFDictionaryCreateCopy(NULL, newOptions);
900
901 // set [auto] display name from options
902 if ((interfacePrivate->localized_name == NULL) &&
903 CFDictionaryGetValueIfPresent(newOptions,
904 CFSTR("__AUTO__"),
905 (const void **)&name_auto) &&
906 isA_CFString(name_auto)) {
907 // set display name
908 interfacePrivate->localized_key = name_auto;
909 if (interfacePrivate->localized_arg1 != NULL) {
910 CFRelease(interfacePrivate->localized_arg1);
911 interfacePrivate->localized_arg1 = NULL;
912 }
913 }
914 }
915 }
916
917 return ok;
918 }
919
920
921 #pragma mark -
922 #pragma mark SCBridgeInterface management
923
924
925 #ifdef IFT_BRIDGE
926 static Boolean
927 __bridge_add_interface(int s, CFStringRef bridge_if, CFStringRef interface_if)
928 {
929 struct ifbreq breq;
930 struct ifdrv ifd;
931
932 // bridge interface
933 bzero(&ifd, sizeof(ifd));
934 (void) _SC_cfstring_to_cstring(bridge_if,
935 ifd.ifd_name,
936 sizeof(ifd.ifd_name),
937 kCFStringEncodingASCII);
938 ifd.ifd_cmd = BRDGADD;
939 ifd.ifd_len = sizeof(breq);
940 ifd.ifd_data = (caddr_t)&breq;
941
942 // new bridge member
943 bzero(&breq, sizeof(breq));
944 (void) _SC_cfstring_to_cstring(interface_if,
945 breq.ifbr_ifsname,
946 sizeof(breq.ifbr_ifsname),
947 kCFStringEncodingASCII);
948
949 // add new bridge member
950 if (ioctl(s, SIOCSDRVSPEC, (caddr_t)&ifd) == -1) {
951 _SCErrorSet(errno);
952 SC_log(LOG_ERR, "could not add interface \"%@\" to bridge \"%@\": %s",
953 interface_if,
954 bridge_if,
955 strerror(errno));
956 return FALSE;
957 }
958
959 SC_log(LOG_INFO, "%@: added bridge member: %@", bridge_if, interface_if);
960 return TRUE;
961 }
962
963
964 static Boolean
965 __bridge_remove_interface(int s, CFStringRef bridge_if, CFStringRef interface_if)
966 {
967 struct ifbreq breq;
968 struct ifdrv ifd;
969
970 // bridge interface
971 bzero(&ifd, sizeof(ifd));
972 (void) _SC_cfstring_to_cstring(bridge_if,
973 ifd.ifd_name,
974 sizeof(ifd.ifd_name),
975 kCFStringEncodingASCII);
976 ifd.ifd_cmd = BRDGDEL;
977 ifd.ifd_len = sizeof(breq);
978 ifd.ifd_data = (caddr_t)&breq;
979
980 // bridge member to remove
981 bzero(&breq, sizeof(breq));
982 (void) _SC_cfstring_to_cstring(interface_if,
983 breq.ifbr_ifsname,
984 sizeof(breq.ifbr_ifsname),
985 kCFStringEncodingASCII);
986
987 // remove bridge member
988 if (ioctl(s, SIOCSDRVSPEC, (caddr_t)&ifd) == -1) {
989 _SCErrorSet(errno);
990 SC_log(LOG_ERR, "could not remove interface \"%@\" from bridge \"%@\": %s",
991 interface_if,
992 bridge_if,
993 strerror(errno));
994 return FALSE;
995 }
996
997 SC_log(LOG_INFO, "%@: removed bridge member: %@", bridge_if, interface_if);
998 return TRUE;
999 }
1000
1001
1002 static Boolean
1003 __bridge_set_mac(int s, CFStringRef bridge_if, CFDataRef macAddr)
1004 {
1005 struct ifreq ifr;
1006
1007 bzero(&ifr, sizeof(ifr));
1008 (void) _SC_cfstring_to_cstring(bridge_if,
1009 ifr.ifr_name,
1010 sizeof(ifr.ifr_name),
1011 kCFStringEncodingASCII);
1012 ifr.ifr_addr.sa_len = CFDataGetLength(macAddr);
1013 if (ifr.ifr_addr.sa_len > sizeof(ifr.ifr_addr.sa_data)) {
1014 _SCErrorSet(kSCStatusInvalidArgument);
1015 SC_log(LOG_ERR, "%@: maformed MAC address (%d > %lu)",
1016 bridge_if,
1017 ifr.ifr_addr.sa_len,
1018 sizeof(ifr.ifr_addr.sa_data));
1019 return FALSE;
1020 }
1021 CFDataGetBytes(macAddr, CFRangeMake(0, ifr.ifr_addr.sa_len), (UInt8 *)ifr.ifr_addr.sa_data);
1022
1023 if (ioctl(s, SIOCSIFLLADDR, &ifr) == -1) {
1024 _SCErrorSet(errno);
1025 SC_log(LOG_ERR, "%@: could not set MAC address: %s",
1026 bridge_if,
1027 strerror(errno));
1028 return FALSE;
1029 }
1030
1031 SC_log(LOG_INFO, "%@: updated MAC address: %{ private }@", bridge_if, macAddr);
1032 return TRUE;
1033 }
1034 #endif // IFT_BRIDGE
1035
1036
1037 Boolean
1038 _SCBridgeInterfaceUpdateConfiguration(SCPreferencesRef prefs)
1039 {
1040 #ifdef IFT_BRIDGE
1041 CFArrayRef active = NULL;
1042 CFArrayRef config = NULL;
1043 CFIndex i;
1044 CFIndex nActive;
1045 CFIndex nConfig;
1046 Boolean ok = TRUE;
1047 int s = -1;
1048
1049 if (prefs == NULL) {
1050 _SCErrorSet(kSCStatusInvalidArgument);
1051 return FALSE;
1052 }
1053
1054 /* configured Bridges */
1055 config = SCBridgeInterfaceCopyAll(prefs);
1056 nConfig = (config != NULL) ? CFArrayGetCount(config) : 0;
1057
1058 /* active Bridges */
1059 active = _SCBridgeInterfaceCopyActive();
1060 nActive = (active != NULL) ? CFArrayGetCount(active) : 0;
1061
1062 /*
1063 * remove any no-longer-configured bridge interfaces and
1064 * any members associated with a bridge that are no longer
1065 * associated with a bridge.
1066 */
1067 for (i = 0; i < nActive; i++) {
1068 SCBridgeInterfaceRef a_bridge;
1069 CFStringRef a_bridge_if;
1070 CFIndex j;
1071 Boolean found = FALSE;
1072
1073 a_bridge = CFArrayGetValueAtIndex(active, i);
1074 a_bridge_if = SCNetworkInterfaceGetBSDName(a_bridge);
1075
1076 for (j = 0; j < nConfig; j++) {
1077 SCBridgeInterfaceRef c_bridge;
1078 CFStringRef c_bridge_if;
1079
1080 c_bridge = CFArrayGetValueAtIndex(config, j);
1081 c_bridge_if = SCNetworkInterfaceGetBSDName(c_bridge);
1082
1083 if (CFEqual(a_bridge_if, c_bridge_if)) {
1084 CFIndex a;
1085 CFArrayRef a_bridge_interfaces;
1086 CFIndex a_count;
1087 CFArrayRef c_bridge_interfaces;
1088 CFIndex c_count;
1089
1090 c_bridge_interfaces = SCBridgeInterfaceGetMemberInterfaces(c_bridge);
1091 c_count = (c_bridge_interfaces != NULL) ? CFArrayGetCount(c_bridge_interfaces) : 0;
1092
1093 a_bridge_interfaces = SCBridgeInterfaceGetMemberInterfaces(a_bridge);
1094 a_count = (a_bridge_interfaces != NULL) ? CFArrayGetCount(a_bridge_interfaces) : 0;
1095
1096 for (a = 0; a < a_count; a++) {
1097 SCNetworkInterfaceRef a_interface;
1098 CFStringRef a_interface_if;
1099
1100 a_interface = CFArrayGetValueAtIndex(a_bridge_interfaces, a);
1101 if ((c_count == 0) ||
1102 !CFArrayContainsValue(c_bridge_interfaces,
1103 CFRangeMake(0, c_count),
1104 a_interface)) {
1105 /*
1106 * if this member is no longer part
1107 * of the bridge.
1108 */
1109 if (s == -1) {
1110 s = inet_dgram_socket();
1111 if (s == -1) {
1112 _SCErrorSet(errno);
1113 ok = FALSE;
1114 goto done;
1115 }
1116 }
1117
1118 a_interface_if = SCNetworkInterfaceGetBSDName(a_interface);
1119 if (!__bridge_remove_interface(s, a_bridge_if, a_interface_if)) {
1120 ok = FALSE;
1121 }
1122 }
1123 }
1124
1125 found = TRUE;
1126 break;
1127 }
1128 }
1129
1130 if (!found) {
1131 /*
1132 * if this interface is no longer configured
1133 */
1134 if (s == -1) {
1135 s = inet_dgram_socket();
1136 if (s == -1) {
1137 _SCErrorSet(errno);
1138 ok = FALSE;
1139 goto done;
1140 }
1141 }
1142
1143 if (!__destroyInterface(s, a_bridge_if)) {
1144 _SCErrorSet(errno);
1145 ok = FALSE;
1146 }
1147 }
1148 }
1149
1150 /*
1151 * add any newly-configured bridge interfaces and add any
1152 * members that should now be associated with the bridge.
1153 */
1154 for (i = 0; i < nConfig; i++) {
1155 SCBridgeInterfaceRef c_bridge;
1156 CFArrayRef c_bridge_interfaces;
1157 CFStringRef c_bridge_if;
1158 CFIndex c_count;
1159 Boolean found = FALSE;
1160 CFIndex j;
1161 Boolean setMAC = FALSE;
1162
1163 c_bridge = CFArrayGetValueAtIndex(config, i);
1164 c_bridge_if = SCNetworkInterfaceGetBSDName(c_bridge);
1165 c_bridge_interfaces = SCBridgeInterfaceGetMemberInterfaces(c_bridge);
1166 c_count = (c_bridge_interfaces != NULL) ? CFArrayGetCount(c_bridge_interfaces) : 0;
1167
1168 for (j = 0; j < nActive; j++) {
1169 SCBridgeInterfaceRef a_bridge;
1170 CFArrayRef a_bridge_interfaces;
1171 CFStringRef a_bridge_if;
1172 CFIndex a_count;
1173
1174 a_bridge = CFArrayGetValueAtIndex(active, j);
1175 a_bridge_if = SCNetworkInterfaceGetBSDName(a_bridge);
1176 a_bridge_interfaces = SCBridgeInterfaceGetMemberInterfaces(a_bridge);
1177 a_count = (a_bridge_interfaces != NULL) ? CFArrayGetCount(a_bridge_interfaces) : 0;
1178
1179 if (CFEqual(c_bridge_if, a_bridge_if)) {
1180 CFIndex c;
1181
1182 found = TRUE;
1183
1184 if (_SC_CFEqual(c_bridge_interfaces, a_bridge_interfaces)) {
1185 break; // if no change
1186 }
1187
1188 if (s == -1) {
1189 s = inet_dgram_socket();
1190 if (s == -1) {
1191 _SCErrorSet(errno);
1192 ok = FALSE;
1193 goto done;
1194 }
1195 }
1196
1197 /*
1198 * ensure that the first member of the bridge matches, if
1199 * not then we remove all current members and add them
1200 * back in the preferred order.
1201 */
1202 if ((c_count > 0) &&
1203 (a_count > 0) &&
1204 !CFEqual(CFArrayGetValueAtIndex(c_bridge_interfaces, 0),
1205 CFArrayGetValueAtIndex(a_bridge_interfaces, 0))) {
1206 CFIndex a;
1207
1208 for (a = 0; a < a_count; a++) {
1209 SCNetworkInterfaceRef a_interface;
1210 CFStringRef a_interface_if;
1211
1212 a_interface = CFArrayGetValueAtIndex(a_bridge_interfaces, a);
1213 if (!CFArrayContainsValue(c_bridge_interfaces,
1214 CFRangeMake(0, c_count),
1215 a_interface)) {
1216 continue; // if already removed
1217 }
1218
1219 a_interface_if = SCNetworkInterfaceGetBSDName(a_interface);
1220 if (!__bridge_remove_interface(s, a_bridge_if, a_interface_if)) {
1221 ok = FALSE;
1222 }
1223 }
1224
1225 a_count = 0; // all active members have been removed
1226 }
1227
1228 if (a_count == 0) {
1229 setMAC = TRUE;
1230 }
1231
1232 /*
1233 * add any members which are not currently associated
1234 * with the bridge interface.
1235 */
1236 for (c = 0; c < c_count; c++) {
1237 SCNetworkInterfaceRef c_interface;
1238 SCNetworkInterfacePrivateRef c_interfacePrivate;
1239 CFStringRef c_interface_if;
1240
1241 c_interface = CFArrayGetValueAtIndex(c_bridge_interfaces, c);
1242 if ((a_count == 0) ||
1243 !CFArrayContainsValue(a_bridge_interfaces,
1244 CFRangeMake(0, a_count),
1245 c_interface)) {
1246 /*
1247 * check if this member interface can be added to a bridge.
1248 */
1249 c_interfacePrivate = (SCNetworkInterfacePrivateRef)c_interface;
1250 if (!c_interfacePrivate->supportsBridge) {
1251 // if member not supported
1252 continue;
1253 }
1254
1255 /*
1256 * if this is the first member interface, set the MAC address
1257 * of the bridge.
1258 */
1259 if (setMAC) {
1260 CFDataRef macAddr;
1261
1262 macAddr = _SCNetworkInterfaceGetHardwareAddress(c_interface);
1263 if (!__bridge_set_mac(s, c_bridge_if, macAddr)) {
1264 // if bridge MAC could not be set
1265 ok = FALSE;
1266 }
1267 setMAC = FALSE;
1268 }
1269
1270 /*
1271 * add the member interface to the bridge.
1272 */
1273 c_interface_if = SCNetworkInterfaceGetBSDName(c_interface);
1274 if (!__bridge_add_interface(s, c_bridge_if, c_interface_if)) {
1275 // if member could not be added
1276 ok = FALSE;
1277 }
1278 }
1279 }
1280
1281 break;
1282 }
1283 }
1284
1285 if (!found) {
1286 CFIndex c;
1287
1288 if (s == -1) {
1289 s = inet_dgram_socket();
1290 if (s == -1) {
1291 _SCErrorSet(errno);
1292 ok = FALSE;
1293 goto done;
1294 }
1295 }
1296
1297 /*
1298 * establish the new bridge interface.
1299 */
1300 if (!__createInterface(s, c_bridge_if)) {
1301 _SCErrorSet(errno);
1302 ok = FALSE;
1303 continue;
1304 }
1305
1306 setMAC = TRUE;
1307
1308 /*
1309 * add the member interfaces
1310 */
1311 for (c = 0; c < c_count; c++) {
1312 SCNetworkInterfaceRef c_interface;
1313 SCNetworkInterfacePrivateRef c_interfacePrivate;
1314 CFStringRef c_interface_if;
1315
1316 c_interface = CFArrayGetValueAtIndex(c_bridge_interfaces, c);
1317 c_interfacePrivate = (SCNetworkInterfacePrivateRef)c_interface;
1318 if (!c_interfacePrivate->supportsBridge) {
1319 // if member not supported
1320 continue;
1321 }
1322
1323 /*
1324 * if this is the first member interface, set the MAC address
1325 * of the bridge.
1326 */
1327 if (setMAC) {
1328 CFDataRef macAddr;
1329
1330 macAddr = _SCNetworkInterfaceGetHardwareAddress(c_interface);
1331 if (!__bridge_set_mac(s, c_bridge_if, macAddr)) {
1332 // if bridge MAC could not be set
1333 ok = FALSE;
1334 }
1335 setMAC = FALSE;
1336 }
1337
1338 /*
1339 * add the member interface to the bridge.
1340 */
1341 c_interface_if = SCNetworkInterfaceGetBSDName(c_interface);
1342 if (!__bridge_add_interface(s, c_bridge_if, c_interface_if)) {
1343 // if member could not be added
1344 ok = FALSE;
1345 }
1346 }
1347 }
1348 }
1349
1350 done :
1351
1352 if (active != NULL) CFRelease(active);
1353 if (config != NULL) CFRelease(config);
1354 if (s != -1) (void) close(s);
1355
1356 return ok;
1357 #else // IFT_BRIDGE
1358 return TRUE;
1359 #endif // IFT_BRIDGE
1360 }
mirror of configd