__private_extern__
void
interface_update_quality_metric(const char *if_name,
int quality)
{
CFStringRef key = NULL;
CFMutableDictionaryRef newDict = NULL;
CFNumberRef linkquality = NULL;
key = create_linkquality_key(if_name);
newDict = copy_entity(key);
if (quality != IFNET_LQM_THRESH_UNKNOWN) {
linkquality = CFNumberCreate(NULL, kCFNumberIntType, &quality);
CFDictionarySetValue(newDict, kSCPropNetLinkQuality, linkquality);
CFRelease(linkquality);
} else {
CFDictionaryRemoveValue(newDict, kSCPropNetLinkQuality);
}
/* update status */
if (CFDictionaryGetCount(newDict) > 0) {
cache_SCDynamicStoreSetValue(store, key, newDict);
} else {
cache_SCDynamicStoreRemoveValue(store, key);
}
CFRelease(key);
CFRelease(newDict);
return;
}
static void
interface_update_status(const char *if_name, CFBooleanRef active,
boolean_t attach)
{
CFStringRef key = NULL;
CFMutableDictionaryRef newDict = NULL;
key = create_interface_key(if_name);
newDict = copy_entity(key);
/* if new status available, update cache */
if (active == NULL) {
CFDictionaryRemoveValue(newDict, kSCPropNetLinkActive);
} else {
CFDictionarySetValue(newDict, kSCPropNetLinkActive, active);
}
if (attach == TRUE) {
/* the interface was attached, remove stale state */
CFDictionaryRemoveValue(newDict, kSCPropNetLinkDetaching);
}
/* update status */
if (CFDictionaryGetCount(newDict) > 0) {
cache_SCDynamicStoreSetValue(store, key, newDict);
} else {
cache_SCDynamicStoreRemoveValue(store, key);
}
CFRelease(key);
CFRelease(newDict);
return;
}
__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;
}
__private_extern__
void
link_remove(const char *if_name)
{
CFStringRef interface;
CFStringRef cacheKey;
CFDictionaryRef dict;
CFMutableDictionaryRef newDict = NULL;
CFArrayRef ifList;
CFMutableArrayRef newIFList = NULL;
CFIndex i;
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 (!newIFList ||
((i = CFArrayGetFirstIndexOfValue(newIFList,
CFRangeMake(0, CFArrayGetCount(newIFList)),
interface)) == kCFNotFound)
) {
/* we're not tracking this interface */
goto done;
}
CFArrayRemoveValueAtIndex(newIFList, i);
CFDictionarySetValue(newDict, kSCPropNetInterfaces, newIFList);
cache_SCDynamicStoreSetValue(store, cacheKey, newDict);
interface_remove(if_name);
done:
CFRelease(cacheKey);
CFRelease(interface);
if (newDict) CFRelease(newDict);
if (newIFList) CFRelease(newIFList);
return;
}
__private_extern__
void
interface_detaching(const char *if_name)
{
CFStringRef key;
CFMutableDictionaryRef newDict;
key = create_interface_key(if_name);
newDict = copy_entity(key);
CFDictionarySetValue(newDict, kSCPropNetLinkDetaching,
kCFBooleanTrue);
cache_SCDynamicStoreSetValue(store, key, newDict);
CFRelease(newDict);
CFRelease(key);
return;
}
static void
updateStore(const void *key, const void *value, void *context)
{
CFDictionaryRef dict;
CFDictionaryRef newDict = (CFDictionaryRef)value;
CFDictionaryRef oldIFs = (CFDictionaryRef)context;
dict = CFDictionaryGetValue(oldIFs, key);
if (!dict || !CFEqual(dict, newDict)) {
if (CFDictionaryGetCount(newDict) > 0) {
cache_SCDynamicStoreSetValue(store, key, newDict);
} else if (dict) {
cache_SCDynamicStoreRemoveValue(store, key);
}
network_changed = TRUE;
}
return;
}
__private_extern__
void
interface_update_link_issues(const char *if_name,
uint64_t timestamp,
uint8_t *modid,
size_t modid_size,
uint8_t *info,
size_t info_size)
{
CFDataRef infoData;
CFStringRef key;
CFDataRef modidData;
CFMutableDictionaryRef newDict;
CFDateRef timeStamp;
key = create_link_issues_key(if_name);
newDict = copy_entity(key);
modidData = CFDataCreate(NULL, modid, modid_size);
CFDictionarySetValue(newDict, kSCPropNetLinkIssuesModuleID, modidData);
CFRelease(modidData);
if (info_size != 0) {
infoData = CFDataCreate(NULL, info, info_size);
CFDictionarySetValue(newDict, kSCPropNetLinkIssuesInfo, infoData);
CFRelease(infoData);
} else {
CFDictionaryRemoveValue(newDict, kSCPropNetLinkIssuesInfo);
}
timeStamp = CFDateCreate(NULL, timestamp);
CFDictionarySetValue(newDict, kSCPropNetLinkIssuesTimeStamp, timeStamp);
CFRelease(timeStamp);
cache_SCDynamicStoreSetValue(store, key, newDict);
CFRelease(newDict);
CFRelease(key);
return;
}
static void
updateStore(const void *key, const void *value, void *context)
{
CFDictionaryRef dict;
CFDictionaryRef newDict = (CFDictionaryRef)value;
CFDictionaryRef oldIFs = (CFDictionaryRef)context;
dict = CFDictionaryGetValue(oldIFs, key);
if (!dict || !CFEqual(dict, newDict)) {
if (CFDictionaryGetCount(newDict) > 0) {
SC_log(LOG_DEBUG, "Update interface configuration: %@: %@", key, newDict);
cache_SCDynamicStoreSetValue(store, key, newDict);
} else if (dict) {
SC_log(LOG_DEBUG, "Update interface configuration: %@: <removed>", key);
cache_SCDynamicStoreRemoveValue(store, key);
}
network_changed = TRUE;
}
return;
}
static boolean_t
updateConfiguration(int *newState)
{
boolean_t changed = FALSE;
CFStringRef computerName;
CFStringEncoding computerNameEncoding;
CFArrayRef configuredServices = NULL;
CFDictionaryRef dict;
CFIndex i;
CFIndex ifCount = 0;
CFMutableArrayRef info = NULL;
CFArrayRef interfaces = NULL;
CFStringRef key;
CFArrayRef keys;
CFIndex n;
CFMutableArrayRef newConfigFile;
CFMutableDictionaryRef newDefaults;
CFMutableDictionaryRef newDict;
CFMutableDictionaryRef newGlobals;
CFMutableDictionaryRef newGlobalsX; /* newGlobals without ServiceID */
CFMutableDictionaryRef newStartup;
CFMutableDictionaryRef newZones;
CFNumberRef num;
CFMutableDictionaryRef curGlobalsX; /* curGlobals without ServiceID */
CFStringRef pattern;
boolean_t postGlobals = FALSE;
CFStringRef primaryPort = NULL; /* primary interface */
CFStringRef primaryZone = NULL;
CFArrayRef serviceOrder = NULL;
CFDictionaryRef setGlobals = NULL;
cache_open();
/*
* establish the "new" AppleTalk configuration
*/
*newState = curState;
newConfigFile = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
newGlobals = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
newDefaults = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
newStartup = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
newZones = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
/* initialize overall state */
CFDictionarySetValue(newStartup, CFSTR("APPLETALK"), CFSTR("-NO-"));
/*
* get the global settings (ServiceOrder, ComputerName, ...)
*/
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainSetup,
kSCEntNetAppleTalk);
setGlobals = cache_SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (setGlobals) {
if (isA_CFDictionary(setGlobals)) {
/* get service order */
serviceOrder = CFDictionaryGetValue(setGlobals,
kSCPropNetServiceOrder);
serviceOrder = isA_CFArray(serviceOrder);
if (serviceOrder) {
CFRetain(serviceOrder);
}
} else {
CFRelease(setGlobals);
setGlobals = NULL;
}
}
/*
* if we don't have an AppleTalk ServiceOrder, use IPv4's (if defined)
*/
if (!serviceOrder) {
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainSetup,
kSCEntNetIPv4);
dict = cache_SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict) {
if (isA_CFDictionary(dict)) {
serviceOrder = CFDictionaryGetValue(dict,
kSCPropNetServiceOrder);
serviceOrder = isA_CFArray(serviceOrder);
if (serviceOrder) {
CFRetain(serviceOrder);
}
}
CFRelease(dict);
}
}
/*
* get the list of ALL configured services
*/
configuredServices = entity_all(store, kSCEntNetAppleTalk, serviceOrder);
if (configuredServices) {
ifCount = CFArrayGetCount(configuredServices);
}
if (serviceOrder) CFRelease(serviceOrder);
/*
* get the list of ALL active interfaces
*/
key = SCDynamicStoreKeyCreateNetworkInterface(NULL, kSCDynamicStoreDomainState);
dict = cache_SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict) {
if (isA_CFDictionary(dict)) {
interfaces = CFDictionaryGetValue(dict,
kSCDynamicStorePropNetInterfaces);
interfaces = isA_CFArray(interfaces);
if (interfaces) {
CFRetain(interfaces);
}
}
CFRelease(dict);
}
/*
* get the list of previously configured services
*/
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainState,
kSCCompAnyRegex,
kSCEntNetAppleTalk);
keys = SCDynamicStoreCopyKeyList(store, pattern);
CFRelease(pattern);
if (keys) {
info = CFArrayCreateMutableCopy(NULL, 0, keys);
CFRelease(keys);
}
/*
* iterate over each configured service to establish the new
* configuration.
*/
for (i = 0; i < ifCount; i++) {
CFDictionaryRef service;
CFStringRef ifName;
CFStringRef configMethod;
CFMutableStringRef portConfig = NULL;
CFArrayRef networkRange; /* for seed ports, CFArray[2] of CFNumber (lo, hi) */
int sNetwork;
int eNetwork;
CFArrayRef zoneList; /* for seed ports, CFArray[] of CFString (zones names) */
CFIndex zCount;
CFIndex j;
CFMutableDictionaryRef ifDefaults = NULL;
CFNumberRef defaultNetwork;
CFNumberRef defaultNode;
CFStringRef defaultZone;
/* get AppleTalk service dictionary */
service = CFArrayGetValueAtIndex(configuredServices, i);
/* get interface name */
ifName = CFDictionaryGetValue(service, kSCPropNetInterfaceDeviceName);
/* check inteface availability */
if (!interfaces ||
!CFArrayContainsValue(interfaces, CFRangeMake(0, CFArrayGetCount(interfaces)), ifName)) {
/* if interface not available */
goto nextIF;
}
/* check interface link status */
key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
kSCDynamicStoreDomainState,
ifName,
kSCEntNetLink);
dict = cache_SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict) {
Boolean linkStatus = TRUE; /* assume the link is "up" */
Boolean ifDetaching = FALSE; /* assume link is not detaching */
/* the link key for this interface is available */
if (isA_CFDictionary(dict)) {
CFBooleanRef bVal;
bVal = CFDictionaryGetValue(dict, kSCPropNetLinkActive);
if (isA_CFBoolean(bVal)) {
linkStatus = CFBooleanGetValue(bVal);
}
/* check if interface is detaching - value
doesn't really matter, only that it exists */
ifDetaching = CFDictionaryContainsKey(dict, kSCPropNetLinkDetaching);
}
CFRelease(dict);
if (!linkStatus || ifDetaching) {
/* if link status down or the interface is detaching */
goto nextIF;
}
}
/*
* Determine configuration method for this service
*/
configMethod = CFDictionaryGetValue(service, kSCPropNetAppleTalkConfigMethod);
if (!isA_CFString(configMethod)) {
/* if no ConfigMethod */
goto nextIF;
}
if (!CFEqual(configMethod, kSCValNetAppleTalkConfigMethodNode ) &&
!CFEqual(configMethod, kSCValNetAppleTalkConfigMethodRouter ) &&
!CFEqual(configMethod, kSCValNetAppleTalkConfigMethodSeedRouter)) {
/* if not one of the expected values, disable */
SCLog(TRUE, LOG_NOTICE,
CFSTR("Unexpected AppleTalk ConfigMethod: %@"),
configMethod);
goto nextIF;
}
/*
* the first service to be defined will always be "primary"
*/
if (CFArrayGetCount(newConfigFile) == 0) {
CFDictionaryRef active;
CFDictionarySetValue(newGlobals,
kSCDynamicStorePropNetPrimaryService,
CFDictionaryGetValue(service, CFSTR("ServiceID")));
CFDictionarySetValue(newGlobals,
kSCDynamicStorePropNetPrimaryInterface,
ifName);
/* and check if AT newtorking is active on the primary interface */
key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
kSCDynamicStoreDomainState,
ifName,
kSCEntNetAppleTalk);
active = cache_SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (active) {
if (isA_CFDictionary(active)) {
postGlobals = TRUE;
}
CFRelease(active);
}
}
/*
* define the port
*/
portConfig = CFStringCreateMutable(NULL, 0);
CFStringAppendFormat(portConfig, NULL, CFSTR("%@:"), ifName);
if (CFEqual(configMethod, kSCValNetAppleTalkConfigMethodSeedRouter)) {
CFNumberRef num;
/*
* we have been asked to configure this interface as a
* seed port. Ensure that we have been provided at least
* one network number, have been provided with at least
* one zonename, ...
*/
networkRange = CFDictionaryGetValue(service,
kSCPropNetAppleTalkSeedNetworkRange);
if (!isA_CFArray(networkRange) || (CFArrayGetCount(networkRange) == 0)) {
SCLog(TRUE, LOG_NOTICE,
CFSTR("AppleTalk configuration error (%@)"),
kSCPropNetAppleTalkSeedNetworkRange);
goto nextIF;
}
/*
* establish the starting and ending network numbers
*/
num = CFArrayGetValueAtIndex(networkRange, 0);
if (!isA_CFNumber(num)) {
SCLog(TRUE, LOG_NOTICE,
CFSTR("AppleTalk configuration error (%@)"),
kSCPropNetAppleTalkSeedNetworkRange);
goto nextIF;
}
CFNumberGetValue(num, kCFNumberIntType, &sNetwork);
eNetwork = sNetwork;
if (CFArrayGetCount(networkRange) > 1) {
num = CFArrayGetValueAtIndex(networkRange, 1);
if (!isA_CFNumber(num)) {
SCLog(TRUE, LOG_NOTICE,
CFSTR("AppleTalk configuration error (%@)"),
kSCPropNetAppleTalkSeedNetworkRange);
goto nextIF;
}
CFNumberGetValue(num, kCFNumberIntType, &eNetwork);
}
CFStringAppendFormat(portConfig, NULL, CFSTR("%d:%d:"), sNetwork, eNetwork);
/*
* establish the zones associated with this port
*/
zoneList = CFDictionaryGetValue(service,
kSCPropNetAppleTalkSeedZones);
if (!isA_CFArray(zoneList)) {
SCLog(TRUE, LOG_NOTICE,
CFSTR("AppleTalk configuration error (%@)"),
kSCPropNetAppleTalkSeedZones);
goto nextIF;
}
zCount = CFArrayGetCount(zoneList);
for (j = 0; j < zCount; j++) {
CFStringRef zone;
CFArrayRef ifList;
CFMutableArrayRef newIFList;
zone = CFArrayGetValueAtIndex(zoneList, j);
if (!isA_CFString(zone)) {
continue;
}
if (CFDictionaryGetValueIfPresent(newZones, zone, (const void **)&ifList)) {
/* known zone */
newIFList = CFArrayCreateMutableCopy(NULL, 0, ifList);
} else {
/* new zone */
newIFList = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
}
CFArrayAppendValue(newIFList, ifName);
CFArraySortValues(newIFList,
CFRangeMake(0, CFArrayGetCount(newIFList)),
(CFComparatorFunction)CFStringCompare,
NULL);
CFDictionarySetValue(newZones, zone, newIFList);
CFRelease(newIFList);
/*
* flag the default zone
*/
if (!primaryZone) {
primaryZone = CFRetain(zone);
}
}
if (!primaryZone) {
SCLog(TRUE, LOG_NOTICE,
CFSTR("AppleTalk configuration error (%@)"),
kSCPropNetAppleTalkSeedZones);
goto nextIF;
}
}
/* get the (per-interface) "Computer Name" */
computerName = CFDictionaryGetValue(service,
kSCPropNetAppleTalkComputerName);
if (CFDictionaryGetValueIfPresent(service,
kSCPropNetAppleTalkComputerNameEncoding,
(const void **)&num) &&
isA_CFNumber(num)) {
CFNumberGetValue(num, kCFNumberIntType, &computerNameEncoding);
} else {
computerNameEncoding = CFStringGetSystemEncoding();
}
encodeName(computerName, computerNameEncoding, newStartup, newGlobals);
/*
* declare the first configured AppleTalk service / interface
* as the "home port".
*/
if (CFArrayGetCount(newConfigFile) == 0) {
CFStringAppend(portConfig, CFSTR("*"));
primaryPort = CFRetain(ifName);
}
CFArrayAppendValue(newConfigFile, portConfig);
/*
* get the per-interface defaults
*/
ifDefaults = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
defaultNetwork = CFDictionaryGetValue(service, kSCPropNetAppleTalkNetworkID);
defaultNode = CFDictionaryGetValue(service, kSCPropNetAppleTalkNodeID);
if (isA_CFNumber(defaultNetwork) && isA_CFNumber(defaultNode)) {
/*
* set the default node and network
*/
CFDictionarySetValue(ifDefaults,
kSCPropNetAppleTalkNetworkID,
defaultNetwork);
CFDictionarySetValue(ifDefaults,
kSCPropNetAppleTalkNodeID,
defaultNode);
}
if ((CFDictionaryGetValueIfPresent(service,
kSCPropNetAppleTalkDefaultZone,
(const void **)&defaultZone) == TRUE)) {
/*
* set the default zone for this interface
*/
CFDictionarySetValue(ifDefaults,
kSCPropNetAppleTalkDefaultZone,
defaultZone);
}
CFDictionarySetValue(newDefaults, ifName, ifDefaults);
CFRelease(ifDefaults);
switch (CFArrayGetCount(newConfigFile)) {
case 1:
/*
* first AppleTalk interface
*/
CFDictionarySetValue(newStartup, CFSTR("APPLETALK"), ifName);
break;
case 2:
/* second AppleTalk interface */
if (!CFEqual(CFDictionaryGetValue(newStartup, CFSTR("APPLETALK")),
CFSTR("-ROUTER-"))) {
/*
* if not routing (yet), configure as multi-home
*/
CFDictionarySetValue(newStartup, CFSTR("APPLETALK"), CFSTR("-MULTIHOME-"));
}
break;
}
if (CFEqual(configMethod, kSCValNetAppleTalkConfigMethodRouter) ||
CFEqual(configMethod, kSCValNetAppleTalkConfigMethodSeedRouter)) {
/* if not a simple node, enable routing */
CFDictionarySetValue(newStartup, CFSTR("APPLETALK"), CFSTR("-ROUTER-"));
}
/*
* establish the State:/Network/Service/nnn/AppleTalk key info
*/
key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainState,
CFDictionaryGetValue(service, CFSTR("ServiceID")),
kSCEntNetAppleTalk);
newDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(newDict, kSCPropInterfaceName, ifName);
cache_SCDynamicStoreSetValue(store, key, newDict);
CFRelease(newDict);
if (info) {
j = CFArrayGetFirstIndexOfValue(info,
CFRangeMake(0, CFArrayGetCount(info)),
key);
if (j != kCFNotFound) {
CFArrayRemoveValueAtIndex(info, j);
}
}
CFRelease(key);
nextIF :
if (portConfig) CFRelease(portConfig);
}
if (primaryZone) {
CFArrayRef ifList;
CFMutableArrayRef newIFList;
ifList = CFDictionaryGetValue(newZones, primaryZone);
if (CFArrayContainsValue(ifList,
CFRangeMake(0, CFArrayGetCount(ifList)),
primaryPort)) {
newIFList = CFArrayCreateMutableCopy(NULL, 0, ifList);
CFArrayAppendValue(newIFList, CFSTR("*"));
CFDictionarySetValue(newZones, primaryZone, newIFList);
CFRelease(newIFList);
}
CFRelease(primaryZone);
}
if (primaryPort) {
CFRelease(primaryPort);
}
/* sort the ports */
i = CFArrayGetCount(newConfigFile);
CFArraySortValues(newConfigFile,
CFRangeMake(0, i),
(CFComparatorFunction)CFStringCompare,
NULL);
/* add the zones to the configuration */
CFDictionaryApplyFunction(newZones, addZoneToPorts, newConfigFile);
CFRelease(newZones);
/* sort the zones */
CFArraySortValues(newConfigFile,
CFRangeMake(i, CFArrayGetCount(newConfigFile)-i),
(CFComparatorFunction)CFStringCompare,
NULL);
/* ensure that the last line of the configuration file is terminated */
CFArrayAppendValue(newConfigFile, CFSTR(""));
/*
* Check if we have a "ComputerName" and look elsewhere if we don't have
* one yet.
*/
if (!CFDictionaryContainsKey(newStartup, CFSTR("APPLETALK_HOSTNAME")) &&
(setGlobals != NULL)) {
computerName = CFDictionaryGetValue(setGlobals,
kSCPropNetAppleTalkComputerName);
if (CFDictionaryGetValueIfPresent(setGlobals,
kSCPropNetAppleTalkComputerNameEncoding,
(const void **)&num) &&
isA_CFNumber(num)) {
CFNumberGetValue(num, kCFNumberIntType, &computerNameEncoding);
} else {
computerNameEncoding = CFStringGetSystemEncoding();
}
encodeName(computerName, computerNameEncoding, newStartup, newGlobals);
}
if (!CFDictionaryContainsKey(newStartup, CFSTR("APPLETALK_HOSTNAME"))) {
computerName = SCDynamicStoreCopyComputerName(store, &computerNameEncoding);
if (computerName) {
encodeName(computerName, computerNameEncoding, newStartup, newGlobals);
CFRelease(computerName);
}
}
if (!CFDictionaryContainsKey(newStartup, CFSTR("APPLETALK_HOSTNAME"))) {
struct utsname name;
if (uname(&name) == 0) {
computerName = CFStringCreateWithCString(NULL, name.nodename, kCFStringEncodingASCII);
if (computerName) {
encodeName(computerName, kCFStringEncodingASCII, NULL, newGlobals);
CFRelease(computerName);
}
}
}
/* compare the previous and current configurations */
curGlobalsX = CFDictionaryCreateMutableCopy(NULL, 0, curGlobals);
CFDictionaryRemoveValue(curGlobalsX, kSCDynamicStorePropNetPrimaryService);
newGlobalsX = CFDictionaryCreateMutableCopy(NULL, 0, newGlobals);
CFDictionaryRemoveValue(newGlobalsX, kSCDynamicStorePropNetPrimaryService);
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainState,
kSCEntNetAppleTalk);
if (CFEqual(curGlobalsX , newGlobalsX ) &&
CFEqual(curConfigFile , newConfigFile) &&
CFEqual(curDefaults , newDefaults ) &&
CFEqual(curStartup , newStartup )
) {
/*
* the configuration has not changed.
*/
if (postGlobals) {
/*
* the requested configuration hasn't changed but we
* now need to tell everyone that AppleTalk is active.
*/
if (!SCDynamicStoreSetValue(store, key, newGlobals)) {
SCLog(TRUE,
LOG_ERR,
CFSTR("SCDynamicStoreSetValue() failed: %s"),
SCErrorString(SCError()));
}
}
CFRelease(newGlobals);
CFRelease(newConfigFile);
CFRelease(newDefaults);
CFRelease(newStartup);
} else if (CFArrayGetCount(newConfigFile) <= 1) {
/*
* the configuration has changed but there are no
* longer any interfaces configured for AppleTalk
* networking.
*/
/*
* remove the global (State:/Network/Global/AppleTalk) key.
*
* Note: it will be restored later after AT networking has
* been activated.
*/
/* remove the (/etc/appletalk.cfg) configuration file */
(void)unlink(AT_CFG_FILE);
/*
* update the per-service (and global) state
*/
cache_SCDynamicStoreRemoveValue(store, key); // remove State:/Network/Global/AppleTalk
n = CFArrayGetCount(info);
for (i = 0; i < n; i++) {
CFStringRef xKey = CFArrayGetValueAtIndex(info, i);
cache_SCDynamicStoreRemoveValue(store, xKey);
}
cache_write(store);
/* flag this as a new configuration */
*newState = -(abs(curState) + 1);
changed = TRUE;
} else {
/*
* the configuration has changed.
*/
/* update the (/etc/appletalk.cfg) configuration file */
configWrite(AT_CFG_FILE, newConfigFile);
/*
* update the per-service (and global) state
*
* Note: if present, we remove any existing global state key and allow it
* to be restored after the stack has been re-started.
*/
CFDictionaryApplyFunction(newDefaults, updateDefaults, NULL);
cache_SCDynamicStoreRemoveValue(store, key); // remove State:/Network/Global/AppleTalk
n = CFArrayGetCount(info);
for (i = 0; i < n; i++) {
CFStringRef xKey = CFArrayGetValueAtIndex(info, i);
cache_SCDynamicStoreRemoveValue(store, xKey);
}
cache_write(store);
/* flag this as a new configuration */
*newState = abs(curState) + 1;
changed = TRUE;
}
CFRelease(curGlobalsX);
CFRelease(newGlobalsX);
CFRelease(key);
if (changed) {
CFRelease(curGlobals);
curGlobals = newGlobals;
CFRelease(curConfigFile);
curConfigFile = newConfigFile;
CFRelease(curDefaults);
curDefaults = newDefaults;
CFRelease(curStartup);
curStartup = newStartup;
}
if (info) CFRelease(info);
if (interfaces) CFRelease(interfaces);
if (configuredServices) CFRelease(configuredServices);
if (setGlobals) CFRelease(setGlobals);
cache_close();
return changed;
}
