/*
- * Copyright (c) 2004-2016 Apple Inc. All rights reserved.
+ * Copyright (c) 2004-2019 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
*/
-#include <Availability.h>
#include <TargetConditionals.h>
#include <CoreFoundation/CoreFoundation.h>
#include <CoreFoundation/CFRuntime.h>
#include "dy_framework.h"
-#ifndef kIODeviceSupportsHoldKey
-#define kIODeviceSupportsHoldKey "V92Modem"
-#endif
-
#ifndef kPCIThunderboltString
#define kPCIThunderboltString "PCI-Thunderbolt"
#endif
+#if TARGET_OS_OSX
+#ifndef kUSBSupportsIPhoneOS
+#define kUSBSupportsIPhoneOS "SupportsIPhoneOS"
+#endif // !kUSBSupportsIPhoneOS
+#endif // TARGET_OS_OSX
+
#ifndef kIOUserEthernetInterfaceRoleKey
#define kIOUserEthernetInterfaceRoleKey "InterfaceRole"
#endif
#include <pthread.h>
#include <ifaddrs.h>
+/* CrashReporter "Application Specific Information" */
+#include <CrashReporterClient.h>
+
static CFStringRef copy_interface_string (CFBundleRef bundle, CFStringRef key, Boolean localized);
static CFStringRef __SCNetworkInterfaceCopyDescription (CFTypeRef cf);
static void __SCNetworkInterfaceDeallocate (CFTypeRef cf);
static Boolean __SCNetworkInterfaceEqual (CFTypeRef cf1, CFTypeRef cf2);
static CFHashCode __SCNetworkInterfaceHash (CFTypeRef cf);
+static void __SCNetworkInterfaceCacheAdd (CFStringRef bsdName, CFArrayRef matchingInterfaces);
+static Boolean __SCNetworkInterfaceCacheIsOpen (void);
+static CFArrayRef __SCNetworkInterfaceCacheCopy (CFStringRef bsdName);
enum {
- kSortInternalModem,
+ kSortInternalModem = 0,
kSortUSBModem,
kSortModem,
kSortBluetooth,
kSortBluetoothPAN_NAP,
kSortBluetoothPAN_U,
kSortThunderbolt,
+ kSortCarPlay,
kSortBond,
kSortBridge,
kSortVLAN,
};
+static const char *sortOrderName[] = {
+ "InternalModem",
+ "USBModem",
+ "Modem",
+ "Bluetooth",
+ "IrDA",
+ "SerialPort",
+ "WWAN",
+ "EthernetPPP",
+ "AirportPPP",
+ "Ethernet",
+ "FireWire",
+ "AirPort",
+ "OtherWireless",
+ "Tethered",
+ "WWANEthernet",
+ "BluetoothPAN_GN",
+ "BluetoothPAN_NAP",
+ "BluetoothPAN_U",
+ "Thunderbolt",
+ "CarPlay",
+ "Bond",
+ "Bridge",
+ "VLAN",
+ "Unknown"
+};
+
+
const CFStringRef kSCNetworkInterfaceType6to4 = CFSTR("6to4");
const CFStringRef kSCNetworkInterfaceTypeBluetooth = CFSTR("Bluetooth");
const CFStringRef kSCNetworkInterfaceTypeBond = CFSTR("Bond");
static CFMutableSetRef vendor_interface_types = NULL;
+// A thread-specific convenience cache of all interfaces matching a bsd name
+// Key: CFStringRef (BSD name)
+// Value: CFArrayRef (matching interfaces)
+static __thread CFMutableDictionaryRef S_interface_cache = NULL;
+
#pragma mark -
#pragma mark SCNetworkInterface configuration details
{ &kSCNetworkInterfaceTypePPTP , NULL , FALSE, doPPP, &kSCValNetInterfaceSubTypePPTP, doNone },
#pragma GCC diagnostic pop
{ &kSCNetworkInterfaceTypeSerial , &kSCEntNetModem , FALSE, doPPP, &kSCValNetInterfaceSubTypePPPSerial, doNone },
- { &kSCNetworkInterfaceTypeVLAN , &kSCEntNetEthernet , TRUE , doNone, NULL, doDNS|doIPv4|doIPv6|doProxies|doSMB },
+ { &kSCNetworkInterfaceTypeVLAN , &kSCEntNetEthernet , TRUE , doNone, &kSCValNetInterfaceSubTypePPPoE, doDNS|doIPv4|doIPv6|doProxies|doSMB },
{ &kSCNetworkInterfaceTypeVPN , &kSCEntNetVPN , FALSE, doNone, NULL, doDNS|doIPv4|doIPv6|doProxies|doSMB },
{ &kSCNetworkInterfaceTypeWWAN , &kSCEntNetModem , FALSE, doPPP, &kSCValNetInterfaceSubTypePPPSerial, doNone },
// ===================================== =================== ========== =============== ======================================= =========================================
if (interfacePrivate->hidden) {
CFStringAppendFormat(result, NULL, CFSTR(", hidden = TRUE"));
}
- if (interfacePrivate->modemIsV92) {
- CFStringAppendFormat(result, NULL, CFSTR(", v.92"));
+#if TARGET_OS_IPHONE
+ if (interfacePrivate->trustRequired) {
+ CFStringAppendFormat(result, NULL, CFSTR(", trust required = TRUE"));
}
+#endif // TARGET_OS_IPHONE
if (interfacePrivate->location != NULL) {
CFStringAppendFormat(result, NULL, CFSTR(", location = %@"), interfacePrivate->location);
}
CFStringAppendFormat(result, NULL, CFSTR(", action = %@"), interfacePrivate->configurationAction);
}
if (interfacePrivate->overrides != NULL) {
- CFStringAppendFormat(result, formatOptions, CFSTR(", overrides = %p"), interfacePrivate->overrides);
+ CFStringRef str;
+
+ str = _SCCopyDescription(interfacePrivate->overrides, formatOptions);
+ CFStringAppendFormat(result, formatOptions, CFSTR(", overrides = %@"), str);
+ CFRelease(str);
}
- CFStringAppendFormat(result, NULL, CFSTR(", order = %d"), interfacePrivate->sort_order);
+ CFStringAppendFormat(result, NULL, CFSTR(", order = %d (%s)"),
+ interfacePrivate->sort_order,
+ interfacePrivate->sort_order <= kSortUnknown ? sortOrderName[interfacePrivate->sort_order] : "?");
if (interfacePrivate->prefs != NULL) {
CFStringAppendFormat(result, NULL, CFSTR(", prefs = %p"), interfacePrivate->prefs);
}
CFComparisonResult
_SCNetworkInterfaceCompare(const void *val1, const void *val2, void *context)
{
+#pragma unused(context)
SCNetworkInterfacePrivateRef dev1 = (SCNetworkInterfacePrivateRef)val1;
SCNetworkInterfacePrivateRef dev2 = (SCNetworkInterfacePrivateRef)val2;
CFComparisonResult res = kCFCompareEqualTo;
slot_name = IORegistryEntryCreateCFProperty(interface, CFSTR("AAPL,slot-name"), NULL, 0);
if (slot_name != NULL) {
- CFIndex i;
-
slot = CFStringCreateMutable(NULL, 0);
if (isA_CFString(slot_name)) {
if (pci_slot_name != NULL) *pci_slot_name = CFStringCreateCopy(NULL, slot_name);
kCFStringEncodingUTF8);
}
- for (i = 0; i < sizeof(slot_prefixes)/sizeof(slot_prefixes[0]); i++) {
+ for (size_t i = 0; i < sizeof(slot_prefixes)/sizeof(slot_prefixes[0]); i++) {
CFIndex len;
len = CFStringGetLength(slot_prefixes[i]);
}
}
- for (i = 0; i < sizeof(slot_mappings)/sizeof(slot_mappings[0]); i++) {
+ for (size_t i = 0; i < sizeof(slot_mappings)/sizeof(slot_mappings[0]); i++) {
if (CFStringCompare(slot,
slot_mappings[i].name,
kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
if (*pci_slot_name != NULL) CFRelease(*pci_slot_name);
*pci_slot_name = parent_pci_slot_name;
} else {
- CFRelease(parent_pci_slot_name);
+ if (parent_pci_slot_name != NULL) CFRelease(parent_pci_slot_name);
}
}
static CFComparisonResult
compare_bsdNames(const void *val1, const void *val2, void *context)
{
+#pragma unused(context)
CFStringRef bsd1 = (CFStringRef)val1;
CFStringRef bsd2 = (CFStringRef)val2;
io_registry_entry_t bus,
CFDictionaryRef bus_dict)
{
+#if TARGET_OS_SIMULATOR
+#pragma unused(interfacePrivate)
+#pragma unused(interface)
+#endif // TARGET_OS_SIMULATOR
+#pragma unused(interface_dict)
+#pragma unused(controller)
+#pragma unused(controller_dict)
+#pragma unused(bus)
+#pragma unused(bus_dict)
#if !TARGET_OS_SIMULATOR
// capture USB info
- interfacePrivate->usb.name = IORegistryEntrySearchCFProperty(interface,
- kIOServicePlane,
- CFSTR(kUSBProductString),
- NULL,
- kIORegistryIterateRecursively | kIORegistryIterateParents);
- interfacePrivate->usb.vid = IORegistryEntrySearchCFProperty(interface,
- kIOServicePlane,
- CFSTR(kUSBVendorID),
- NULL,
- kIORegistryIterateRecursively | kIORegistryIterateParents);
- interfacePrivate->usb.pid = IORegistryEntrySearchCFProperty(interface,
- kIOServicePlane,
- CFSTR(kUSBProductID),
- NULL,
- kIORegistryIterateRecursively | kIORegistryIterateParents);
+ if (interfacePrivate->usb.name == NULL) {
+ interfacePrivate->usb.name = IORegistryEntrySearchCFProperty(interface,
+ kIOServicePlane,
+ CFSTR(kUSBProductString),
+ NULL,
+ kIORegistryIterateRecursively | kIORegistryIterateParents);
+ }
+ if (interfacePrivate->usb.vid == NULL) {
+ interfacePrivate->usb.vid = IORegistryEntrySearchCFProperty(interface,
+ kIOServicePlane,
+ CFSTR(kUSBVendorID),
+ NULL,
+ kIORegistryIterateRecursively | kIORegistryIterateParents);
+ }
+ if (interfacePrivate->usb.pid == NULL) {
+ interfacePrivate->usb.pid = IORegistryEntrySearchCFProperty(interface,
+ kIOServicePlane,
+ CFSTR(kUSBProductID),
+ NULL,
+ kIORegistryIterateRecursively | kIORegistryIterateParents);
+ }
#endif // !TARGET_OS_SIMULATOR
return;
CFNumberGetValue(num, kCFNumberIntType, &ift)) {
interfacePrivate->type = CFRetain(num);
} else {
- SC_log(LOG_INFO, "no interface type");
+ SC_log(LOG_INFO, "no interface type: %@", interface_dict);
return FALSE;
}
interfacePrivate->interface_type = kSCNetworkInterfaceTypeEthernet;
interfacePrivate->entity_type = kSCValNetInterfaceTypeEthernet;
interfacePrivate->sort_order = kSortBluetoothPAN_U;
+ } else if (CFEqual(val, CFSTR("CarPlay"))) {
+ interfacePrivate->interface_type = kSCNetworkInterfaceTypeEthernet;
+ interfacePrivate->entity_type = kSCValNetInterfaceTypeEthernet;
+ interfacePrivate->sort_order = kSortCarPlay;
}
}
}
}
+#if TARGET_OS_OSX
+ if (interfacePrivate->interface_type == NULL) {
+ val = IORegistryEntrySearchCFProperty(interface,
+ kIOServicePlane,
+ CFSTR(kUSBSupportsIPhoneOS),
+ NULL,
+ kIORegistryIterateRecursively | kIORegistryIterateParents);
+ if (val != NULL) {
+ if (isA_CFBoolean(val) && CFBooleanGetValue(val)) {
+ interfacePrivate->interface_type = kSCNetworkInterfaceTypeEthernet;
+ interfacePrivate->entity_type = kSCValNetInterfaceTypeEthernet;
+ interfacePrivate->sort_order = kSortTethered;
+ }
+
+ CFRelease(val);
+ }
+ }
+#endif // TARGET_OS_OSX
+
if (interfacePrivate->interface_type == NULL) {
str = IODictionaryCopyCFStringValue(bus_dict, CFSTR("name"));
if (str != NULL) {
// Modem
interfacePrivate->interface_type = kSCNetworkInterfaceTypeModem;
interfacePrivate->sort_order = kSortModem;
-
- // V.92 support
- val = IORegistryEntrySearchCFProperty(interface,
- kIOServicePlane,
- CFSTR(kIODeviceSupportsHoldKey),
- NULL,
- kIORegistryIterateRecursively | kIORegistryIterateParents);
- if (val != NULL) {
- uint32_t v92;
-
- if (isA_CFNumber(val) &&
- CFNumberGetValue(val, kCFNumberSInt32Type, &v92)) {
- interfacePrivate->modemIsV92 = (v92 == 1);
- }
- CFRelease(val);
- }
}
// Entity (Type)
CFTypeRef val;
// Keys of interest
-#if TARGET_OS_SIMULATOR || 1 // while waiting for rdar://19431723
-#else
const CFStringRef interface_dict_keys[] = {
CFSTR(kIOInterfaceType),
CFSTR(kIOBuiltin),
CFSTR(kIOSerialBSDTypeKey),
CFSTR(kIOLocation)
};
-#endif // !TARGET_OS_SIMULATOR
const CFStringRef controller_dict_keys[] = {
CFSTR(kIOFeatures),
}
}
-#if TARGET_OS_SIMULATOR || 1 // while waiting for rdar://19431723
- // get the dictionary associated with the [interface] node
- kr = IORegistryEntryCreateCFProperties(interface, &interface_dict, NULL, kNilOptions);
- if (kr != kIOReturnSuccess) {
- SC_log(LOG_INFO, "IORegistryEntryCreateCFProperties() failed, kr = 0x%x", kr);
- goto done;
- }
-#else
interface_dict = copyIORegistryProperties(interface,
interface_dict_keys,
sizeof(interface_dict_keys)/sizeof(interface_dict_keys[0]));
-#endif // !TARGET_OS_SIMULATOR
// get the controller node
kr = IORegistryEntryGetParentEntry(interface, kIOServicePlane, &controller);
interfacePrivate->hidden = TRUE;
CFRelease(val);
}
+
+#if TARGET_OS_IPHONE
+ // get TrustRequired preference
+ val = IORegistryEntrySearchCFProperty(interface,
+ kIOServicePlane,
+ kSCNetworkInterfaceTrustRequiredKey,
+ NULL,
+ kIORegistryIterateRecursively | kIORegistryIterateParents);
+ if (val != NULL) {
+ if (isA_CFBoolean(val)) {
+ interfacePrivate->trustRequired = CFBooleanGetValue(val);
+ }
+ CFRelease(val);
+ }
+#endif // TARGET_OS_IPHONE
} else {
CFRelease(interfacePrivate);
interfacePrivate = NULL;
static CFIndex
findConfiguration(CFStringRef interface_type)
{
- CFIndex i;
-
- for (i = 0; i < sizeof(configurations)/sizeof(configurations[0]); i++) {
+ for (size_t i = 0; i < sizeof(configurations)/sizeof(configurations[0]); i++) {
if (CFEqual(interface_type, *configurations[i].interface_type)) {
return i;
}
static void
__addExtendedConfigurationType(const void *key, const void *value, void *context)
{
+#pragma unused(value)
CFStringRef extendedType = (CFStringRef)key;
extendedConfigurationRef myContextRef = (extendedConfigurationRef)context;
kSCNetworkInterfaceHiddenConfigurationKey,
kCFBooleanTrue);
}
+#if TARGET_OS_IPHONE
+ if (interfacePrivate->trustRequired) {
+ CFDictionarySetValue(entity,
+ kSCNetworkInterfaceTrustRequiredKey,
+ kCFBooleanTrue);
+ }
+#endif // TARGET_OS_IPHONE
// match the "hardware" with the lowest layer
while (TRUE) {
kSCPropUserDefinedName,
SCNetworkInterfaceGetLocalizedDisplayName(interface));
- // note that this is a V.92 capable modem
- if (CFEqual(interfacePrivate->interface_type, kSCNetworkInterfaceTypeModem) &&
- interfacePrivate->modemIsV92) {
- int one = 1;
- CFNumberRef num;
-
- num = CFNumberCreate(NULL, kCFNumberIntType, &one);
- CFDictionarySetValue(entity,
- kSCPropNetInterfaceSupportsModemOnHold,
- num);
- CFRelease(num);
- }
-
return entity;
}
SCNetworkInterfaceRef
-_SCNetworkInterfaceCreateWithBSDName(CFAllocatorRef allocator,
- CFStringRef bsdName,
- UInt32 flags)
+_SCNetworkInterfaceCreateWithBSDName(CFAllocatorRef allocator,
+ CFStringRef bsdName,
+ UInt32 flags)
{
+#pragma unused(allocator)
CFMutableDictionaryRef entity = NULL;
struct ifreq ifr;
SCNetworkInterfaceRef interface;
- bzero(&ifr, sizeof(ifr));
+ memset(&ifr, 0, sizeof(ifr));
if (_SC_cfstring_to_cstring(bsdName, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII) != NULL) {
int s;
static SCNetworkInterfaceRef
-__SCNetworkInterfaceCreateWithStorageEntity (CFAllocatorRef allocator,
- CFDictionaryRef interface_entity,
- SCPreferencesRef prefs)
+__SCNetworkInterfaceCreateWithStorageEntity(CFAllocatorRef allocator,
+ CFDictionaryRef interface_entity)
{
+#pragma unused(allocator)
SCNetworkInterfacePrivateRef interfacePrivate = NULL;
CFBooleanRef active = NULL;
CFStringRef bsdName = NULL;
}
+__private_extern__
+void
+_SCNetworkInterfaceCacheOpen(void)
+{
+ if (!__SCNetworkInterfaceCacheIsOpen()) {
+ S_interface_cache = CFDictionaryCreateMutable(NULL,
+ 0,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks);
+ SC_log(LOG_DEBUG, "SCNetworkInterface cache (%p): open", S_interface_cache);
+ }
+}
+
+
+__private_extern__
+void
+_SCNetworkInterfaceCacheClose(void)
+{
+ if (__SCNetworkInterfaceCacheIsOpen()) {
+ SC_log(LOG_DEBUG, "SCNetworkInterface cache (%p): close", S_interface_cache);
+ CFRelease(S_interface_cache);
+ S_interface_cache = NULL;
+ }
+}
+
+
+static void
+__SCNetworkInterfaceCacheAdd(CFStringRef bsdName, CFArrayRef matchingInterfaces)
+{
+ if (__SCNetworkInterfaceCacheIsOpen() &&
+ bsdName != NULL &&
+ matchingInterfaces != NULL) {
+ SC_log(LOG_DEBUG, "SCNetworkInterface cache (%p): add %@", S_interface_cache, bsdName);
+ CFDictionaryAddValue(S_interface_cache, bsdName, matchingInterfaces);
+ }
+}
+
+
+static inline Boolean
+__SCNetworkInterfaceCacheIsOpen(void)
+{
+ return (S_interface_cache != NULL);
+}
+
+
+static CFArrayRef
+__SCNetworkInterfaceCacheCopy(CFStringRef bsdName)
+{
+ if (__SCNetworkInterfaceCacheIsOpen() &&
+ bsdName != NULL) {
+ CFArrayRef matchingInterfaces = CFDictionaryGetValue(S_interface_cache, bsdName);
+ if (matchingInterfaces) {
+ CFRetain(matchingInterfaces);
+ SC_log(LOG_DEBUG, "SCNetworkInterface cache (%p): copy w/ match for %@", S_interface_cache, bsdName);
+ } else {
+ SC_log(LOG_DEBUG, "SCNetworkInterface cache (%p): copy w/ no match for %@", S_interface_cache, bsdName);
+ }
+
+ return matchingInterfaces;
+ }
+
+ return NULL;
+}
+
+
SCNetworkInterfaceRef
-_SCNetworkInterfaceCreateWithEntity(CFAllocatorRef allocator,
- CFDictionaryRef interface_entity,
- SCNetworkServiceRef service)
+_SCNetworkInterfaceCreateWithEntity(CFAllocatorRef allocator,
+ CFDictionaryRef interface_entity,
+ SCNetworkServiceRef service)
{
+#pragma unused(allocator)
SCNetworkInterfacePrivateRef interfacePrivate = NULL;
CFStringRef ifDevice;
CFStringRef ifName = NULL;
if (service != NULL) {
servicePref = ((SCNetworkServicePrivateRef)service)->prefs;
useSystemInterfaces = ((__SCPreferencesUsingDefaultPrefs(servicePref)) &&
- (__SCPreferencesGetLimitSCNetworkConfiguration(servicePref) == FALSE));
+ (!__SCPreferencesGetLimitSCNetworkConfiguration(servicePref)));
}
ifType = CFDictionaryGetValue(interface_entity, kSCPropNetInterfaceType);
goto done;
}
if (useSystemInterfaces) {
- if (_SC_cfstring_to_cstring(ifDevice, bsdName, sizeof(bsdName), kCFStringEncodingASCII) == NULL) {
- goto done;
- }
+ // Check to see if we already have the info in the cache
+ matching_interfaces = __SCNetworkInterfaceCacheCopy(ifDevice);
+ if (matching_interfaces == NULL) {
+ if (_SC_cfstring_to_cstring(ifDevice, bsdName, sizeof(bsdName), kCFStringEncodingASCII) == NULL) {
+ goto done;
+ }
- matching = IOBSDNameMatching(masterPort, 0, bsdName);
- if (matching == NULL) {
- goto done;
+ matching = IOBSDNameMatching(masterPort, 0, bsdName);
+ if (matching == NULL) {
+ goto done;
+ }
+ matching_interfaces = findMatchingInterfaces(matching,
+ processNetworkInterface,
+ kSCNetworkInterfaceHiddenInterfaceKey,
+ TRUE);
+
+ __SCNetworkInterfaceCacheAdd(ifDevice, matching_interfaces);
+ CFRelease(matching);
}
- matching_interfaces = findMatchingInterfaces(matching,
- processNetworkInterface,
- kSCNetworkInterfaceHiddenInterfaceKey,
- TRUE);
- CFRelease(matching);
}
} else if (CFEqual(ifType, kSCValNetInterfaceTypePPP)) {
if (CFEqual(ifSubType, kSCValNetInterfaceSubTypePPPSerial)) {
(((virtualInterface = findBridgeInterface(servicePref, ifDevice)) != NULL) ||
#if !TARGET_OS_IPHONE
((virtualInterface = findBondInterface(servicePref, ifDevice)) != NULL) ||
-#endif
+#endif // !TARGET_OS_IPHONE
((virtualInterface = findVLANInterface(servicePref, ifDevice)) != NULL))) {
CFRelease(interfacePrivate);
interfacePrivate = (SCNetworkInterfacePrivateRef)virtualInterface;
if (CFDictionaryContainsKey(interface_entity, kSCNetworkInterfaceHiddenConfigurationKey)) {
interfacePrivate->hidden = TRUE;
}
+#if TARGET_OS_IPHONE
+ if (CFDictionaryContainsKey(interface_entity, kSCNetworkInterfaceTrustRequiredKey)) {
+ interfacePrivate->trustRequired = TRUE;
+ }
+#endif // TARGET_OS_IPHONE
}
if (service != NULL) {
__private_extern__
CFArrayRef
-__SCNetworkInterfaceCopyAll_IONetworkInterface(void)
+__SCNetworkInterfaceCopyAll_IONetworkInterface(Boolean keep_pre_configured)
{
CFDictionaryRef matching;
CFArrayRef new_interfaces;
new_interfaces = findMatchingInterfaces(matching,
processNetworkInterface,
kSCNetworkInterfaceHiddenInterfaceKey,
- FALSE);
+ keep_pre_configured);
CFRelease(matching);
return new_interfaces;
#if !TARGET_OS_IPHONE
static void
-addBTPANInterface(SCPreferencesRef prefs, CFMutableArrayRef all_interfaces)
+addBTPANInterface(CFMutableArrayRef all_interfaces)
{
CFIndex i;
SCNetworkInterfaceRef interface;
static void
__waitForInterfaces()
{
- CFStringRef key;
+ CFStringRef key = NULL;
CFArrayRef keys;
Boolean ok;
- SCDynamicStoreRef store;
+ SCDynamicStoreRef store = NULL;
+
+ CRSetCrashLogMessage("Waiting for IOKit to quiesce (or timeout)");
store = SCDynamicStoreCreate(NULL, CFSTR("SCNetworkInterfaceCopyAll"), NULL, NULL);
if (store == NULL) {
- return;
+ goto done;
}
key = SCDynamicStoreKeyCreate(NULL, CFSTR("%@" "InterfaceNamer"), kSCDynamicStoreDomainPlugin);
done :
- CFRelease(key);
- CFRelease(store);
+ CRSetCrashLogMessage(NULL);
+
+ if (key != NULL) CFRelease(key);
+ if (store != NULL) CFRelease(store);
return;
}
all_interfaces = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
// get Ethernet, Firewire, Thunderbolt, and AirPort interfaces
- new_interfaces = __SCNetworkInterfaceCopyAll_IONetworkInterface();
+ new_interfaces = __SCNetworkInterfaceCopyAll_IONetworkInterface(FALSE);
if (new_interfaces != NULL) {
add_interfaces(all_interfaces, new_interfaces);
CFRelease(new_interfaces);
#if !TARGET_OS_IPHONE
// add BT-PAN interface
- addBTPANInterface(prefs, all_interfaces);
+ addBTPANInterface(all_interfaces);
#endif // !TARGET_OS_IPHONE
if (temp_preferences) CFRelease(prefs);
parentPrivate->hidden = childPrivate->hidden;
+#if TARGET_OS_IPHONE
+ parentPrivate->trustRequired = childPrivate->trustRequired;
+#endif // TARGET_OS_IPHONE
+
if (childPrivate->overrides != NULL) {
parentPrivate->overrides = CFDictionaryCreateMutableCopy(NULL, 0, childPrivate->overrides);
}
(interfacePrivate->addressString == NULL)) {
uint8_t *bp;
char *cp;
- CFIndex n;
+ size_t n;
char mac[sizeof("xx:xx:xx:xx:xx:xx:xx:xx")];
char *mac_p = mac;
knownStrKey,
localized);
-#if TARGET_OS_IPHONE
+#if TARGET_OS_IPHONE
/* ...and we want to know about it! */
_SC_crash("Failed to retrieve interface string", NULL, NULL);
-#endif //TARGET_OS_IPHONE
+#endif //TARGET_OS_IPHONE
reported = TRUE;
}
__private_extern__
-CFDictionaryRef
+CFPropertyListRef
__SCNetworkInterfaceGetTemplateOverrides(SCNetworkInterfaceRef interface, CFStringRef overrideType)
{
SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)interface;
- CFDictionaryRef overrides = NULL;
+ CFPropertyListRef overrides = NULL;
if (interfacePrivate->overrides != NULL) {
overrides = CFDictionaryGetValue(interfacePrivate->overrides, overrideType);
#pragma mark SCNetworkInterface [Refresh Configuration] API
-#ifndef kSCEntNetRefreshConfiguration
-#define kSCEntNetRefreshConfiguration CFSTR("RefreshConfiguration")
-#endif // kSCEntNetRefreshConfiguration
-
Boolean
_SCNetworkInterfaceForceConfigurationRefresh(CFStringRef ifName)
{
}
+#if !TARGET_OS_IPHONE
Boolean
SCNetworkInterfaceRefreshConfiguration(CFStringRef ifName)
{
return _SCNetworkInterfaceForceConfigurationRefresh(ifName);
}
+#endif // !TARGET_OS_IPHONE
#pragma mark -
return ok;
}
+#pragma mark -
+#pragma mark SCNetworkInterface [Advisory] SPIs
+#if TARGET_OS_SIMULATOR
+Boolean
+SCNetworkInterfaceSetAdvisory(SCNetworkInterfaceRef interface,
+ SCNetworkInterfaceAdvisory advisory,
+ CFStringRef reason)
+{
+#pragma unused(interface)
+#pragma unused(advisory)
+#pragma unused(reason)
+ return (FALSE);
+}
+
+Boolean
+SCNetworkInterfaceAdvisoryIsSet(SCNetworkInterfaceRef interface)
+{
+#pragma unused(interface)
+ return (FALSE);
+}
+
+CFStringRef
+SCNetworkInterfaceCopyAdvisoryNotificationKey(SCNetworkInterfaceRef interface)
+{
+#pragma unused(interface)
+ return (NULL);
+}
+
+#else /* TARGET_OS_SIMULATOR */
+Boolean
+SCNetworkInterfaceSetAdvisory(SCNetworkInterfaceRef interface,
+ SCNetworkInterfaceAdvisory advisory,
+ CFStringRef reason)
+{
+ IPMonitorControlRef control;
+ SCNetworkInterfacePrivateRef interfacePrivate =
+ (SCNetworkInterfacePrivateRef)interface;
+ CFStringRef ifName;
+
+ ifName = SCNetworkInterfaceGetBSDName(interface);
+ if (ifName == NULL) {
+ _SCErrorSet(kSCStatusInvalidArgument);
+ return (FALSE);
+ }
+ control = interfacePrivate->IPMonitorControl;
+ if (control == NULL) {
+ control = IPMonitorControlCreate();
+ if (control == NULL) {
+ _SCErrorSet(kSCStatusFailed);
+ return (FALSE);
+ }
+ interfacePrivate->IPMonitorControl = control;
+ }
+ return IPMonitorControlSetInterfaceAdvisory(control,
+ ifName,
+ advisory,
+ reason);
+}
+
+Boolean
+SCNetworkInterfaceAdvisoryIsSet(SCNetworkInterfaceRef interface)
+{
+ IPMonitorControlRef control;
+ SCNetworkInterfacePrivateRef interfacePrivate =
+ (SCNetworkInterfacePrivateRef)interface;
+ CFStringRef ifName;
+
+ ifName = SCNetworkInterfaceGetBSDName(interface);
+ if (ifName == NULL) {
+ _SCErrorSet(kSCStatusInvalidArgument);
+ return (FALSE);
+ }
+ control = interfacePrivate->IPMonitorControl;
+ if (control == NULL) {
+ control = IPMonitorControlCreate();
+ if (control == NULL) {
+ _SCErrorSet(kSCStatusFailed);
+ return (FALSE);
+ }
+ interfacePrivate->IPMonitorControl = control;
+ }
+ return IPMonitorControlInterfaceAdvisoryIsSet(control, ifName);
+}
+
+CFStringRef
+SCNetworkInterfaceCopyAdvisoryNotificationKey(SCNetworkInterfaceRef interface)
+{
+ CFStringRef ifName;
+
+ ifName = SCNetworkInterfaceGetBSDName(interface);
+ if (ifName == NULL) {
+ _SCErrorSet(kSCStatusInvalidArgument);
+ return (NULL);
+ }
+ return IPMonitorControlCopyInterfaceAdvisoryNotificationKey(ifName);
+}
+#endif /* TARGET_OS_SIMULATOR */
#pragma mark -
#pragma mark SCNetworkInterface [InterfaceNamer] SPIs
CFStringRef bsdName = SCNetworkInterfaceGetBSDName(interface);
struct ifreq ifr;
- bzero(&ifr, sizeof(ifr));
+ memset(&ifr, 0, sizeof(ifr));
if ((bsdName != NULL) &&
_SC_cfstring_to_cstring(bsdName, ifr.ifr_name, sizeof(ifr.ifr_name), kCFStringEncodingASCII) != NULL) {
int s;
}
+Boolean
+_SCNetworkInterfaceIsTrustRequired(SCNetworkInterfaceRef interface)
+{
+ SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)interface;
+
+ return interfacePrivate->trustRequired;
+}
+
+
#pragma mark -
#pragma mark SCNetworkInterface SPIs
-#if !TARGET_OS_EMBEDDED
+#if TARGET_OS_OSX
SCNetworkInterfaceRef
_SCNetworkInterfaceCopyBTPANInterface(void)
return interface;
}
-#endif // !TARGET_OS_EMBEDDED
+#endif // TARGET_OS_OSX
CFStringRef
Boolean
_SCNetworkInterfaceIsApplePreconfigured(SCNetworkInterfaceRef interface)
{
-#if !TARGET_OS_SIMULATOR
+#if TARGET_OS_SIMULATOR
+#pragma unused(interface)
+#else // TARGET_OS_SIMULATOR
SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)interface;
- if (!interfacePrivate->hidden) {
+ if (!_SCNetworkInterfaceIsHiddenConfiguration(interface)) {
// if not HiddenConfiguration
return FALSE;
}
return FALSE;
}
- if (interfacePrivate->builtin) {
+ if (_SCNetworkInterfaceIsBuiltin(interface)) {
// if built-in (and overrides are present)
return TRUE;
}
+ if (_SCNetworkInterfaceIsCarPlay(interface)) {
+ // if CarPlay (and overrides are present)
+ return TRUE;
+ }
+
if (isA_CFNumber(interfacePrivate->usb.vid)) {
int vid;
return TRUE;
}
}
-#endif // !TARGET_OS_SIMULATOR
+#endif // TARGET_OS_SIMULATOR
return FALSE;
}
Boolean
-_SCNetworkInterfaceIsHiddenConfiguration(SCNetworkInterfaceRef interface)
+_SCNetworkInterfaceIsCarPlay(SCNetworkInterfaceRef interface)
{
SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)interface;
- return interfacePrivate->hidden;
+ return (interfacePrivate->sort_order == kSortCarPlay);
}
Boolean
-_SCNetworkInterfaceIsModemV92(SCNetworkInterfaceRef interface)
+_SCNetworkInterfaceIsHiddenConfiguration(SCNetworkInterfaceRef interface)
{
SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)interface;
- return interfacePrivate->modemIsV92;
+ return interfacePrivate->hidden;
}
SCPreferencesRef prefs,
CFStringRef serviceID)
{
+#pragma unused(allocator)
SCNetworkInterfacePrivateRef oldPrivate = (SCNetworkInterfacePrivateRef)interface;
SCNetworkInterfacePrivateRef newPrivate;
newPrivate->configurationAction = CFRetain(oldPrivate->configurationAction);
}
newPrivate->hidden = oldPrivate->hidden;
+#if TARGET_OS_IPHONE
+ newPrivate->trustRequired = oldPrivate->trustRequired;
+#endif // TARGET_OS_IPHONE
if (oldPrivate->location != NULL) {
newPrivate->location = CFRetain(oldPrivate->location);
}
if (oldPrivate->overrides != NULL) {
newPrivate->overrides = CFDictionaryCreateMutableCopy(NULL, 0, oldPrivate->overrides);
}
- newPrivate->modemIsV92 = oldPrivate->modemIsV92;
if (oldPrivate->type != NULL) {
newPrivate->type = CFRetain(oldPrivate->type);
}
SCNetworkServicePrimaryRank
SCNetworkInterfaceGetPrimaryRank(SCNetworkInterfaceRef interface)
{
+#pragma unused(interface)
return (kSCNetworkServicePrimaryRankDefault);
}
SCNetworkInterfaceSetPrimaryRank(SCNetworkInterfaceRef interface,
SCNetworkServicePrimaryRank newRank)
{
+#pragma unused(interface)
+#pragma unused(newRank)
_SCErrorSet(kSCStatusInvalidArgument);
return (FALSE);
}
Boolean
SCNetworkInterfaceGetDisableUntilNeeded(SCNetworkInterfaceRef interface)
{
+#pragma unused(interface)
return (FALSE);
}
Boolean
__SCNetworkInterfaceSetDisableUntilNeededValue(SCNetworkInterfaceRef interface, CFTypeRef disable)
{
+#pragma unused(interface)
+#pragma unused(disable)
return (FALSE);
}
Boolean
SCNetworkInterfaceSetDisableUntilNeeded(SCNetworkInterfaceRef interface, Boolean disable)
{
+#pragma unused(interface)
+#pragma unused(disable)
_SCErrorSet(kSCStatusInvalidArgument);
return (FALSE);
}
__private_extern__
CFArrayRef // SCNetworkInterfaceRef
-__SCNetworkInterfaceCopyStoredWithPreferences (SCPreferencesRef ni_prefs)
+__SCNetworkInterfaceCopyStoredWithPreferences(SCPreferencesRef ni_prefs)
{
- CFMutableArrayRef interfaceList = NULL;
+ CFStringRef defaultNetworkInterfacePath = NULL;
CFArrayRef if_list;
- SCNetworkInterfaceRef interfaceNamer = NULL;
- CFStringRef defaultNetworkInterfacePath = NULL;
+ CFMutableArrayRef interfaceList = NULL;
+ SCNetworkInterfaceRef interfaceNamer = NULL;
/* initialize runtime */
pthread_once(&initialized, __SCNetworkInterfaceInitialize);
}
if_list = SCPreferencesGetValue(ni_prefs, INTERFACES);
-
- if (isA_CFArray(if_list) != NULL) {
+ if (isA_CFArray(if_list)) {
CFIndex i;
CFIndex n = CFArrayGetCount(if_list);
dict = CFArrayGetValueAtIndex(if_list, i);
if (isA_CFDictionary(dict) != NULL) {
- interfaceNamer = __SCNetworkInterfaceCreateWithStorageEntity(NULL, dict, ni_prefs);
+ interfaceNamer = __SCNetworkInterfaceCreateWithStorageEntity(NULL, dict);
if (interfaceNamer != NULL) {
CFArrayAppendValue(interfaceList, interfaceNamer);
continue;
}
if (CFEqual(bsdName, tmp_bsdName)) {
- interface = __SCNetworkInterfaceCreateWithStorageEntity(allocator, dict, ni_prefs);
+ interface = __SCNetworkInterfaceCreateWithStorageEntity(allocator, dict);
break;
}
}
projects / apple / configd.git / blobdiff