static void
dnssdUpdateDNSSDName(int from_callback) /* I - Called from callback? */
{
char webif[1024]; /* Web interface share name */
# ifdef __APPLE__
SCDynamicStoreRef sc; /* Context for dynamic store */
CFDictionaryRef btmm; /* Back-to-My-Mac domains */
CFStringEncoding nameEncoding; /* Encoding of computer name */
CFStringRef nameRef; /* Host name CFString */
char nameBuffer[1024]; /* C-string buffer */
# endif /* __APPLE__ */
/*
* Only share the web interface and printers when non-local listening is
* enabled...
*/
if (!DNSSDPort)
{
/*
* Get the port we use for registrations. If we are not listening on any
* non-local ports, there is no sense sharing local printers via Bonjour...
*/
cupsd_listener_t *lis; /* Current listening socket */
for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
lis;
lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
{
if (httpAddrLocalhost(&(lis->address)))
continue;
DNSSDPort = httpAddrPort(&(lis->address));
break;
}
}
if (!DNSSDPort)
return;
/*
* Get the computer name as a c-string...
*/
# ifdef __APPLE__
sc = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("cupsd"), NULL, NULL);
if (sc)
{
/*
* Get the computer name from the dynamic store...
*/
cupsdClearString(&DNSSDComputerName);
if ((nameRef = SCDynamicStoreCopyComputerName(sc, &nameEncoding)) != NULL)
{
if (CFStringGetCString(nameRef, nameBuffer, sizeof(nameBuffer),
kCFStringEncodingUTF8))
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Dynamic store computer name is \"%s\".", nameBuffer);
cupsdSetString(&DNSSDComputerName, nameBuffer);
}
CFRelease(nameRef);
}
if (!DNSSDComputerName)
{
/*
* Use the ServerName instead...
*/
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Using ServerName \"%s\" as computer name.", ServerName);
cupsdSetString(&DNSSDComputerName, ServerName);
}
/*
* Get the local hostname from the dynamic store...
*/
cupsdClearString(&DNSSDHostName);
if ((nameRef = SCDynamicStoreCopyLocalHostName(sc)) != NULL)
{
if (CFStringGetCString(nameRef, nameBuffer, sizeof(nameBuffer),
kCFStringEncodingUTF8))
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Dynamic store host name is \"%s\".", nameBuffer);
cupsdSetString(&DNSSDHostName, nameBuffer);
}
CFRelease(nameRef);
}
if (!DNSSDHostName)
{
/*
* Use the ServerName instead...
*/
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Using ServerName \"%s\" as host name.", ServerName);
cupsdSetString(&DNSSDHostName, ServerName);
}
/*
* Get any Back-to-My-Mac domains and add them as aliases...
*/
cupsdFreeAliases(DNSSDAlias);
DNSSDAlias = NULL;
btmm = SCDynamicStoreCopyValue(sc, CFSTR("Setup:/Network/BackToMyMac"));
if (btmm && CFGetTypeID(btmm) == CFDictionaryGetTypeID())
{
cupsdLogMessage(CUPSD_LOG_DEBUG, "%d Back to My Mac aliases to add.",
(int)CFDictionaryGetCount(btmm));
CFDictionaryApplyFunction(btmm, dnssdAddAlias, NULL);
}
else if (btmm)
cupsdLogMessage(CUPSD_LOG_ERROR,
"Bad Back to My Mac data in dynamic store!");
else
cupsdLogMessage(CUPSD_LOG_DEBUG, "No Back to My Mac aliases to add.");
if (btmm)
CFRelease(btmm);
CFRelease(sc);
}
else
# endif /* __APPLE__ */
# ifdef HAVE_AVAHI
if (DNSSDClient)
{
const char *host_name = avahi_client_get_host_name(DNSSDClient);
const char *host_fqdn = avahi_client_get_host_name_fqdn(DNSSDClient);
cupsdSetString(&DNSSDComputerName, host_name ? host_name : ServerName);
if (host_fqdn)
cupsdSetString(&DNSSDHostName, host_fqdn);
else if (strchr(ServerName, '.'))
cupsdSetString(&DNSSDHostName, ServerName);
else
cupsdSetStringf(&DNSSDHostName, "%s.local", ServerName);
}
else
# endif /* HAVE_AVAHI */
{
cupsdSetString(&DNSSDComputerName, ServerName);
if (strchr(ServerName, '.'))
cupsdSetString(&DNSSDHostName, ServerName);
else
cupsdSetStringf(&DNSSDHostName, "%s.local", ServerName);
}
/*
* Then (re)register the web interface if enabled...
*/
if (BrowseWebIF)
{
if (DNSSDComputerName)
snprintf(webif, sizeof(webif), "CUPS @ %s", DNSSDComputerName);
else
strlcpy(webif, "CUPS", sizeof(webif));
dnssdDeregisterInstance(&WebIFSrv, from_callback);
dnssdRegisterInstance(&WebIFSrv, NULL, webif, "_http._tcp", "_printer", DNSSDPort, NULL, 1, from_callback);
}
}
static void
smb_set_configuration(SCDynamicStoreRef store, CFDictionaryRef dict)
{
CFArrayRef array;
Boolean changed = FALSE;
UInt32 dosCodepage = 0;
CFStringEncoding dosEncoding = 0;
CFStringEncoding macEncoding = kCFStringEncodingMacRoman;
uint32_t macRegion = 0;
Boolean ok;
SCPreferencesRef prefs;
CFStringRef str;
prefs = SCPreferencesCreate(NULL, CFSTR("smb-configuration"), CFSTR(kSMBPreferencesAppID));
if (prefs == NULL) {
my_log(LOG_ERR,
"smb_set_configuration: SCPreferencesCreate() failed: %s",
SCErrorString(SCError()));
return;
}
ok = SCPreferencesLock(prefs, TRUE);
if (!ok) {
my_log(LOG_ERR,
"smb_set_configuration: SCPreferencesLock() failed: %s",
SCErrorString(SCError()));
goto done;
}
// Server description
str = SCDynamicStoreCopyComputerName(store, &macEncoding);
update_pref(prefs, CFSTR(kSMBPrefServerDescription), str, &changed);
// DOS code page
if (str != NULL) {
if (macEncoding == kCFStringEncodingMacRoman) {
CFStringRef key;
CFDictionaryRef dict;
// get region
key = SCDynamicStoreKeyCreateComputerName(NULL);
dict = SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (dict != NULL) {
if (isA_CFDictionary(dict)) {
CFNumberRef num;
SInt32 val;
num = CFDictionaryGetValue(dict, kSCPropSystemComputerNameRegion);
if (isA_CFNumber(num) &&
CFNumberGetValue(num, kCFNumberSInt32Type, &val)) {
macRegion = (uint32_t)val;
}
}
CFRelease(dict);
}
}
CFRelease(str);
} else {
// Important: must have root acccess (eUID==0) to access the config file!
__CFStringGetInstallationEncodingAndRegion((uint32_t *)&macEncoding, &macRegion);
}
_SC_dos_encoding_and_codepage(macEncoding, macRegion, &dosEncoding, &dosCodepage);
str = CFStringCreateWithFormat(NULL, NULL, CFSTR("%d"), (unsigned int)dosCodepage);
assert(str != NULL);
update_pref(prefs, CFSTR(kSMBPrefDOSCodePage), str, &changed);
CFRelease(str);
// NetBIOS name
str = CFDictionaryGetValue(dict, kSCPropNetSMBNetBIOSName);
str = isA_CFString(str);
update_pref(prefs, CFSTR(kSMBPrefNetBIOSName), str, &changed);
// NetBIOS node type
str = CFDictionaryGetValue(dict, kSCPropNetSMBNetBIOSNodeType);
str = isA_CFString(str);
if (str != NULL) {
if (CFEqual(str, kSCValNetSMBNetBIOSNodeTypeBroadcast)) {
// B-node
str = CFSTR(kSMBPrefNetBIOSNodeBroadcast);
} else if (CFEqual(str, kSCValNetSMBNetBIOSNodeTypePeer)) {
// P-node
str = CFSTR(kSMBPrefNetBIOSNodePeer);
} else if (CFEqual(str, kSCValNetSMBNetBIOSNodeTypeMixed)) {
// M-node
str = CFSTR(kSMBPrefNetBIOSNodeMixed);
} else if (CFEqual(str, kSCValNetSMBNetBIOSNodeTypeHybrid)) {
// H-node
str = CFSTR(kSMBPrefNetBIOSNodeHybrid);
} else {
str = NULL;
}
}
update_pref(prefs, CFSTR(kSMBPrefNetBIOSNodeType), str, &changed);
#ifdef ADD_NETBIOS_SCOPE
// NetBIOS scope
str = CFDictionaryGetValue(dict, kSCPropNetSMBNetBIOSScope);
str = isA_CFString(str);
update_pref(prefs, CFSTR(kSMBPrefNetBIOSScope), str, &changed);
#endif // ADD_NETBIOS_SCOPE
// WINS addresses
array = CFDictionaryGetValue(dict, kSCPropNetSMBWINSAddresses);
array = isA_CFArray(array);
update_pref(prefs, CFSTR(kSMBPrefWINSServerAddressList), array, &changed);
// Workgroup (or domain)
str = CFDictionaryGetValue(dict, kSCPropNetSMBWorkgroup);
str = isA_CFString(str);
update_pref(prefs, CFSTR(kSMBPrefWorkgroup), str, &changed);
if (changed) {
ok = SCPreferencesCommitChanges(prefs);
if (!ok) {
if ((SCError() != EROFS)) {
my_log(LOG_ERR,
"smb_set_configuration: SCPreferencesCommitChanges() failed: %s",
SCErrorString(SCError()));
}
goto done;
}
ok = SCPreferencesApplyChanges(prefs);
if (!ok) {
my_log(LOG_ERR,
"smb_set_configuration: SCPreferencesApplyChanges() failed: %s",
SCErrorString(SCError()));
goto done;
}
}
done :
(void) SCPreferencesUnlock(prefs);
CFRelease(prefs);
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;
}
PsychError SCREENComputer(void)
{
const char *majorStructFieldNames[]={"macintosh", "windows", "osx" ,"linux", "kern", "hw", "processUserLongName",
"processUserShortName", "consoleUserName", "machineName", "localHostName", "location", "MACAddress", "system", "gstreamer", "supported" };
const char *kernStructFieldNames[]={"ostype", "osrelease", "osrevision", "version","hostname"};
const char *hwStructFieldNames[]={"machine", "model", "ncpu", "physmem", "usermem", "busfreq", "cpufreq"};
int numMajorStructDimensions=-1, numKernStructDimensions=-1, numHwStructDimensions=-1;
int numMajorStructFieldNames=16, numKernStructFieldNames=5, numHwStructFieldNames=7;
PsychGenericScriptType *kernStruct, *hwStruct, *majorStruct;
//char tempStr[CTL_MAXNAME]; //this seems like a bug in Darwin, CTL_MAXNAME is shorter than the longest name.
char tempStr[256], *ethernetMACStr;
size_t tempIntSize, tempStrSize, tempULongIntSize;
int mib[2];
int tempInt;
psych_uint64 tempULongInt;
char *tempStrPtr;
CFStringRef tempCFStringRef;
psych_bool stringSuccess;
int stringLengthChars, ethernetMACStrSizeBytes;
long gestaltResult;
OSErr gestaltError;
int i,strIndex, bcdDigit, lengthSystemVersionString;
int osMajor, osMinor, osBugfix;
char systemVersionStr[256];
//all subfunctions should have these two lines
PsychPushHelp(useString, synopsisString, seeAlsoString);
if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);};
PsychErrorExit(PsychCapNumOutputArgs(1));
PsychErrorExit(PsychCapNumInputArgs(0));
//fill the major struct
PsychAllocOutStructArray(1, FALSE, numMajorStructDimensions, numMajorStructFieldNames, majorStructFieldNames, &majorStruct);
PsychSetStructArrayDoubleElement("macintosh", 0, 0, majorStruct);
PsychSetStructArrayDoubleElement("windows", 0, 0, majorStruct);
PsychSetStructArrayDoubleElement("linux", 0, 0, majorStruct);
PsychSetStructArrayDoubleElement("osx", 0, 1, majorStruct);
// Official support status:
PsychSetStructArrayStringElement("supported", 0, (char*) PsychSupportStatus(), majorStruct);
// GStreamer availability and rough version:
#if defined(PTB_USE_GSTREAMER)
#if GST_CHECK_VERSION(1,0,0)
PsychSetStructArrayDoubleElement("gstreamer", 0, 1 * 10000 + 0 * 100 + 0, majorStruct);
#else
PsychSetStructArrayDoubleElement("gstreamer", 0, 0 * 10000 + 10 * 100 + 0, majorStruct);
#endif
#else
PsychSetStructArrayDoubleElement("gstreamer", 0, 0, majorStruct);
#endif
//fill the kern struct and implant it within the major struct
PsychAllocOutStructArray(-1, FALSE, numKernStructDimensions, numKernStructFieldNames, kernStructFieldNames, &kernStruct);
mib[0]=CTL_KERN;
mib[1]=KERN_OSTYPE;
tempStrSize=sizeof(tempStr);
ReportSysctlError(sysctl(mib, 2, tempStr, &tempStrSize, NULL, 0));
PsychSetStructArrayStringElement("ostype", 0, tempStr, kernStruct);
mib[1]=KERN_OSRELEASE;
tempStrSize=sizeof(tempStr);
ReportSysctlError(sysctl(mib, 2, tempStr, &tempStrSize, NULL, 0));
PsychSetStructArrayStringElement("osrelease", 0, tempStr, kernStruct);
mib[1]=KERN_OSREV;
tempIntSize=sizeof(tempInt);
ReportSysctlError(sysctl(mib, 2, &tempInt, &tempIntSize, NULL, 0));
PsychSetStructArrayDoubleElement("osrevision", 0, (double)tempInt, kernStruct);
mib[1]=KERN_VERSION;
tempStrSize=sizeof(tempStr);
ReportSysctlError(sysctl(mib, 2, tempStr, &tempStrSize, NULL, 0));
PsychSetStructArrayStringElement("version", 0, tempStr, kernStruct);
mib[1]=KERN_HOSTNAME;
tempStrSize=sizeof(tempStr);
ReportSysctlError(sysctl(mib, 2, tempStr, &tempStrSize, NULL, 0));
PsychSetStructArrayStringElement("hostname", 0, tempStr, kernStruct);
PsychSetStructArrayStructElement("kern",0, kernStruct, majorStruct);
//fill the hw struct and implant it within the major struct
PsychAllocOutStructArray(-1, FALSE, numHwStructDimensions, numHwStructFieldNames, hwStructFieldNames, &hwStruct);
mib[0]=CTL_HW;
mib[1]=HW_MACHINE;
tempStrSize=sizeof(tempStr);
ReportSysctlError(sysctl(mib, 2, tempStr, &tempStrSize, NULL, 0));
PsychSetStructArrayStringElement("machine", 0, tempStr, hwStruct);
mib[1]=HW_MODEL;
tempStrSize=sizeof(tempStr);
ReportSysctlError(sysctl(mib, 2, tempStr, &tempStrSize, NULL, 0));
PsychSetStructArrayStringElement("model", 0, tempStr, hwStruct);
mib[1]=HW_NCPU;
tempIntSize=sizeof(tempInt);
ReportSysctlError(sysctl(mib, 2, &tempInt, &tempIntSize, NULL, 0));
PsychSetStructArrayDoubleElement("ncpu", 0, (double)tempInt, hwStruct);
mib[1]=HW_MEMSIZE;
tempULongIntSize=sizeof(tempULongInt);
tempULongInt = 0;
ReportSysctlError(sysctl(mib, 2, &tempULongInt, &tempULongIntSize, NULL, 0));
PsychSetStructArrayDoubleElement("physmem", 0, (double)tempULongInt, hwStruct);
mib[1]=HW_USERMEM;
tempULongIntSize=sizeof(tempULongInt);
tempULongInt = 0;
ReportSysctlError(sysctlbyname("hw.usermem", &tempULongInt, &tempULongIntSize, NULL, 0));
PsychSetStructArrayDoubleElement("usermem", 0, (double)tempULongInt, hwStruct);
mib[1]=HW_BUS_FREQ;
tempULongIntSize=sizeof(tempULongInt);
tempULongInt = 0;
ReportSysctlError(sysctlbyname("hw.busfrequency", &tempULongInt, &tempULongIntSize, NULL, 0));
PsychSetStructArrayDoubleElement("busfreq", 0, (double)tempULongInt, hwStruct);
mib[1]=HW_CPU_FREQ;
tempULongIntSize=sizeof(tempULongInt);
tempULongInt = 0;
ReportSysctlError(sysctlbyname("hw.cpufrequency", &tempULongInt, &tempULongIntSize, NULL, 0));
PsychSetStructArrayDoubleElement("cpufreq", 0, (double)tempULongInt, hwStruct);
PsychSetStructArrayStructElement("hw",0, hwStruct, majorStruct);
//fill in the process user, console user and machine name in the root struct.
tempCFStringRef = SCDynamicStoreCopyComputerName(NULL, NULL);
if (tempCFStringRef) {
stringLengthChars=(int) CFStringGetMaximumSizeForEncoding(CFStringGetLength(tempCFStringRef), kCFStringEncodingASCII);
tempStrPtr=malloc(sizeof(char) * (stringLengthChars+1));
stringSuccess= CFStringGetCString(tempCFStringRef, tempStrPtr, stringLengthChars+1, kCFStringEncodingASCII);
if(stringSuccess) {
PsychSetStructArrayStringElement("machineName", 0, tempStrPtr, majorStruct);
}
else {
PsychSetStructArrayStringElement("machineName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
free(tempStrPtr);
CFRelease(tempCFStringRef);
}
else {
PsychSetStructArrayStringElement("machineName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
struct passwd* thisUser = getpwuid(getuid());
if (thisUser) {
PsychSetStructArrayStringElement("processUserShortName", 0, thisUser->pw_name, majorStruct);
}
else {
PsychSetStructArrayStringElement("processUserShortName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
PsychSetStructArrayStringElement("processUserLongName", 0, PsychCocoaGetFullUsername(), majorStruct);
tempCFStringRef= SCDynamicStoreCopyConsoleUser(NULL, NULL, NULL);
if (tempCFStringRef) {
stringLengthChars=(int) CFStringGetMaximumSizeForEncoding(CFStringGetLength(tempCFStringRef), kCFStringEncodingASCII);
tempStrPtr=malloc(sizeof(char) * (stringLengthChars+1));
stringSuccess= CFStringGetCString(tempCFStringRef, tempStrPtr, stringLengthChars+1, kCFStringEncodingASCII);
if(stringSuccess) {
PsychSetStructArrayStringElement("consoleUserName", 0, tempStrPtr, majorStruct);
}
else {
PsychSetStructArrayStringElement("consoleUserName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
free(tempStrPtr);
CFRelease(tempCFStringRef);
}
else {
PsychSetStructArrayStringElement("consoleUserName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
tempCFStringRef= SCDynamicStoreCopyLocalHostName(NULL);
if (tempCFStringRef) {
stringLengthChars=(int) CFStringGetMaximumSizeForEncoding(CFStringGetLength(tempCFStringRef), kCFStringEncodingASCII);
tempStrPtr=malloc(sizeof(char) * (stringLengthChars+1));
stringSuccess= CFStringGetCString(tempCFStringRef, tempStrPtr, stringLengthChars+1, kCFStringEncodingASCII);
if(stringSuccess) {
PsychSetStructArrayStringElement("localHostName", 0, tempStrPtr, majorStruct);
}
else {
PsychSetStructArrayStringElement("localHostName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
free(tempStrPtr);
CFRelease(tempCFStringRef);
}
else {
PsychSetStructArrayStringElement("localHostName", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
tempCFStringRef= SCDynamicStoreCopyLocation(NULL);
if (tempCFStringRef) {
stringLengthChars=(int) CFStringGetMaximumSizeForEncoding(CFStringGetLength(tempCFStringRef), kCFStringEncodingASCII);
tempStrPtr=malloc(sizeof(char) * (stringLengthChars+1));
stringSuccess= CFStringGetCString(tempCFStringRef, tempStrPtr, stringLengthChars+1, kCFStringEncodingASCII);
if(stringSuccess) {
PsychSetStructArrayStringElement("location", 0, tempStrPtr, majorStruct);
}
else {
PsychSetStructArrayStringElement("location", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
free(tempStrPtr);
CFRelease(tempCFStringRef);
}
else {
PsychSetStructArrayStringElement("location", 0, "UNKNOWN! QUERY FAILED DUE TO EMPTY OR PROBLEMATIC NAME.", majorStruct);
}
//Add the ethernet MAC address of the primary ethernet interface to the stuct. This can serve as a unique identifier for the computer.
ethernetMACStrSizeBytes=GetPrimaryEthernetAddressStringLengthBytes(TRUE)+1;
ethernetMACStr=(char*) malloc(sizeof(char) * ethernetMACStrSizeBytes);
GetPrimaryEthernetAddressString(ethernetMACStr, TRUE, TRUE);
PsychSetStructArrayStringElement("MACAddress", 0, ethernetMACStr, majorStruct);
free(ethernetMACStr);
//Add the system version string:
PsychCocoaGetOSXVersion(&osMajor, &osMinor, &osBugfix);
sprintf(systemVersionStr, "Mac OS %i.%i.%i", osMajor, osMinor, osBugfix);
//embed it in the return struct
PsychSetStructArrayStringElement("system", 0, systemVersionStr, majorStruct);
return(PsychError_none);
}
CFStringRef
CopyNextWorkstationName(SCDynamicStoreRef store, CFStringRef currentName)
{
CFMutableStringRef computerName = NULL;
CFStringRef macAddress = NULL;
if (currentName) {
/* Sanity check to make sure the current Workstation name is longer than the length of a MAC address string */
CFIndex totalLengh = CFStringGetLength(currentName);
if (totalLengh >= (CFIndex)kMACAddressLengh) {
/* Create a substring that chops off the MAC addres, giving us the Computer Name */
CFRange range = CFRangeMake(0, totalLengh - kMACAddressLengh);
CFStringRef oldComputerName = CFStringCreateWithSubstring(NULL, currentName, range);
/* If the Computer Name contains a trailing close paren it means that this name may have
already experienced a name conflict which means it could have a trailing digit to increment */
if (CFStringHasSuffix(oldComputerName, CFSTR(")"))) {
CFRange result;
/* Search for the first open paren, starting the search from the end of the Computer Name */
if (CFStringFindWithOptions(oldComputerName, CFSTR("("), range, kCFCompareBackwards, &result)) {
/* Create a substring which contains the contents between the open and close paren */
range = CFRangeMake(result.location + 1, CFStringGetLength(oldComputerName) - result.location - 2);
CFStringRef countString = CFStringCreateWithSubstring(NULL, currentName, range);
/* Try converting the substring to an integer */
SInt32 conflictCount = CFStringGetIntValue(countString);
if (conflictCount) {
/* Create a substring of just the Computer Name without the trailing open paren, conflict integer, close paren */
range = CFRangeMake(0, result.location);
CFStringRef tempComputerName = CFStringCreateWithSubstring(NULL, oldComputerName, range);
/* Create a mutable copy of the Computer Name base substring */
computerName = CFStringCreateMutableCopy(NULL, 0, tempComputerName);
/* Create a string containing a space, open paren, previous conflict digit incremented by one, close paren */
CFStringRef numberString = CFStringCreateWithFormat(NULL, NULL, CFSTR(" (%d)"), ++conflictCount);
/* Truncate the Computer Name base as neccessary to ensure we can append the conflict digits */
CFStringTruncateToUTF8Length(computerName, kMaxComputerName - CFStringGetLength(numberString));
/* Append the incremented conflict digit to the Computer Name base string */
CFStringAppend(computerName, numberString);
}
}
}
/* If computerName is NULL it means that the previous Computer Name didn't contain any conflict digits so append a " (2)" */
if (!computerName) {
/* Create mutable copy of previous Computer Name */
computerName = CFStringCreateMutableCopy(NULL, 0, oldComputerName);
/* Make sure we have enough room to append 4 characters to the name by truncating the Computer Name if neccessary */
CFStringTruncateToUTF8Length(computerName, kMaxComputerName - 4);
/* Append the name conflict digits */
CFStringAppend(computerName, CFSTR(" (2)"));
}
CFRelease(oldComputerName);
} else {
DbgLog( kLogError, "Workstation name is shorter than a MAC address which shouldn't be possible" );
}
} else {
/* There's currently no registered Workstation name so get the Computer Name from the dynamic store */
CFStringRef tempName = SCDynamicStoreCopyComputerName(store, NULL);
if (tempName) {
/* Create a mutable copy of the Computer Name */
computerName = CFStringCreateMutableCopy(NULL, 0, tempName);
CFRelease(tempName);
/* Truncate the Computer Name to ensure we can append the MAC address */
CFStringTruncateToUTF8Length(computerName, kMaxComputerName);
} else {
return NULL;
}
}
/* Copy the primary MAC address string */
macAddress = CopyPrimaryMacAddress();
if (!macAddress) {
if (computerName) {
CFRelease(computerName);
}
return NULL;
}
/* Append a space */
CFStringAppend(computerName, CFSTR(" "));
/* Append the MAC address string */
CFStringAppend(computerName, macAddress);
CFRelease(macAddress);
return computerName;
}
