#include <TargetConditionals.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <SystemConfiguration/SystemConfiguration.h>
#include <SystemConfiguration/SCPrivate.h>
#include <SystemConfiguration/SCValidation.h>
static SCPreferencesRef prefs = NULL;
static SCDynamicStoreRef store = NULL;
static CFStringRef initKey = NULL;
static CFRunLoopSourceRef initRls = NULL;
static CFMutableDictionaryRef currentPrefs;
static CFMutableDictionaryRef newPrefs;
static CFMutableArrayRef unchangedPrefsKeys;
static CFMutableArrayRef removedPrefsKeys;
static Boolean rofs = FALSE;
static Boolean restorePrefs = FALSE;
#define MY_PLUGIN_NAME "PreferencesMonitor"
#define MY_PLUGIN_ID CFSTR("com.apple.SystemConfiguration." MY_PLUGIN_NAME)
static Boolean
restorePreferences()
{
Boolean ok = FALSE;
CFStringRef currentModel = NULL;
CFMutableStringRef modelPrefixStr = NULL;
CFArrayRef keyList = NULL;
CFIndex keyListCount;
CFIndex idx;
Boolean modified = FALSE;
int sc_status = kSCStatusFailed;
while (TRUE) {
ok = SCPreferencesLock(prefs, TRUE);
if (ok) {
break;
}
sc_status = SCError();
if (sc_status == kSCStatusStale) {
SCPreferencesSynchronize(prefs);
} else {
SC_log(LOG_NOTICE, "Could not acquire network configuration lock: %s",
SCErrorString(sc_status));
return FALSE;
}
}
keyList = SCPreferencesCopyKeyList(prefs);
if (keyList == NULL) {
goto error;
}
currentModel = _SC_hw_model(FALSE);
if (currentModel == NULL) {
goto error;
}
modelPrefixStr = CFStringCreateMutableCopy(NULL, 0, currentModel);
CFStringAppend(modelPrefixStr, CFSTR(":"));
keyListCount = CFArrayGetCount(keyList);
for (idx = 0; idx < keyListCount; idx++) {
CFStringRef existingKey = CFArrayGetValueAtIndex(keyList, idx);
CFStringRef key;
CFArrayRef splitKey = NULL;
CFPropertyListRef value;
if (isA_CFString(existingKey) == NULL) {
continue;
}
if (CFStringHasPrefix(existingKey, modelPrefixStr) == FALSE) {
continue;
}
splitKey = CFStringCreateArrayBySeparatingStrings(NULL, existingKey, CFSTR(":"));
key = CFArrayGetValueAtIndex(splitKey, 1);
value = SCPreferencesGetValue(prefs, existingKey);
SCPreferencesSetValue(prefs, key, value);
SCPreferencesRemoveValue(prefs, existingKey);
modified = TRUE;
CFRelease(splitKey);
}
if (modified == TRUE) {
SCPreferencesRef ni_prefs = NULL;
ni_prefs = SCPreferencesCreate(NULL, MY_PLUGIN_ID, CFSTR("NetworkInterfaces.plist"));
if (ni_prefs == NULL) {
goto error;
}
ok = _SCNetworkConfigurationCheckValidityWithPreferences(prefs, ni_prefs, NULL);
CFRelease(ni_prefs);
if (ok == TRUE) {
if (!SCPreferencesCommitChanges(prefs)) {
if (SCError() != EROFS) {
SC_log(LOG_NOTICE, "SCPreferencesCommitChanges() failed: %s",
SCErrorString(SCError()));
}
goto error;
}
(void) SCPreferencesApplyChanges(prefs);
}
}
error:
(void) SCPreferencesUnlock(prefs);
if (keyList != NULL) {
CFRelease(keyList);
}
if (modelPrefixStr != NULL) {
CFRelease(modelPrefixStr);
}
return modified;
}
static Boolean
establishNewPreferences()
{
CFBundleRef bundle;
SCNetworkSetRef current = NULL;
CFStringRef new_model;
Boolean ok = FALSE;
int sc_status = kSCStatusFailed;
SCNetworkSetRef set = NULL;
CFStringRef setName = NULL;
Boolean updated = FALSE;
while (TRUE) {
ok = SCPreferencesLock(prefs, TRUE);
if (ok) {
break;
}
sc_status = SCError();
if (sc_status == kSCStatusStale) {
SCPreferencesSynchronize(prefs);
} else {
SC_log(LOG_NOTICE, "Could not acquire network configuration lock: %s",
SCErrorString(sc_status));
return FALSE;
}
}
new_model = _SC_hw_model(FALSE);
if (new_model != NULL) {
CFStringRef old_model;
old_model = SCPreferencesGetValue(prefs, MODEL);
if ((old_model != NULL) && !_SC_CFEqual(old_model, new_model)) {
CFIndex count;
CFIndex index;
CFArrayRef keys;
keys = SCPreferencesCopyKeyList(prefs);
count = (keys != NULL) ? CFArrayGetCount(keys) : 0;
for (index = 0; index < count; index++) {
CFStringRef existing_key;
existing_key = CFArrayGetValueAtIndex(keys, index);
if (isA_CFString(existing_key) != NULL) {
CFStringRef new_key;
CFPropertyListRef value;
if (CFEqual(existing_key, MODEL)
|| CFStringFind(existing_key, CFSTR(":"), 0).location
!= kCFNotFound) {
continue;
}
value = SCPreferencesGetValue(prefs, existing_key);
new_key = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@:%@"),
old_model, existing_key);
SCPreferencesSetValue(prefs, new_key, value);
if (!CFEqual(existing_key, kSCPrefSystem)) {
SCPreferencesRemoveValue(prefs, existing_key);
}
CFRelease(new_key);
}
}
if (keys != NULL) {
CFRelease(keys);
}
}
SCPreferencesSetValue(prefs, MODEL, new_model);
}
current = SCNetworkSetCopyCurrent(prefs);
if (current != NULL) {
set = current;
}
if (set == NULL) {
set = SCNetworkSetCreate(prefs);
if (set == NULL) {
ok = FALSE;
sc_status = SCError();
goto done;
}
bundle = _SC_CFBundleGet();
if (bundle != NULL) {
setName = CFBundleCopyLocalizedString(bundle,
CFSTR("DEFAULT_SET_NAME"),
CFSTR("Automatic"),
NULL);
}
ok = SCNetworkSetSetName(set, (setName != NULL) ? setName : CFSTR("Automatic"));
if (!ok) {
sc_status = SCError();
goto done;
}
ok = SCNetworkSetSetCurrent(set);
if (!ok) {
sc_status = SCError();
goto done;
}
}
ok = SCNetworkSetEstablishDefaultConfiguration(set);
if (!ok) {
sc_status = SCError();
goto done;
}
done :
if (ok) {
ok = SCPreferencesCommitChanges(prefs);
if (ok) {
SC_log(LOG_NOTICE, "New network configuration saved");
updated = TRUE;
} else {
sc_status = SCError();
if (sc_status == EROFS) {
ok = TRUE;
rofs = TRUE;
}
}
(void) SCPreferencesApplyChanges(prefs);
} else if ((current == NULL) && (set != NULL)) {
(void) SCNetworkSetRemove(set);
}
if (!ok) {
SC_log(LOG_NOTICE, "Could not establish network configuration: %s",
SCErrorString(sc_status));
}
(void)SCPreferencesUnlock(prefs);
if (setName != NULL) CFRelease(setName);
if (set != NULL) CFRelease(set);
return updated;
}
static Boolean
quiet(Boolean *timeout)
{
CFDictionaryRef dict;
Boolean _quiet = FALSE;
Boolean _timeout = FALSE;
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;
}
static void
watchQuietDisable()
{
if ((initKey == NULL) || (initRls == NULL)) {
return;
}
(void) SCDynamicStoreSetNotificationKeys(store, NULL, NULL);
CFRunLoopSourceInvalidate(initRls);
CFRelease(initRls);
initRls = NULL;
CFRelease(initKey);
initKey = NULL;
return;
}
static void
watchQuietEnable()
{
CFArrayRef keys;
Boolean ok;
initKey = SCDynamicStoreKeyCreate(NULL,
CFSTR("%@" "InterfaceNamer"),
kSCDynamicStoreDomainPlugin);
initRls = SCDynamicStoreCreateRunLoopSource(NULL, store, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), initRls, kCFRunLoopDefaultMode);
keys = CFArrayCreate(NULL, (const void **)&initKey, 1, &kCFTypeArrayCallBacks);
ok = SCDynamicStoreSetNotificationKeys(store, keys, NULL);
CFRelease(keys);
if (!ok) {
SC_log(LOG_NOTICE, "SCDynamicStoreSetNotificationKeys() failed: %s", SCErrorString(SCError()));
watchQuietDisable();
}
return;
}
static Boolean
previousConfigurationAvailable()
{
CFStringRef backupKey = NULL;
CFStringRef currentModel = NULL;
CFPropertyListRef properties = NULL;
currentModel = _SC_hw_model(FALSE);
if (currentModel == NULL) {
goto done;
}
backupKey = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@:Sets"), currentModel);
properties = SCPreferencesGetValue(prefs, backupKey);
CFRelease(backupKey);
done:
return (properties != NULL);
}
static void
watchQuietCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)
{
Boolean _quiet;
Boolean _timeout = FALSE;
_quiet = quiet(&_timeout);
if (_quiet
#if !TARGET_OS_IPHONE
|| _timeout
#endif
) {
watchQuietDisable();
}
if (_quiet || _timeout) {
static int logged = 0;
(void) establishNewPreferences();
if (restorePrefs == TRUE) {
(void) restorePreferences();
restorePrefs = FALSE;
}
if (_timeout && (logged++ == 0)) {
SC_log(LOG_ERR, "Network configuration creation timed out waiting for IORegistry");
}
}
return;
}
static void
updateCache(const void *key, const void *value, void *context)
{
CFStringRef configKey = (CFStringRef)key;
CFPropertyListRef configData = (CFPropertyListRef)value;
CFPropertyListRef cacheData;
CFIndex i;
cacheData = CFDictionaryGetValue(currentPrefs, configKey);
if (cacheData) {
if (CFEqual(cacheData, configData)) {
CFArrayAppendValue(unchangedPrefsKeys, configKey);
}
}
i = CFArrayGetFirstIndexOfValue(removedPrefsKeys,
CFRangeMake(0, CFArrayGetCount(removedPrefsKeys)),
configKey);
if (i != kCFNotFound) {
CFArrayRemoveValueAtIndex(removedPrefsKeys, i);
}
return;
}
static void
flatten(SCPreferencesRef prefs,
CFStringRef key,
CFDictionaryRef base)
{
CFDictionaryRef subset;
CFStringRef link;
CFMutableDictionaryRef myDict;
CFStringRef myKey;
CFIndex i;
CFIndex nKeys;
const void **keys;
const void **vals;
if (!CFDictionaryGetValueIfPresent(base, kSCResvLink, (const void **)&link)) {
subset = base;
} else {
subset = SCPreferencesPathGetValue(prefs, link);
if (!subset) {
SC_log(LOG_NOTICE, "SCPreferencesPathGetValue(,%@,) failed: %s",
link,
SCErrorString(SCError()));
return;
}
}
if (CFDictionaryContainsKey(subset, kSCResvInactive)) {
return;
}
myKey = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@%@"),
kSCDynamicStoreDomainSetup,
key);
myDict = (CFMutableDictionaryRef)CFDictionaryGetValue(newPrefs, myKey);
if (myDict) {
myDict = CFDictionaryCreateMutableCopy(NULL,
0,
(CFDictionaryRef)myDict);
} else {
myDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
nKeys = CFDictionaryGetCount(subset);
if (nKeys > 0) {
keys = CFAllocatorAllocate(NULL, nKeys * sizeof(CFStringRef) , 0);
vals = CFAllocatorAllocate(NULL, nKeys * sizeof(CFPropertyListRef), 0);
CFDictionaryGetKeysAndValues(subset, keys, vals);
for (i = 0; i < nKeys; i++) {
if (CFGetTypeID((CFTypeRef)vals[i]) != CFDictionaryGetTypeID()) {
CFDictionarySetValue(myDict, keys[i], vals[i]);
} else {
CFStringRef subKey;
subKey = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@%s%@"),
key,
CFEqual(key, CFSTR("/")) ? "" : "/",
keys[i]);
flatten(prefs, subKey, vals[i]);
CFRelease(subKey);
}
}
CFAllocatorDeallocate(NULL, keys);
CFAllocatorDeallocate(NULL, vals);
}
if (CFDictionaryGetCount(myDict) > 0) {
CFDictionarySetValue(newPrefs, myKey, myDict);
}
CFRelease(myDict);
CFRelease(myKey);
return;
}
static void
updateSCDynamicStore(SCPreferencesRef prefs)
{
CFStringRef current = NULL;
CFDateRef date = NULL;
CFMutableDictionaryRef dict = NULL;
CFDictionaryRef global = NULL;
CFIndex i;
CFArrayRef keys;
CFIndex n;
CFStringRef pattern;
CFMutableArrayRef patterns;
CFDictionaryRef set = NULL;
patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
pattern = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("^%@.*"),
kSCDynamicStoreDomainSetup);
CFArrayAppendValue(patterns, pattern);
dict = (CFMutableDictionaryRef)SCDynamicStoreCopyMultiple(store, NULL, patterns);
CFRelease(patterns);
CFRelease(pattern);
if (dict) {
currentPrefs = CFDictionaryCreateMutableCopy(NULL, 0, dict);
CFRelease(dict);
} else {
currentPrefs = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
unchangedPrefsKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
i = CFDictionaryGetCount(currentPrefs);
if (i > 0) {
const void **currentKeys;
CFArrayRef array;
currentKeys = CFAllocatorAllocate(NULL, i * sizeof(CFStringRef), 0);
CFDictionaryGetKeysAndValues(currentPrefs, currentKeys, NULL);
array = CFArrayCreate(NULL, currentKeys, i, &kCFTypeArrayCallBacks);
removedPrefsKeys = CFArrayCreateMutableCopy(NULL, 0, array);
CFRelease(array);
CFAllocatorDeallocate(NULL, currentKeys);
} else {
removedPrefsKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
}
newPrefs = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
dict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
date = CFDateCreate(NULL, CFAbsoluteTimeGetCurrent());
keys = SCPreferencesCopyKeyList(prefs);
if ((keys == NULL) || (CFArrayGetCount(keys) == 0)) {
SC_log(LOG_NOTICE, "updateConfiguration(): no preferences");
goto done;
}
global = SCPreferencesGetValue(prefs, kSCPrefSystem);
if (!global) {
goto getSet;
}
if (!isA_CFDictionary(global)) {
SC_log(LOG_NOTICE, "updateConfiguration(): %@ is not a dictionary",
kSCPrefSystem);
goto done;
}
flatten(prefs, CFSTR("/"), global);
getSet :
current = SCPreferencesGetValue(prefs, kSCPrefCurrentSet);
if (!current) {
goto done;
}
if (!isA_CFString(current)) {
SC_log(LOG_NOTICE, "updateConfiguration(): %@ is not a string",
kSCPrefCurrentSet);
goto done;
}
set = SCPreferencesPathGetValue(prefs, current);
if (!set) {
SC_log(LOG_NOTICE, "%@ value (%@) not valid",
kSCPrefCurrentSet,
current);
goto done;
}
if (!isA_CFDictionary(set)) {
SC_log(LOG_NOTICE, "updateConfiguration(): %@ is not a dictionary",
current);
goto done;
}
flatten(prefs, CFSTR("/"), set);
CFDictionarySetValue(dict, kSCDynamicStorePropSetupCurrentSet, current);
done :
CFDictionarySetValue(dict, kSCDynamicStorePropSetupLastUpdated, date);
CFDictionarySetValue(newPrefs, kSCDynamicStoreDomainSetup, dict);
CFDictionaryApplyFunction(newPrefs, updateCache, NULL);
n = CFArrayGetCount(unchangedPrefsKeys);
for (i = 0; i < n; i++) {
CFStringRef key;
key = CFArrayGetValueAtIndex(unchangedPrefsKeys, i);
CFDictionaryRemoveValue(newPrefs, key);
}
#ifndef MAIN
if (!SCDynamicStoreSetMultiple(store, newPrefs, removedPrefsKeys, NULL)) {
SC_log(LOG_NOTICE, "SCDynamicStoreSetMultiple() failed: %s", SCErrorString(SCError()));
}
#else // !MAIN
SC_log(LOG_DEBUG, "SCDynamicStore\nset: %@\nremove: %@",
newPrefs,
removedPrefsKeys);
#endif // !MAIN
CFRelease(currentPrefs);
CFRelease(newPrefs);
CFRelease(unchangedPrefsKeys);
CFRelease(removedPrefsKeys);
if (dict) CFRelease(dict);
if (date) CFRelease(date);
if (keys) CFRelease(keys);
return;
}
static void
updateConfiguration(SCPreferencesRef prefs,
SCPreferencesNotification notificationType,
void *info)
{
os_activity_t activity_id;
activity_id = os_activity_start("processing [SC] preferences.plist changes",
OS_ACTIVITY_FLAG_DEFAULT);
#if !TARGET_OS_IPHONE
if ((notificationType & kSCPreferencesNotificationCommit) == kSCPreferencesNotificationCommit) {
SCNetworkSetRef current;
current = SCNetworkSetCopyCurrent(prefs);
if (current != NULL) {
watchQuietDisable();
CFRelease(current);
}
}
#endif
if ((notificationType & kSCPreferencesNotificationApply) != kSCPreferencesNotificationApply) {
goto done;
}
SC_log(LOG_INFO, "updating configuration");
updateSCDynamicStore(prefs);
if (!rofs) {
SCPreferencesSynchronize(prefs);
}
done :
os_activity_end(activity_id);
return;
}
__private_extern__
void
prime_PreferencesMonitor()
{
SC_log(LOG_DEBUG, "prime() called");
updateConfiguration(prefs, kSCPreferencesNotificationApply, (void *)store);
return;
}
__private_extern__
void
load_PreferencesMonitor(CFBundleRef bundle, Boolean bundleVerbose)
{
Boolean initPrefs = TRUE;
SC_log(LOG_DEBUG, "load() called");
SC_log(LOG_DEBUG, " bundle ID = %@", CFBundleGetIdentifier(bundle));
store = SCDynamicStoreCreate(NULL,
CFSTR("PreferencesMonitor.bundle"),
watchQuietCallback,
NULL);
if (store == NULL) {
SC_log(LOG_NOTICE, "SCDynamicStoreCreate() failed: %s", SCErrorString(SCError()));
goto error;
}
#ifndef MAIN
prefs = SCPreferencesCreate(NULL, CFSTR("PreferencesMonitor.bundle"), NULL);
#else // !MAIN
prefs = SCPreferencesCreate(NULL, CFSTR("PreferencesMonitor.bundle"), CFSTR("/tmp/preferences.plist"));
#endif // !MAIN
if (prefs != NULL) {
Boolean need_update = FALSE;
CFStringRef new_model;
new_model = _SC_hw_model(FALSE);
if (new_model != NULL) {
CFStringRef old_model;
old_model = SCPreferencesGetValue(prefs, MODEL);
if (old_model != NULL && !_SC_CFEqual(old_model, new_model)) {
need_update = TRUE;
restorePrefs = previousConfigurationAvailable();
}
}
if (need_update == FALSE) {
SCNetworkSetRef current;
current = SCNetworkSetCopyCurrent(prefs);
if (current != NULL) {
initPrefs = FALSE;
CFRelease(current);
}
}
} else {
SC_log(LOG_NOTICE, "SCPreferencesCreate() failed: %s", SCErrorString(SCError()));
goto error;
}
if (!SCPreferencesSetCallback(prefs, updateConfiguration, NULL)) {
SC_log(LOG_NOTICE, "SCPreferencesSetCallBack() failed: %s", SCErrorString(SCError()));
goto error;
}
if (!SCPreferencesScheduleWithRunLoop(prefs, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode)) {
SC_log(LOG_NOTICE, "SCPreferencesScheduleWithRunLoop() failed: %s", SCErrorString(SCError()));
goto error;
}
if (initPrefs) {
watchQuietEnable();
watchQuietCallback(store, NULL, NULL);
}
return;
error :
watchQuietDisable();
if (store != NULL) CFRelease(store);
if (prefs != NULL) CFRelease(prefs);
return;
}
#ifdef MAIN
int
main(int argc, char **argv)
{
_sc_log = FALSE;
_sc_verbose = (argc > 1) ? TRUE : FALSE;
load_PreferencesMonitor(CFBundleGetMainBundle(), (argc > 1) ? TRUE : FALSE);
prime_PreferencesMonitor();
CFRunLoopRun();
exit(0);
return 0;
}
#endif