__private_extern__ Boolean
__setPrefsConfiguration(SCPreferencesRef prefs,
CFStringRef path,
CFDictionaryRef config,
Boolean keepInactive)
{
CFDictionaryRef curConfig;
CFMutableDictionaryRef newConfig = NULL;
Boolean ok;
if ((config != NULL) && !isA_CFDictionary(config)) {
_SCErrorSet(kSCStatusInvalidArgument);
return FALSE;
}
curConfig = SCPreferencesPathGetValue(prefs, path);
if (config != NULL) {
newConfig = CFDictionaryCreateMutableCopy(NULL, 0, config);
}
if (keepInactive) {
if (config == NULL) {
newConfig = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
if (isA_CFDictionary(curConfig) && CFDictionaryContainsKey(curConfig, kSCResvInactive)) {
// if currently disabled
CFDictionarySetValue(newConfig, kSCResvInactive, kCFBooleanTrue);
} else {
// if currently enabled
CFDictionaryRemoveValue(newConfig, kSCResvInactive);
}
}
// set new configuration
if (_SC_CFEqual(curConfig, newConfig)) {
// if no change
if (newConfig != NULL) CFRelease(newConfig);
ok = TRUE;
} else if (newConfig != NULL) {
// if new configuration (or we are preserving a disabled state)
ok = SCPreferencesPathSetValue(prefs, path, newConfig);
CFRelease(newConfig);
} else {
ok = SCPreferencesPathRemoveValue(prefs, path);
if (!ok && (SCError() == kSCStatusNoKey)) {
ok = TRUE;
}
}
return ok;
}
CFArrayRef /* of SCNetworkSetRef's */
SCNetworkSetCopyAll(SCPreferencesRef prefs)
{
CFMutableArrayRef array;
CFIndex n;
CFStringRef path;
CFDictionaryRef sets;
path = SCPreferencesPathKeyCreateSets(NULL);
sets = SCPreferencesPathGetValue(prefs, path);
CFRelease(path);
if ((sets != NULL) && !isA_CFDictionary(sets)) {
return NULL;
}
array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
n = (sets != NULL) ? CFDictionaryGetCount(sets) : 0;
if (n > 0) {
CFIndex i;
const void * keys_q[N_QUICK];
const void ** keys = keys_q;
const void * vals_q[N_QUICK];
const void ** vals = vals_q;
if (n > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
keys = CFAllocatorAllocate(NULL, n * sizeof(CFTypeRef), 0);
vals = CFAllocatorAllocate(NULL, n * sizeof(CFPropertyListRef), 0);
}
CFDictionaryGetKeysAndValues(sets, keys, vals);
for (i = 0; i < n; i++) {
SCNetworkSetPrivateRef setPrivate;
if (!isA_CFDictionary(vals[i])) {
SC_log(LOG_INFO, "error w/set \"%@\"", keys[i]);
continue;
}
setPrivate = __SCNetworkSetCreatePrivate(NULL, prefs, keys[i]);
assert(setPrivate != NULL);
// mark set as "old" (already established)
setPrivate->established = TRUE;
CFArrayAppendValue(array, (SCNetworkSetRef)setPrivate);
CFRelease(setPrivate);
}
if (keys != keys_q) {
CFAllocatorDeallocate(NULL, keys);
CFAllocatorDeallocate(NULL, vals);
}
}
return array;
}
__private_extern__ CFDictionaryRef
__copyProtocolTemplate(CFStringRef interfaceType,
CFStringRef childInterfaceType,
CFStringRef protocolType)
{
CFDictionaryRef interface = NULL;
CFDictionaryRef protocol = NULL;
CFDictionaryRef protocols;
CFDictionaryRef templates;
templates = __copyTemplates();
if (templates == NULL) {
return NULL;
}
protocols = CFDictionaryGetValue(templates, CFSTR("Protocol"));
if (!isA_CFDictionary(protocols)) {
CFRelease(templates);
return NULL;
}
if (childInterfaceType == NULL) {
interface = CFDictionaryGetValue(protocols, interfaceType);
} else {
CFStringRef expandedType;
if (CFStringFind(childInterfaceType, CFSTR("."), 0).location != kCFNotFound) {
// if "vendor" type
childInterfaceType = CFSTR("*");
}
expandedType = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@-%@"),
interfaceType,
childInterfaceType);
interface = CFDictionaryGetValue(protocols, expandedType);
CFRelease(expandedType);
}
if (isA_CFDictionary(interface)) {
protocol = CFDictionaryGetValue(interface, protocolType);
if (isA_CFDictionary(protocol)) {
CFRetain(protocol);
} else {
protocol = NULL;
}
}
CFRelease(templates);
return protocol;
}
kern_return_t
_io_pm_cancel_repeat_events
(
mach_port_t server __unused,
audit_token_t token,
int *return_code
)
{
SCPreferencesRef prefs = 0;
uid_t callerEUID;
CFStringRef offType, onType;
*return_code = kIOReturnSuccess;
audit_token_to_au32(token, NULL, &callerEUID, NULL, NULL, NULL, NULL, NULL, NULL);
if((*return_code = createSCSession(&prefs, callerEUID, 1)) != kIOReturnSuccess)
goto exit;
/* Need to take a retain on these strings as these dictionaries get release below */
offType = getRepeatingDictionaryType(repeatingPowerOff); CFRetain(offType);
onType = getRepeatingDictionaryType(repeatingPowerOn); CFRetain(onType);
if (repeatingPowerOff && isA_CFDictionary(repeatingPowerOff))
CFRelease(repeatingPowerOff);
if (repeatingPowerOn && isA_CFDictionary(repeatingPowerOn))
CFRelease(repeatingPowerOn);
repeatingPowerOff = repeatingPowerOn = NULL;
if ((*return_code = updateRepeatEventsOnDisk(prefs)) != kIOReturnSuccess)
goto exit;
schedulePowerEventType(offType);
schedulePowerEventType(onType);
exit:
if (offType)
CFRelease(offType);
if (onType)
CFRelease(onType);
destroySCSession(prefs, 1);
return KERN_SUCCESS;
}
__private_extern__ CFDictionaryRef
__copyInterfaceTemplate(CFStringRef interfaceType,
CFStringRef childInterfaceType)
{
CFDictionaryRef interface = NULL;
CFDictionaryRef interfaces;
CFDictionaryRef templates;
templates = __copyTemplates();
if (templates == NULL) {
return NULL;
}
interfaces = CFDictionaryGetValue(templates, CFSTR("Interface"));
if (!isA_CFDictionary(interfaces)) {
CFRelease(templates);
return NULL;
}
if (childInterfaceType == NULL) {
interface = CFDictionaryGetValue(interfaces, interfaceType);
} else {
CFStringRef expandedType;
if (CFStringFind(childInterfaceType, CFSTR("."), 0).location != kCFNotFound) {
// if "vendor" type
childInterfaceType = CFSTR("*");
}
expandedType = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@-%@"),
interfaceType,
childInterfaceType);
interface = CFDictionaryGetValue(interfaces, expandedType);
CFRelease(expandedType);
}
if (isA_CFDictionary(interface) && (CFDictionaryGetCount(interface) > 0)) {
CFRetain(interface);
} else {
interface = NULL;
}
CFRelease(templates);
return interface;
}
static bool
is_valid_repeating_dictionary(CFDictionaryRef event)
{
CFNumberRef tmp_num;
CFStringRef tmp_str;
if(NULL == event) return true;
if(!isA_CFDictionary(event)) return false;
tmp_num = (CFNumberRef)CFDictionaryGetValue(event, CFSTR(kIOPMPowerEventTimeKey));
if(!isA_CFNumber(tmp_num)) return false;
tmp_num = (CFNumberRef)CFDictionaryGetValue(event, CFSTR(kIOPMDaysOfWeekKey));
if(!isA_CFNumber(tmp_num)) return false;
tmp_str = (CFStringRef)CFDictionaryGetValue(event, CFSTR(kIOPMPowerEventTypeKey));
if(!isA_CFString(tmp_str)) return false;
if( !CFEqual(tmp_str, CFSTR(kIOPMAutoSleep))
&& !CFEqual(tmp_str, CFSTR(kIOPMAutoShutdown))
&& !CFEqual(tmp_str, CFSTR(kIOPMAutoWakeOrPowerOn))
&& !CFEqual(tmp_str, CFSTR(kIOPMAutoPowerOn))
&& !CFEqual(tmp_str, CFSTR(kIOPMAutoWake))
&& !CFEqual(tmp_str, CFSTR(kIOPMAutoRestart)) )
{
return false;
}
return true;
}
__private_extern__ CFDictionaryRef copyRepeatPowerEvents( )
{
CFMutableDictionaryRef return_dict = NULL;
return_dict = CFDictionaryCreateMutable(kCFAllocatorDefault, 2,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (repeatingPowerOn && isA_CFDictionary(repeatingPowerOn))
CFDictionaryAddValue(return_dict, CFSTR(kIOPMRepeatingPowerOnKey), repeatingPowerOn);
if (repeatingPowerOff && isA_CFDictionary(repeatingPowerOff))
CFDictionaryAddValue(return_dict, CFSTR(kIOPMRepeatingPowerOffKey), repeatingPowerOff);
return return_dict;
}
static Boolean
quiet(Boolean *timeout)
{
CFDictionaryRef dict;
Boolean _quiet = FALSE;
Boolean _timeout = FALSE;
// check if quiet
dict = SCDynamicStoreCopyValue(store, initKey);
if (dict != NULL) {
if (isA_CFDictionary(dict)) {
if (CFDictionaryContainsKey(dict, CFSTR("*QUIET*"))) {
_quiet = TRUE;
}
if (CFDictionaryContainsKey(dict, CFSTR("*TIMEOUT*"))) {
_timeout = TRUE;
}
}
CFRelease(dict);
}
if (timeout != NULL) {
*timeout = _timeout;
}
return _quiet;
}
__private_extern__ CFDictionaryRef
__getPrefsConfiguration(SCPreferencesRef prefs, CFStringRef path)
{
CFDictionaryRef config;
CFIndex n;
config = SCPreferencesPathGetValue(prefs, path);
n = isA_CFDictionary(config) ? CFDictionaryGetCount(config) : 0;
switch (n) {
case 0 :
// ignore empty configuration entities
config = NULL;
break;
case 1 :
if (CFDictionaryContainsKey(config, kSCResvInactive)) {
// ignore [effectively] empty configuration entities
config = NULL;
}
break;
default :
break;
}
return config;
}
/* IOCopyLoadAdvisoryLevelDetailed
* In case of error, or inability to find system load advisory level,
* returns NULL.
*/
CFDictionaryRef IOCopySystemLoadAdvisoryDetailed(void)
{
CFDictionaryRef gtDetailed = NULL;
SCDynamicStoreRef storage = NULL;
CFStringRef gtDetailedKey = SCDynamicStoreKeyCreate(
kCFAllocatorDefault,
CFSTR("%@%@"),
_io_kSCDynamicStoreDomainState,
kSLADetailedPath);
storage = SCDynamicStoreCreate(
kCFAllocatorDefault,
CFSTR("IOKit IOGetSystemLoadAdvisoryDetailed"),
NULL,
NULL);
if (!storage || !gtDetailedKey) {
goto exit;
}
gtDetailed = SCDynamicStoreCopyValue(storage, gtDetailedKey);
if(gtDetailed)
{
if(!isA_CFDictionary(gtDetailed)) {
CFRelease(gtDetailed);
gtDetailed = NULL;
}
}
exit:
if (gtDetailedKey) CFRelease(gtDetailedKey);
if (storage) CFRelease(storage);
return gtDetailed;
}
IOReturn IOPSSetPowerSourceDetails(
IOPSPowerSourceID whichPS,
CFDictionaryRef details)
{
IOReturn ret = kIOReturnSuccess;
char dskey_str[kMaxSCDSKeyLength];
CFDataRef flatDetails;
mach_port_t pm_server = MACH_PORT_NULL;
if (!whichPS || !isA_CFString(whichPS->scdsKey) || !isA_CFDictionary(details))
return kIOReturnBadArgument;
CFStringGetCString(whichPS->scdsKey, dskey_str, sizeof(dskey_str), kCFStringEncodingUTF8);
flatDetails = IOCFSerialize(whichPS, 0);
if (!flatDetails)
goto exit;
ret = _pm_connect(&pm_server);
if(kIOReturnSuccess != ret) {
ret = kIOReturnNotOpen;
goto exit;
}
// Pass the details off to powerd
io_pm_update_pspowersource(pm_server, dskey_str,
(vm_offset_t) CFDataGetBytePtr(flatDetails), CFDataGetLength(flatDetails), (int *)&ret);
_pm_disconnect(pm_server);
exit:
if (flatDetails)
CFRelease(flatDetails);
return ret;
}
static CFMutableDictionaryRef
copyIF(CFStringRef key, CFMutableDictionaryRef oldIFs, CFMutableDictionaryRef newIFs)
{
CFDictionaryRef dict = NULL;
CFMutableDictionaryRef newDict = NULL;
if (CFDictionaryGetValueIfPresent(newIFs, key, (const void **)&dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
} else {
dict = cache_SCDynamicStoreCopyValue(store, key);
if (dict) {
CFDictionarySetValue(oldIFs, key, dict);
if (isA_CFDictionary(dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6Addresses);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6DestAddresses);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6Flags);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6PrefixLength);
#ifdef NOTYET
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6ScopeID);
#endif /* NOTYET */
}
CFRelease(dict);
}
}
if (!newDict) {
newDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
return newDict;
}
static void
add_configured_interface(const void *key, const void *value, void *context)
{
SCBondInterfaceRef bond;
CFStringRef bond_if = (CFStringRef)key;
CFDictionaryRef bond_info = (CFDictionaryRef)value;
CFDictionaryRef bond_options;
CFIndex i;
CFArrayRef interfaces;
SCNetworkInterfacePrivateRef interfacePrivate;
CFMutableArrayRef members = NULL;
CFNumberRef mode;
addContextRef myContext = (addContextRef)context;
CFStringRef name;
CFIndex n;
// create the bond interface
bond = (SCBondInterfaceRef)_SCBondInterfaceCreatePrivate(NULL, bond_if);
// add member interfaces
interfaces = CFDictionaryGetValue(bond_info, kSCPropVirtualNetworkInterfacesBondInterfaces);
n = isA_CFArray(interfaces) ? CFArrayGetCount(interfaces) : 0;
for (i = 0; i < n; i++) {
CFStringRef member;
member = CFArrayGetValueAtIndex(interfaces, i);
if (isA_CFString(member)) {
add_interface(&members, member);
}
}
if (members != NULL) {
_SCBondInterfaceSetMemberInterfaces(bond, members);
CFRelease(members);
}
// set display name
name = CFDictionaryGetValue(bond_info, kSCPropUserDefinedName);
if (isA_CFString(name)) {
SCBondInterfaceSetLocalizedDisplayName(bond, name);
}
// set options
bond_options = CFDictionaryGetValue(bond_info, kSCPropVirtualNetworkInterfacesBondOptions);
if (isA_CFDictionary(bond_options)) {
SCBondInterfaceSetOptions(bond, bond_options);
}
// set the mode
mode = CFDictionaryGetValue(bond_info, kSCPropVirtualNetworkInterfacesBondMode);
_SCBondInterfaceSetMode(bond, isA_CFNumber(mode));
// estabish link to the stored configuration
interfacePrivate = (SCNetworkInterfacePrivateRef)bond;
interfacePrivate->prefs = CFRetain(myContext->prefs);
CFArrayAppendValue(myContext->bonds, bond);
CFRelease(bond);
return;
}
static CFDictionaryRef
smb_copy_global_configuration(SCDynamicStoreRef store)
{
CFDictionaryRef dict;
CFStringRef key;
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainState,
kSCEntNetSMB);
dict = SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict != NULL) {
if (isA_CFDictionary(dict)) {
return dict;
}
CFRelease(dict);
}
dict = CFDictionaryCreate(NULL, // allocator
NULL, // keys
NULL, // values
0, // numValues
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
return dict;
}
static CFStringRef
copy_primary_service(SCDynamicStoreRef store)
{
CFDictionaryRef dict;
CFStringRef key;
CFStringRef serviceID = NULL;
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainState,
kSCEntNetIPv4);
dict = SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict != NULL) {
if (isA_CFDictionary(dict)) {
serviceID = CFDictionaryGetValue(dict, kSCDynamicStorePropNetPrimaryService);
if (isA_CFString(serviceID)) {
CFRetain(serviceID);
} else {
serviceID = NULL;
}
}
CFRelease(dict);
}
return serviceID;
}
__private_extern__
void
do_dictRemoveKey(int argc, char **argv)
{
CFStringRef key;
CFMutableDictionaryRef val;
if (value == NULL) {
SCPrint(TRUE, stdout, CFSTR("d.remove: dictionary must be initialized.\n"));
return;
}
if (!isA_CFDictionary(value)) {
SCPrint(TRUE, stdout, CFSTR("d.remove: data (fetched from configuration server) is not a dictionary.\n"));
return;
}
val = CFDictionaryCreateMutableCopy(NULL, 0, value);
CFRelease(value);
value = val;
key = CFStringCreateWithCString(NULL, argv[0], kCFStringEncodingUTF8);
CFDictionaryRemoveValue((CFMutableDictionaryRef)value, key);
CFRelease(key);
return;
}
CFArrayRef /* of serviceID CFStringRef's */
SCNetworkSetGetServiceOrder(SCNetworkSetRef set)
{
CFDictionaryRef dict;
CFStringRef path;
CFArrayRef serviceOrder;
SCNetworkSetPrivateRef setPrivate = (SCNetworkSetPrivateRef)set;
if (!isA_SCNetworkSet(set)) {
_SCErrorSet(kSCStatusInvalidArgument);
return NULL;
}
path = SCPreferencesPathKeyCreateSetNetworkGlobalEntity(NULL, setPrivate->setID, kSCEntNetIPv4);
if (path == NULL) {
return NULL;
}
dict = SCPreferencesPathGetValue(setPrivate->prefs, path);
CFRelease(path);
if (!isA_CFDictionary(dict)) {
return NULL;
}
serviceOrder = CFDictionaryGetValue(dict, kSCPropNetServiceOrder);
serviceOrder = isA_CFArray(serviceOrder);
return serviceOrder;
}
/*
* Function: EAPOLClientProfileSetInformation
*
* Purpose:
* Associate additional information with the profile using the given
* application identifier.
*
* If info is NULL, the information for the particular application is cleared.
*
* Note:
* applicationID must be an application identifier e.g. "com.mycompany.myapp".
*/
Boolean
EAPOLClientProfileSetInformation(EAPOLClientProfileRef profile,
CFStringRef applicationID,
CFDictionaryRef information)
{
if (applicationID_is_valid(applicationID) == FALSE) {
return (FALSE);
}
if (information == NULL) {
if (profile->information != NULL) {
CFDictionaryRemoveValue(profile->information, applicationID);
}
}
else {
if (isA_CFDictionary(information) == NULL) {
return (FALSE);
}
if (profile->information == NULL) {
profile->information
= CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(profile->information, applicationID, information);
}
return (TRUE);
}
/*
*
* isEntryValidAndFuturistic
* Returns true if the CFDictionary is validly formed
* AND if the date is in the future
* Returns false if anything about the dictionary is invalid
* OR if the CFDate is prior to the current time
*
*/
static bool
isEntryValidAndFuturistic(CFDictionaryRef wakeup_dict, CFDateRef date_now)
{
CFDateRef wakeup_date;
bool ret = true;
wakeup_dict = isA_CFDictionary(wakeup_dict);
if(!wakeup_dict)
{
// bogus entry!
ret = false;
} else
{
// valid entry
wakeup_date = isA_CFDate(CFDictionaryGetValue(wakeup_dict,
CFSTR(kIOPMPowerEventTimeKey)));
if( !wakeup_date
|| (kCFCompareLessThan == CFDateCompare(wakeup_date, date_now, 0)))
{
// date is too early
ret = false;
}
// otherwise date is after now, and ret = true
}
return ret;
}
__private_extern__ IOReturn
GetPMSettingNumber(CFStringRef which, int64_t *value)
{
CFDictionaryRef current_settings;
CFNumberRef n;
CFStringRef pwrSrc;
if (!energySettings || !which)
return kIOReturnBadArgument;
if (_getPowerSource() == kBatteryPowered)
pwrSrc = CFSTR(kIOPMBatteryPowerKey);
else
pwrSrc = CFSTR(kIOPMACPowerKey);
// Don't use 'currentPowerSource' here as that gets updated
// little slowly after this function is called to get a setting
// on new power source.
current_settings = (CFDictionaryRef)isA_CFDictionary(
CFDictionaryGetValue(energySettings, pwrSrc));
if (current_settings) {
n = CFDictionaryGetValue(current_settings, which);
if (isA_CFNumber(n)) {
CFNumberGetValue(n, kCFNumberSInt64Type, value);
return kIOReturnSuccess;
}
}
return kIOReturnError;
}
PRIVATE_EXTERN void
CGAPrepareSetForInterface(const char * ifname,
struct in6_cga_prepare * cga_prep)
{
CFDictionaryRef dict;
CFStringRef ifname_cf;
CFDataRef modifier = NULL;
uint8_t security_level;
if (S_LinkLocalModifiers == NULL) {
my_log_fl(LOG_NOTICE, "S_LinkLocalModifiers is NULL");
return;
}
ifname_cf = CFStringCreateWithCString(NULL, ifname, kCFStringEncodingASCII);
dict = CFDictionaryGetValue(S_LinkLocalModifiers, ifname_cf);
if (isA_CFDictionary(dict) != NULL) {
modifier = CGAModifierDictGetModifier(dict, &security_level);
}
if (modifier == NULL) {
security_level = kCGASecurityLevelZero;
modifier = my_CFDataCreateWithRandomBytes(IN6_CGA_MODIFIER_LENGTH);
dict = CGAModifierDictCreate(modifier, security_level);
CFDictionarySetValue(S_LinkLocalModifiers, ifname_cf, dict);
CFRelease(modifier);
CGAWrite(HostUUIDGet(), S_GlobalModifier, S_LinkLocalModifiers);
}
CFRelease(ifname_cf);
cga_prepare_set(cga_prep, modifier, security_level);
return;
}
STATIC CFDataRef
CGAModifierDictGetModifier(CFDictionaryRef dict, uint8_t * security_level)
{
CFDataRef modifier = NULL;
*security_level = 0;
if (isA_CFDictionary(dict) != NULL) {
modifier = CFDictionaryGetValue(dict, kModifier);
modifier = isA_CFData(modifier);
if (modifier != NULL) {
if (CFDataGetLength(modifier) != IN6_CGA_MODIFIER_LENGTH) {
modifier = NULL;
}
else {
CFNumberRef level;
level = CFDictionaryGetValue(dict, kSecurityLevel);
if (isA_CFNumber(level) != NULL) {
CFNumberGetValue(level, kCFNumberSInt8Type, security_level);
}
}
}
}
return (modifier);
}
static CFStringRef
copy_primary_ip(SCDynamicStoreRef store, CFStringRef serviceID)
{
CFStringRef address = NULL;
CFDictionaryRef dict;
CFStringRef key;
key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainState,
serviceID,
kSCEntNetIPv4);
dict = SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict != NULL) {
if (isA_CFDictionary(dict)) {
CFArrayRef addresses;
addresses = CFDictionaryGetValue(dict, kSCPropNetIPv4Addresses);
if (isA_CFArray(addresses) && (CFArrayGetCount(addresses) > 0)) {
address = CFArrayGetValueAtIndex(addresses, 0);
if (isA_CFString(address)) {
CFRetain(address);
} else {
address = NULL;
}
}
}
CFRelease(dict);
}
return address;
}
SCNetworkSetRef
SCNetworkSetCopy(SCPreferencesRef prefs, CFStringRef setID)
{
CFDictionaryRef entity;
CFStringRef path;
SCNetworkSetPrivateRef setPrivate;
if (!isA_CFString(setID)) {
_SCErrorSet(kSCStatusInvalidArgument);
return NULL;
}
path = SCPreferencesPathKeyCreateSet(NULL, setID);
entity = SCPreferencesPathGetValue(prefs, path);
CFRelease(path);
if (!isA_CFDictionary(entity)) {
_SCErrorSet(kSCStatusNoKey);
return NULL;
}
setPrivate = __SCNetworkSetCreatePrivate(NULL, prefs, setID);
assert(setPrivate != NULL);
// mark set as "old" (already established)
setPrivate->established = TRUE;
return (SCNetworkSetRef)setPrivate;
}
static Boolean
_SCBondInterfaceSetMode(SCBondInterfaceRef bond, CFNumberRef mode)
{
SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bond;
Boolean needs_release = FALSE;
Boolean ok = TRUE;
assert(bond != NULL);
if (mode == NULL) {
int mode_num = IF_BOND_MODE_LACP;
mode = CFNumberCreate(NULL, kCFNumberIntType, &mode_num);
needs_release = TRUE;
}
// set mode in the stored preferences
if (interfacePrivate->prefs != NULL) {
CFDictionaryRef dict;
CFMutableDictionaryRef newDict;
CFStringRef path;
path = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("/%@/%@/%@"),
kSCPrefVirtualNetworkInterfaces,
kSCNetworkInterfaceTypeBond,
interfacePrivate->entity_device);
dict = SCPreferencesPathGetValue(interfacePrivate->prefs, path);
if (!isA_CFDictionary(dict)) {
// if the prefs are confused
CFRelease(path);
_SCErrorSet(kSCStatusFailed);
ok = FALSE;
goto done;
}
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
CFDictionarySetValue(newDict, kSCPropVirtualNetworkInterfacesBondMode, mode);
if (!CFEqual(dict, newDict)) {
ok = SCPreferencesPathSetValue(interfacePrivate->prefs, path, newDict);
}
CFRelease(newDict);
CFRelease(path);
}
if (ok) {
CFRetain(mode);
if (interfacePrivate->bond.mode != NULL) {
CFRelease(interfacePrivate->bond.mode);
}
interfacePrivate->bond.mode = mode;
}
done :
if (needs_release) CFRelease(mode);
return ok;
}
__private_extern__
void
link_add(const char *if_name)
{
CFStringRef interface;
CFStringRef cacheKey;
CFDictionaryRef dict;
CFMutableDictionaryRef newDict = NULL;
CFArrayRef ifList;
CFMutableArrayRef newIFList = NULL;
interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
cacheKey = SCDynamicStoreKeyCreateNetworkInterface(NULL,
kSCDynamicStoreDomainState);
dict = cache_SCDynamicStoreCopyValue(store, cacheKey);
if (dict) {
if (isA_CFDictionary(dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
ifList = CFDictionaryGetValue(newDict, kSCPropNetInterfaces);
if (isA_CFArray(ifList)) {
newIFList = CFArrayCreateMutableCopy(NULL, 0, ifList);
}
}
CFRelease(dict);
}
if (!newDict) {
newDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
if (!newIFList) {
newIFList = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
}
if (CFArrayContainsValue(newIFList,
CFRangeMake(0, CFArrayGetCount(newIFList)),
interface) == FALSE) {
CFArrayAppendValue(newIFList, interface);
CFDictionarySetValue(newDict, kSCPropNetInterfaces, newIFList);
}
cache_SCDynamicStoreSetValue(store, cacheKey, newDict);
link_update_status(if_name, TRUE);
#ifdef KEV_DL_LINK_QUALITY_METRIC_CHANGED
link_update_quality_metric(if_name);
#endif /* KEV_DL_LINK_QUALITY_METRIC_CHANGED */
CFRelease(cacheKey);
CFRelease(interface);
if (newDict) CFRelease(newDict);
if (newIFList) CFRelease(newIFList);
return;
}
static void
nc_listvpn(int argc, char **argv)
{
CFDictionaryRef appDict = NULL;
CFArrayRef appinfo = NULL;
int i, j, count, subtypecount;
const void * * keys = NULL;
CFMutableDictionaryRef optionsDict = NULL;
const void * * values = NULL;
CFStringRef vpntype = NULL;
optionsDict = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(optionsDict, kLookupApplicationTypeKey, kApplicationTypeUser);
CFDictionarySetValue(optionsDict, kLookupAttributeKey, CFSTR("UIVPNPlugin"));
appDict = MobileInstallationLookup(optionsDict);
if (!isA_CFDictionary(appDict))
goto done;
count = CFDictionaryGetCount(appDict);
if (count > 0) {
keys = (const void * *)malloc(sizeof(CFTypeRef) * count);
values = (const void * *)malloc(sizeof(CFTypeRef) * count);
CFDictionaryGetKeysAndValues(appDict, keys, values);
for (i=0; i<count; i++) {
appinfo = CFDictionaryGetValue(values[i], CFSTR("UIVPNPlugin"));
if (appinfo) {
if (isA_CFString(appinfo)) {
nc_print_VPN_app_info((CFStringRef)appinfo, (CFDictionaryRef)values[i]);
}
else if (isA_CFArray(appinfo)) {
subtypecount = CFArrayGetCount((CFArrayRef)appinfo);
for(j=0; j<subtypecount; j++) {
vpntype = (CFStringRef)CFArrayGetValueAtIndex((CFArrayRef)appinfo, j);
nc_print_VPN_app_info(vpntype, (CFDictionaryRef)values[i]);
}
}
}
}
}
done:
if (keys) free(keys);
if (values) free(values);
my_CFRelease(&optionsDict);
my_CFRelease(&appDict);
exit(0);
}
STATIC bool
load_DUID_info(void)
{
CFDataRef duid;
CFDictionaryRef duid_ia;
CFDataRef host_uuid;
CFArrayRef ia_list;
duid_ia = my_CFPropertyListCreateFromFile(DUID_IA_FILE);
if (isA_CFDictionary(duid_ia) == NULL) {
goto done;
}
duid = CFDictionaryGetValue(duid_ia, kDUIDKey);
if (isA_CFData(duid) == NULL) {
goto done;
}
ia_list = CFDictionaryGetValue(duid_ia, kIAIDListKey);
ia_list = isA_CFArray(ia_list);
if (ia_list != NULL) {
int count;
int i;
count = CFArrayGetCount(ia_list);
for (i = 0; i < count; i++) {
CFStringRef name = CFArrayGetValueAtIndex(ia_list, i);
if (isA_CFString(name) == NULL) {
/* invalid property */
ia_list = NULL;
break;
}
}
}
host_uuid = CFDictionaryGetValue(duid_ia, kHostUUIDKey);
if (isA_CFData(host_uuid) != NULL
&& CFDataGetLength(host_uuid) == sizeof(uuid_t)) {
CFDataRef our_UUID;
our_UUID = HostUUIDGet();
if (our_UUID != NULL && CFEqual(host_uuid, our_UUID) == FALSE) {
syslog(LOG_NOTICE,
"DHCPDUID: ignoring DUID - host UUID doesn't match");
goto done;
}
}
S_DUID = CFRetain(duid);
if (ia_list != NULL) {
S_IAIDList = CFArrayCreateMutableCopy(NULL, 0, ia_list);
}
done:
my_CFRelease(&duid_ia);
return (S_DUID != NULL);
}
static int
S_stress_start(int argc, char * argv[])
{
CFDictionaryRef dict = NULL;
int i;
char * ifname = argv[0];
int result;
SCDynamicStoreRef store;
if (access(argv[1], R_OK) != 0) {
fprintf(stderr, "%s: %s\n", argv[1], strerror(errno));
return (errno);
}
dict = (CFDictionaryRef)my_CFPropertyListCreateFromFile(argv[1]);
if (isA_CFDictionary(dict) == NULL) {
fprintf(stderr, "contents of file %s invalid\n", argv[1]);
my_CFRelease(&dict);
return (EINVAL);
}
store = config_session_start(NULL, NULL, ifname);
if (store == NULL) {
CFRelease(dict);
return (EINVAL);
}
for (i = 0; TRUE; i++) {
result = EAPOLControlStart(ifname, dict);
if (result != 0) {
fprintf(stderr, "EAPOLControlStart(%s) returned %d (%s)\n",
ifname, result, strerror(result));
break;
}
result = S_wait_for_state(ifname, store,
kEAPOLControlStateRunning,
kEAPOLControlStateStarting);
if (result != 0) {
fprintf(stderr, "Waiting for Running failed\n");
break;
}
result = EAPOLControlStop(ifname);
if (result != 0) {
fprintf(stderr, "EAPOLControlStop(%s) returned %d (%s)\n",
ifname, result, strerror(result));
break;
}
(void)S_wait_for_state(ifname, store,
kEAPOLControlStateIdle,
kEAPOLControlStateStopping);
}
fprintf(stderr, "Failed at iteration %d\n", i + 1);
my_CFRelease(&dict);
return (result);
}
__private_extern__ Boolean
__getPrefsEnabled(SCPreferencesRef prefs, CFStringRef path)
{
CFDictionaryRef config;
config = SCPreferencesPathGetValue(prefs, path);
if (isA_CFDictionary(config) && CFDictionaryContainsKey(config, kSCResvInactive)) {
return FALSE;
}
return TRUE;
}
