/* 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;
}
__private_extern__
CFPropertyListRef
cache_SCDynamicStoreCopyValue(SCDynamicStoreRef store, CFStringRef key)
{
CFPropertyListRef value;
value = CFDictionaryGetValue(cached_set, key);
if (value) {
// if we have "set" a new value
return (CFRetain(value));
}
if (CFArrayContainsValue(cached_removals,
CFRangeMake(0, CFArrayGetCount(cached_removals)),
key)) {
// if we have "removed" the key
return NULL;
}
value = CFDictionaryGetValue(cached_keys, key);
if (value) {
// if we have a cached value
return (CFRetain(value));
}
value = SCDynamicStoreCopyValue(store, key);
if (value) {
CFDictionarySetValue(cached_keys, key, value);
}
return value;
}
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;
}
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_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;
}
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;
}
static int
S_wait_all(mach_port_t server, int argc, char * argv[])
{
CFMutableArrayRef keys;
SCDynamicStoreRef session;
CFRunLoopSourceRef rls;
unsigned long t = WAIT_ALL_DEFAULT_TIMEOUT;
CFPropertyListRef value;
struct itimerval v;
if (argc > 0) {
t = strtoul(argv[0], 0, 0);
if (t > WAIT_ALL_MAX_TIMEOUT) {
t = WAIT_ALL_MAX_TIMEOUT;
}
}
session = SCDynamicStoreCreate(NULL, CFSTR("ipconfig command"),
key_appeared, NULL);
if (session == NULL) {
fprintf(stderr, "SCDynamicStoreCreate failed: %s\n",
SCErrorString(SCError()));
return (0);
}
keys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(keys, STARTUP_KEY);
SCDynamicStoreSetNotificationKeys(session, keys, NULL);
CFRelease(keys);
rls = SCDynamicStoreCreateRunLoopSource(NULL, session, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
CFRelease(rls);
signal(SIGALRM, on_alarm);
bzero(&v, sizeof(v));
v.it_value.tv_sec = t;
if (setitimer(ITIMER_REAL, &v, NULL) < 0) {
perror("setitimer");
return (0);
}
value = SCDynamicStoreCopyValue(session, STARTUP_KEY);
if (value == NULL) {
CFRunLoopRun();
return (0);
}
CFRelease(value);
CFRelease(session);
return (0);
}
static
CFDictionaryRef _CFNetDiagnosticsGetDataFromSCDSAndThowAwayGarbage(CFAllocatorRef allocator, SCDynamicStoreRef store,
CFStringRef(*SCFunc)(CFAllocatorRef, CFStringRef, CFStringRef, CFStringRef), CFStringRef arg1, CFStringRef arg2, CFStringRef arg3) {
CFStringRef pattern = NULL;
CFDictionaryRef dict = NULL;
pattern = SCFunc(allocator, arg1, arg2, arg3);
if(pattern) {
dict = SCDynamicStoreCopyValue( store, pattern );
CFRelease(pattern);
}
return dict;
}
/* @function SystemLoadPrefsHaveChanged
* @abstract We check whether DIsplay Sleep Timer == 0
* Populates:
* displaySleepEnabled
*/
__private_extern__ void SystemLoadPrefsHaveChanged(void)
{
SCDynamicStoreRef _store = _getSharedPMDynamicStore();
CFDictionaryRef liveSettings = NULL;
CFNumberRef displaySleep = NULL;
CFTypeRef dwbt = NULL;
int idle, newDWBT;
static bool lastDisplaySleep = false;
static int lastDWBT = -1;
bool notify = false;
liveSettings = SCDynamicStoreCopyValue(_store,
CFSTR(kIOPMDynamicStoreSettingsKey));
if (liveSettings)
{
displaySleep = CFDictionaryGetValue(liveSettings,
CFSTR(kIOPMDisplaySleepKey));
if (displaySleep)
{
CFNumberGetValue(displaySleep, kCFNumberIntType, &idle);
displaySleepEnabled = idle ? true:false;
if (displaySleepEnabled != lastDisplaySleep)
{
lastDisplaySleep = displaySleepEnabled;
notify = true;
}
}
dwbt = CFDictionaryGetValue(liveSettings,
CFSTR(kIOPMDarkWakeBackgroundTaskKey));
if (dwbt)
{
newDWBT = CFBooleanGetValue(dwbt) ? 1 : 0;
if (lastDWBT != newDWBT)
{
lastDWBT = newDWBT;
notify = true;
}
}
CFRelease(liveSettings);
}
if (notify)
shareTheSystemLoad(kYesNotify);
return;
}
static
CFArrayRef copyCurrentDNSServers(void) {
SCDynamicStoreRef store;
CFPropertyListRef propList;
CFStringRef scdsRegexp;
CFArrayRef retval = NULL;
CFStringRef serviceID;
serviceID = copyCurrentPrimaryService();
if(serviceID) {
scdsRegexp = SCDynamicStoreKeyCreateNetworkServiceEntity (
kCFAllocatorDefault,
kSCDynamicStoreDomainState,
serviceID,
kSCEntNetDNS);
if(scdsRegexp) {
store = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("Network Diagnostics"), NULL, NULL);
if(store) {
propList = SCDynamicStoreCopyValue(store, scdsRegexp);
if(propList) {
retval = CFDictionaryGetValue(propList, CFSTR("ServerAddresses"));
if (retval) {
CFRetain(retval);
}
CFRelease(propList);
}
CFRelease(store);
}
CFRelease(scdsRegexp);
}
CFRelease(serviceID);
}
return retval;
}
static char *
getVPNInterfaceBuf (struct service *serv)
{
char *interface_buf;
SCLog(TRUE, LOG_INFO, CFSTR("%s:"), __FUNCTION__);
switch (serv->type) {
case TYPE_IPSEC:
interface_buf = serv->u.ipsec.lower_interface;
break;
case TYPE_PPP:
if (!serv->u.ppp.lower_interface[0]) {
CFStringRef string, key;
CFDictionaryRef dict;
SCLog(TRUE, LOG_INFO, CFSTR("%s: lower_interface is null"), __FUNCTION__);
/* TODO: this part should be change to grab the real lower interface instead of the primary */
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, kSCDynamicStoreDomainState, kSCEntNetIPv4);
if (key) {
dict = SCDynamicStoreCopyValue(gDynamicStore, key);
CFRelease(key);
if (dict) {
if ((string = CFDictionaryGetValue(dict, kSCDynamicStorePropNetPrimaryInterface))) {
CFStringGetCString(string, serv->u.ppp.lower_interface, sizeof(serv->u.ppp.lower_interface), kCFStringEncodingASCII);
SCLog(TRUE, LOG_INFO, CFSTR("%s: lower_interface is gotten %@"), __FUNCTION__, string);
}
CFRelease(dict);
}
}
}
interface_buf = serv->u.ppp.lower_interface;
SCLog(TRUE, LOG_INFO, CFSTR("%s: lower_interface is %s"), __FUNCTION__, interface_buf[0]? interface_buf : "null");
break;
default:
interface_buf = NULL;
break;
}
return interface_buf;
}
/* return AD realm if it exists */
const char *get_ad_realm ( struct auth_request *auth_request )
{
const char *out_realm = NULL;
SCDynamicStoreRef store = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("dovecot.digest.auth"), NULL, NULL);
if ( store ) {
CFDictionaryRef dict = SCDynamicStoreCopyValue(store, CFSTR("com.apple.opendirectoryd.ActiveDirectory"));
if (dict) {
CFStringRef domain = CFDictionaryGetValue(dict, CFSTR("DomainNameFlat"));
if (domain) {
const char *ad_realm = CFStringGetCStringPtr(domain, kCFStringEncodingUTF8);
if (ad_realm) {
auth_request_log_info(auth_request, "digest-md5", "ad realm: %s", ad_realm);
out_realm = t_strdup(ad_realm);
}
}
CFRelease(dict);
}
CFRelease(store);
}
return( out_realm );
}
/* _weManageUPSPower
*
* Determines whether X Power Management should do the emergency shutdown when low on UPS power.
* OS X should NOT manage low power situations if another third party application has already claimed
* that emergency shutdown responsibility.
*
* Return value:
* true == OS X should manage emergency shutdowns
* false == another installed & running application is managing shutdowns
*/
static bool
_weManageUPSPower(void)
{
static CFStringRef ups_claimed = NULL;
SCDynamicStoreRef ds_ref = NULL;
CFTypeRef temp;
bool ret_val = true;
if(!ups_claimed) {
ups_claimed = SCDynamicStoreKeyCreate(kCFAllocatorDefault, CFSTR("%@%@"), kSCDynamicStoreDomainState, CFSTR(kIOPSUPSManagementClaimed));
}
// Check for existence of "UPS Management claimed" key in SCDynamicStore
if( ups_claimed && ds_ref &&
(temp = SCDynamicStoreCopyValue(_getSharedPMDynamicStore(), ups_claimed)) )
{
if(kCFBooleanTrue == temp)
ret_val = false;
CFRelease(temp);
}
return ret_val;
}
static
CFStringRef copyCurrentPrimaryService(void) {
SCDynamicStoreRef store;
CFPropertyListRef propList;
CFStringRef retval = NULL;
store = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("Network Diagnostics"), NULL, NULL);
if(store) {
propList = SCDynamicStoreCopyValue(store, CFSTR("State:/Network/Global/IPv4"));
if(propList) {
retval = CFDictionaryGetValue(propList, CFSTR("PrimaryService"));
if (retval) {
CFRetain(retval);
}
CFRelease(propList);
}
CFRelease(store);
}
return retval;
}
void NetworkStateNotifier::updateState()
{
// Assume that we're offline until proven otherwise.
m_isOnLine = false;
RetainPtr<CFStringRef> str = adoptCF(SCDynamicStoreKeyCreateNetworkInterface(0, kSCDynamicStoreDomainState));
RetainPtr<CFPropertyListRef> propertyList = adoptCF(SCDynamicStoreCopyValue(m_store.get(), str.get()));
if (!propertyList)
return;
if (CFGetTypeID(propertyList.get()) != CFDictionaryGetTypeID())
return;
CFArrayRef netInterfaces = (CFArrayRef)CFDictionaryGetValue((CFDictionaryRef)propertyList.get(), kSCDynamicStorePropNetInterfaces);
if (CFGetTypeID(netInterfaces) != CFArrayGetTypeID())
return;
for (CFIndex i = 0; i < CFArrayGetCount(netInterfaces); i++) {
CFStringRef interface = (CFStringRef)CFArrayGetValueAtIndex(netInterfaces, i);
if (CFGetTypeID(interface) != CFStringGetTypeID())
continue;
// Ignore the loopback interface.
if (CFStringFind(interface, CFSTR("lo"), kCFCompareAnchored).location != kCFNotFound)
continue;
RetainPtr<CFStringRef> key = adoptCF(SCDynamicStoreKeyCreateNetworkInterfaceEntity(0, kSCDynamicStoreDomainState, interface, kSCEntNetIPv4));
RetainPtr<CFArrayRef> keyList = adoptCF(SCDynamicStoreCopyKeyList(m_store.get(), key.get()));
if (keyList && CFArrayGetCount(keyList.get())) {
m_isOnLine = true;
break;
}
}
}
static void
nc_ondemand_callback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)
{
CFStringRef key = NULL;
CFDictionaryRef ondemand_dict = NULL;
struct tm tm_now;
struct timeval tv_now;
if (CFArrayGetCount(changedKeys) < 1) {
return;
}
(void)gettimeofday(&tv_now, NULL);
(void)localtime_r(&tv_now.tv_sec, &tm_now);
SCPrint(TRUE, stdout, CFSTR("\n*** %2d:%02d:%02d.%03d\n\n"),
tm_now.tm_hour,
tm_now.tm_min,
tm_now.tm_sec,
tv_now.tv_usec / 1000);
if (ondemand_nodename) {
checkOnDemandHost(store, ondemand_nodename, FALSE);
checkOnDemandHost(store, ondemand_nodename, TRUE);
} else {
key = CFArrayGetValueAtIndex(changedKeys, 0);
ondemand_dict = SCDynamicStoreCopyValue(store, key);
if (ondemand_dict) {
SCPrint(TRUE, stdout, CFSTR("%@ %@\n"), kSCEntNetOnDemand, ondemand_dict);
} else {
SCPrint(TRUE, stdout, CFSTR("%@ not configured\n"), kSCEntNetOnDemand);
}
my_CFRelease(&ondemand_dict);
}
}
int
main(int argc, char **argv)
{
CFDictionaryRef entities;
CFStringRef key;
CFDictionaryRef newProxy = NULL;
CFStringRef pattern;
CFMutableArrayRef patterns;
CFStringRef primary = NULL;
CFMutableDictionaryRef primary_proxy = NULL;
CFArrayRef service_order = NULL;
CFMutableDictionaryRef service_state_dict;
CFDictionaryRef setup_global_ipv4;
CFDictionaryRef state_global_ipv4;
SCDynamicStoreRef store;
_sc_log = FALSE;
_sc_verbose = (argc > 1) ? TRUE : FALSE;
store = SCDynamicStoreCreate(NULL, CFSTR("TEST"), NULL, NULL);
// get IPv4, IPv6, and Proxies entities
patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainState,
kSCCompAnyRegex,
kSCEntNetIPv4);
CFArrayAppendValue(patterns, pattern);
CFRelease(pattern);
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainState,
kSCCompAnyRegex,
kSCEntNetIPv6);
CFArrayAppendValue(patterns, pattern);
CFRelease(pattern);
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainSetup,
kSCCompAnyRegex,
kSCEntNetProxies);
CFArrayAppendValue(patterns, pattern);
CFRelease(pattern);
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainState,
kSCCompAnyRegex,
kSCEntNetProxies);
CFArrayAppendValue(patterns, pattern);
CFRelease(pattern);
entities = SCDynamicStoreCopyMultiple(store, NULL, patterns);
CFRelease(patterns);
service_state_dict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionaryApplyFunction(entities, split, service_state_dict);
CFRelease(entities);
// get primary service ID
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainState,
kSCEntNetIPv4);
state_global_ipv4 = SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (state_global_ipv4 != NULL) {
primary = CFDictionaryGetValue(state_global_ipv4, kSCDynamicStorePropNetPrimaryService);
if (primary != NULL) {
CFDictionaryRef service_dict;
// get proxy configuration for primary service
service_dict = CFDictionaryGetValue(service_state_dict, primary);
if (service_dict != NULL) {
CFDictionaryRef service_proxy;
service_proxy = CFDictionaryGetValue(service_dict, kSCEntNetProxies);
if (service_proxy != NULL) {
primary_proxy = CFDictionaryCreateMutableCopy(NULL, 0, service_proxy);
CFDictionaryRemoveValue(primary_proxy, kSCPropInterfaceName);
}
}
}
}
// get serviceOrder
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
kSCDynamicStoreDomainSetup,
kSCEntNetIPv4);
setup_global_ipv4 = SCDynamicStoreCopyValue(store, key);
CFRelease(key);
if (setup_global_ipv4 != NULL) {
service_order = CFDictionaryGetValue(setup_global_ipv4, kSCPropNetServiceOrder);
}
// update proxy configuration
proxy_configuration_init(CFBundleGetMainBundle());
newProxy = proxy_configuration_update(primary_proxy,
service_state_dict,
service_order,
NULL);
if (newProxy != NULL) {
SCPrint(TRUE, stdout, CFSTR("%@\n"), newProxy);
CFRelease(newProxy);
}
// cleanup
if (setup_global_ipv4 != NULL) CFRelease(setup_global_ipv4);
if (state_global_ipv4 != NULL) CFRelease(state_global_ipv4);
CFRelease(service_state_dict);
CFRelease(store);
/* not reached */
exit(0);
return 0;
}
/* Main program */
int main (int argc, const char * argv[])
{
enum suspend_type {soft, dump, hard};
int vmmib[2] = {CTL_VM, VM_SWAPUSAGE};
int osmib[2] = {CTL_KERN, KERN_OSRELEASE};
int original_mode;
int target_mode;
int default_mode;
int original_profile;
int target_profile = -1;
void *refCon;
struct xsw_usage swap;
size_t swlen = sizeof(swap);
size_t oslen;
char *kernel_version;
int major_version = 0;
int minor_version = 0;
struct stat sleepimage;
/* By default, */
int do_sleep = 1; /* send the sleep call, */
int repair = 0; /* do not check the validity of the original hibernation mode, */
int check_hibernation = 1; /* check if the hibernation file is present, */
int check_os = 1; /* check if the operating system is supported, */
enum suspend_type target_suspend = soft; /* send computer to software suspend mode, */
int restore = 1; /* restore the original mode, */
if (argc >= 2) {
if (!strcmp(argv[1], "-v")) { /* Display version number if invoked with -v */
printf("deepsleep build %s\n", VERSION);
return 0;
} else if (!strcmp(argv[1], "-h")) {
printf("deepsleep usage: deepsleep [-bdhrvsu] [hard|dump|soft]\n");
printf(" -b : bypass the hibernation file check\n");
printf(" -d : debug mode - be verbose\n");
printf(" -h : display this help screen\n");
printf(" -m : mute - be silent\n");
printf(" -o : do not restore the original hibernation mode\n");
printf(" -r : repair the default hibernation mode if needed\n");
printf(" -s : simulation - do not send the computer to sleep\n");
printf(" -v : display version number\n");
printf(" -u : perform operations even on unsupported OS revisions\n");
printf(" hard : send computer to hardware suspend mode\n");
printf(" dump : send computer to safe hardware suspend mode\n");
printf(" soft : send computer to software suspend mode (by default)\n");
return 0;
} else {
if (argc >= 3) {
if (strstr(argv[1], "b")) /* Do not check the existence of the hibernation file if invoked with -b */
check_hibernation = 0;
if (strstr(argv[1], "d")) /* Print debug information if invoked with -d */
debug = 1;
if (strstr(argv[1], "o")) /* Do not restore the original hibernation mode if invoked with -o */
restore = 0;
if (strstr(argv[1], "r")) /* Check for the validity of the original hibernation mode if invoked with -r*/
repair = 1;
if (strstr(argv[1], "s")) /* Do not send the sleep call if invoked with -s */
do_sleep = 0;
if (strstr(argv[1], "u")) /* Do not care about OS revision if invoked with -u */
check_os = 0;
if (strstr(argv[1], "m"))
mute = 1;
}
if (strstr(argv[argc-1], "hard")) /* Send computer to hardware suspend mode instead of software suspend mode if the hard argument is present */
target_suspend = hard;
else if (strstr(argv[argc-1], "dump")) /* Send computer to safe hardware suspend mode instead of software suspend mode if the safe argument is present */
target_suspend = dump;
}
}
if (sysctl(osmib, 2, NULL, &oslen, NULL, 0) == -1) { /* Get the operating system revision length */
printf("Failed to get the operating system revision\n"); /* On failure: quit */
return 1;
} else {
kernel_version = malloc(oslen * sizeof(char));
sysctl(osmib, 2, kernel_version, &oslen, NULL, 0); /* Get the operating system revision length */
sscanf(kernel_version, "%d.%d", &major_version, &minor_version);
free(kernel_version);
}
if (debug) {
printf("OS revision: %d.%d", major_version, minor_version);
if (!check_os) printf(" (ignored)");
printf("\n");
}
if (check_os && (major_version != 8 || minor_version < 3) && (major_version <= 8)) { /* If needed, check if major version is 8 (Mac OS X 10.4) and minor version is greater or equal than 3. Mac OS X 10.5 is also supported.*/
printf("This operating system is not supported\n"); /* On failure: quit */
return 1;
}
if (check_hibernation && stat("/private/var/vm/sleepimage", &sleepimage)) { /* If needed, check if the hibernation file (/private/var/vm/sleepimage) exists */
printf("Hibernation file is missing\n"); /* On failure: quit */
return 1;
}
if (sysctl(vmmib, 2, &swap, &swlen, NULL, 0) == -1) { /* Get the current virtual memory parameters */
printf("Failed to get the virtual memory information\n"); /* On failure: quit */
return 1;
} else {
default_mode = 3;
if (target_suspend == dump) {
target_mode = default_mode; /* we will use the regular mode 3 for safe hardware suspsend */
} else /*if (target_suspend == soft)*/ {
target_mode = 25; /* or the regular mode 25 for software suspsend */
}
if (target_suspend == hard) /* If we only want to perform basic hardware suspend */
target_mode = 0; /* we will sleep with hibernate mode 0 */
if (debug) printf("target mode: %d\n", target_mode);
}
ps_info = IOPSCopyPowerSourcesInfo(); /* Get the power source information */
if (ps_info) {
current_ps = IOPSGetProvidingPowerSourceType(ps_info); /* On success, store the active power source */
} else {
printf("Failed to get the power source information\n"); /* On failure: quit */
return 1;
}
if (debug) printf("target power source: %s\n", CFStringGetCStringPtr(current_ps, kCFStringEncodingMacRoman));
active_prof = IOPMCopyActivePowerProfiles(); /* Get the power profiles */
if (!active_prof) {
printf("Failed to get the active profile\n");
CFCleanup();
return 1;
}
if (CFDictionaryContainsKey(active_prof, current_ps)) { /* Get the active profile corresponding to the current power source */
profile_ref = (CFNumberRef) CFDictionaryGetValue(active_prof, current_ps);
profile_type = CFNumberGetType(profile_ref);
CFNumberGetValue(profile_ref, profile_type, &original_profile); /* On succes, store its value */
if (debug) printf("original profile: %d\n", original_profile);
} else {
printf("Failed to get the power management settings\n"); /* On failure: quit */
CFCleanup();
return 1;
}
ds = SCDynamicStoreCreate(NULL, CFSTR("deepsleep"), NULL, NULL); /* Create a new dynamic store */
live_settings = SCDynamicStoreCopyValue(ds, CFSTR(kIOPMDynamicStoreSettingsKey)); /* Read current settings */
if(!isA_CFDictionary(live_settings)) { /* We did not get the settings: quit */
printf("Failed to get the power management settings\n");
CFCleanup();
return 1;
}
if (CFDictionaryContainsKey(live_settings, CFSTR("Hibernate Mode"))) { /* Check if the hibernate mode key exists */
hm_ref = (CFNumberRef) CFDictionaryGetValue(live_settings, CFSTR("Hibernate Mode")); /* On success, get its value */
hm_type = CFNumberGetType(hm_ref);
CFNumberGetValue(hm_ref, hm_type, &original_mode);
if (debug) printf("original mode: %d\n", original_mode);
}
else { /* On failure, cleanup and quit */
printf("Failed to get the hibernation mode\n");
CFCleanup();
return 1;
}
if (repair && original_mode == target_mode) { /* If the original mode is the same as the target mode */
original_mode = default_mode; /* A crash has probably happened during hibernation: we will set back the hibernation mode to its default value after wakeup */
if (debug) printf("repair mode to: %d\n", default_mode);
}
root_power_port = IORegisterForSystemPower(refCon, ¬ifyPortRef, PowerCallBack, ¬ifierObject); /* Register to the Root Power Domain IOService: notifications will be handled by the PowerCallBack functions */
if (!root_power_port) { /* Registering failed: quit */
printf("Failed to register to the Root Power Domain IOService\n");
CFCleanup();
return 1;
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), IONotificationPortGetRunLoopSource(notifyPortRef), kCFRunLoopCommonModes); /* Add the notification port to the run loop */
if (SetActiveProfile(target_profile, current_ps, active_prof)) { /* Set the active power profile to custom (-1) */
printf("Failed to set the active profile\n");
PortsCleanup();
CFCleanup();
return 1;
}
if (SetHibernateMode(target_mode, current_ps)) { /* Set the hibernate mode to target mode */
printf("Failed to set the hibernation mode\n");
SetActiveProfile(original_profile, current_ps, active_prof);
PortsCleanup();
CFCleanup();
return 1;
}
if (do_sleep) { /* If we are not in simulation mode */
sleep(3); /* Wait for 3s to allow settings to settle down */
if (IOPMSleepSystem(root_power_port) == kIOReturnSuccess) /* Request the system to sleep */
CFRunLoopRun(); /* On success, start the run loop */
else
perror("Failed to send the sleep request\n"); /* On failure, do not start it */
} /* The run loop has stopped: system has woken up */
if (restore) { /* If we are asked to restore the original hibernate mode */
if (SetHibernateMode(original_mode, current_ps)) { /* Restore the original hibernate mode */
printf("Failed to set the hibernation mode\n");
SetActiveProfile(original_profile, current_ps, active_prof);
PortsCleanup();
CFCleanup();
return 1;
}
if (SetActiveProfile(original_profile, current_ps, active_prof)) { /* Restore the original power profile */
printf("Failed to set the active profile\n");
PortsCleanup();
CFCleanup();
return 1;
}
}
PortsCleanup(); /* Cleanup */
CFCleanup();
return 0;
}
/* -----------------------------------------------------------------------------
----------------------------------------------------------------------------- */
static void
nc_show(int argc, char **argv)
{
SCNetworkServiceRef service = NULL;
SCDynamicStoreRef store = NULL;
int exit_code = 1;
CFStringRef serviceID = NULL;
CFStringRef iftype = NULL;
CFStringRef ifsubtype = NULL;
CFStringRef type_entity_key = NULL;
CFStringRef subtype_entity_key = NULL;
CFDictionaryRef type_entity_dict = NULL;
CFDictionaryRef subtype_entity_dict = NULL;
CFStringRef vpnprefpath = NULL;
#if !TARGET_OS_IPHONE
CFDataRef bookmarkData = NULL;
CFURLRef directory = NULL;
Boolean isStale = FALSE;
char *path = NULL;
CFIndex path_len = 0;
#endif
service = nc_copy_service_from_arguments(argc, argv, NULL);
if (service == NULL) {
SCPrint(TRUE, stderr, CFSTR("No service\n"));
exit(exit_code);
}
serviceID = SCNetworkServiceGetServiceID(service);
nc_get_service_type_and_subtype(service, &iftype, &ifsubtype);
if (!CFEqual(iftype, kSCEntNetPPP) &&
!CFEqual(iftype, kSCEntNetIPSec) &&
!CFEqual(iftype, kSCEntNetVPN)) {
SCPrint(TRUE, stderr, CFSTR("Not a connection oriented service: %@\n"), serviceID);
goto done;
}
type_entity_key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, kSCDynamicStoreDomainSetup, serviceID, iftype);
nc_print_VPN_service(service);
#if !TARGET_OS_IPHONE
vpnprefpath = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@%@%@"), PREF_PREFIX, ifsubtype, PREF_SUFFIX);
if (vpnprefpath == NULL) {
goto skipURL;
}
path_len = CFStringGetLength(vpnprefpath) + 1;
path = malloc(path_len);
if (path == NULL) {
goto skipURL;
}
if (!CFStringGetCString(vpnprefpath, path, path_len, kCFStringEncodingASCII)) {
SCPrint(TRUE, stderr, CFSTR("CFStringGetCString failed\n"));
goto done;
}
do_prefs_init(); /* initialization */
do_prefs_open(1, &path); /* open prefs */
bookmarkData = SCPreferencesGetValue(prefs, CFSTR("ApplicationURL"));
if (bookmarkData == NULL) {
goto skipURL;
}
directory = CFURLCreateByResolvingBookmarkData(kCFAllocatorDefault, bookmarkData, 0, NULL, NULL, &isStale, NULL);
if (directory == NULL) {
goto skipURL;
}
SCPrint(TRUE, stdout, CFSTR("ApplicationURL: %@\n"), directory);
skipURL:
#endif
store = SCDynamicStoreCreate(NULL, CFSTR("scutil --nc"), NULL, NULL);
if (store == NULL) {
SCPrint(TRUE, stderr, CFSTR("Unable to create dynamic store: %s\n"), SCErrorString(SCError()));
goto done;
}
type_entity_dict = SCDynamicStoreCopyValue(store, type_entity_key);
if (!type_entity_dict) {
SCPrint(TRUE, stderr, CFSTR("No \"%@\" configuration available\n"), iftype);
} else {
SCPrint(TRUE, stdout, CFSTR("%@ %@\n"), iftype, type_entity_dict);
}
if (ifsubtype) {
subtype_entity_key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, kSCDynamicStoreDomainSetup, serviceID, ifsubtype);
subtype_entity_dict = SCDynamicStoreCopyValue(store, subtype_entity_key);
if (!subtype_entity_dict) {
//
}
else {
SCPrint(TRUE, stdout, CFSTR("%@ %@\n"), ifsubtype, subtype_entity_dict);
}
}
exit_code = 0;
done:
my_CFRelease(&type_entity_key);
my_CFRelease(&type_entity_dict);
my_CFRelease(&subtype_entity_key);
my_CFRelease(&subtype_entity_dict);
my_CFRelease(&store);
my_CFRelease(&service);
my_CFRelease(&vpnprefpath);
_prefs_close();
exit(exit_code);
}
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 void
nc_ondemand(int argc, char **argv)
{
int exit_code = 1;
CFStringRef key = NULL;
CFDictionaryRef ondemand_dict = NULL;
SCDynamicStoreRef store;
store = SCDynamicStoreCreate(NULL, CFSTR("scutil --nc"), nc_ondemand_callback, NULL);
if (store == NULL) {
SCPrint(TRUE, stderr, CFSTR("Unable to create dynamic store: %s\n"), SCErrorString(SCError()));
goto done;
}
if (argc == 1) {
#if !TARGET_IPHONE_SIMULATOR
if (strcmp("--refresh", argv[0]) == 0) {
SCNetworkConnectionRef connection = NULL;
connection = SCNetworkConnectionCreate(kCFAllocatorDefault, NULL, NULL);
if (connection && SCNetworkConnectionRefreshOnDemandState(connection)) {
exit_code = 0;
}
if (exit_code) {
SCPrint(TRUE, stderr, CFSTR("Unable to refresh OnDemand state: %s\n"), SCErrorString(SCError()));
}
my_CFRelease(&connection);
goto done;
}
#endif // !TARGET_IPHONE_SIMULATOR
ondemand_nodename = CFStringCreateWithCString(NULL, argv[0], kCFStringEncodingUTF8);
} else if (argc != 0) {
SCPrint(TRUE, stderr, CFSTR("Usage: scutil --nc ondemand [-W] [hostname]\n"
" scutil --nc ondemand -- --refresh\n"));
goto done;
}
key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, kSCDynamicStoreDomainState, kSCEntNetOnDemand);
if (ondemand_nodename) {
checkOnDemandHost(store, ondemand_nodename, FALSE);
checkOnDemandHost(store, ondemand_nodename, TRUE);
} else {
ondemand_dict = SCDynamicStoreCopyValue(store, key);
if (ondemand_dict) {
SCPrint(TRUE, stdout, CFSTR("%@ %@\n"), kSCEntNetOnDemand, ondemand_dict);
} else {
SCPrint(TRUE, stdout, CFSTR("%@ not configured\n"), kSCEntNetOnDemand);
}
}
if (ondemandwatch) {
CFMutableArrayRef keys = NULL;
keys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(keys, key);
SCDynamicStoreSetNotificationKeys(store, keys, NULL);
my_CFRelease(&keys);
SCDynamicStoreSetDispatchQueue(store, dispatch_get_main_queue());
CFRunLoopRun();
}
exit_code = 0;
done:
my_CFRelease(&ondemand_dict);
my_CFRelease(&key);
my_CFRelease(&store);
my_CFRelease(&ondemand_nodename);
exit(exit_code);
}
int set_global_proxy(int enable, const char* host, int port)
{
printf("set global proxy %d %s %d\n", enable, host, port);
SCPreferencesRef pref = SCPreferencesCreate(kCFAllocatorSystemDefault, CFSTR("setproxy"), 0);
if(!pref){
printf("Failed to open preference.\n");
return 1;
}
CFDictionaryRef set = SCPreferencesPathGetValue(pref, CFSTR("/NetworkServices/"));
if(!set){
printf("Failed to get network services.\n");
}
CFMutableDictionaryRef mset = CFDictionaryCreateMutableCopy(0, 0, set);
SCDynamicStoreRef theDynamicStore = SCDynamicStoreCreate(nil, CFSTR("setproxy"), nil, nil);
CFDictionaryRef returnedPList;
returnedPList = (CFDictionaryRef)SCDynamicStoreCopyValue(theDynamicStore, CFSTR("State:/Network/Global/IPv4"));
CFStringRef primaryService = NULL;
if(returnedPList){
primaryService = (CFStringRef)CFDictionaryGetValue(returnedPList, CFSTR("PrimaryService"));
}
size_t size = CFDictionaryGetCount(set);
CFTypeRef *keysTypeRef = (CFTypeRef *) malloc( size * sizeof(CFTypeRef) );
CFTypeRef *valuesTypeRef = (CFTypeRef *) malloc( size * sizeof(CFTypeRef) );
CFDictionaryGetKeysAndValues(set, (const void **) keysTypeRef, (const void**)valuesTypeRef);
const void **keys = (const void **) keysTypeRef;
printf("Number of interfaces = %ld\n", size);
int i;
for(i=0; i<size && keysTypeRef[i]; i++){
Boolean success;
CFStringRef service = (CFStringRef)keysTypeRef[i];
printf("Setting interface %d\n", i);
if(enable == 1 && primaryService && CFStringCompare(service, primaryService, kCFCompareCaseInsensitive) != 0){
continue;
}
CFTypeRef value = valuesTypeRef[i];
if(!value){
continue;
}
CFDictionaryRef face = (CFDictionaryRef)value;
CFMutableDictionaryRef mface = CFDictionaryCreateMutableCopy(0, 0, face);
CFMutableDictionaryRef mproxy = NULL;
CFDictionaryRef proxy = (CFDictionaryRef)CFDictionaryGetValue(mface, CFSTR("Proxies"));
if(NULL == proxy){
if(enable == 0){
CFRelease(mface);
continue;
}
printf("proxy = %p, try to create it\n", proxy);
mproxy = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}else{
mproxy = CFDictionaryCreateMutableCopy(0, 0, proxy);
if(mproxy == NULL)
return 4;
}
if(enable){
CFStringRef cfHost = CFStringCreateWithCString(0, host, kCFStringEncodingASCII);
CFDictionarySetValue(mproxy, CFSTR("HTTPEnable"), CFNumberCreate(0, kCFNumberIntType, &enable));
CFDictionarySetValue(mproxy, CFSTR("HTTPProxy"), cfHost);
CFDictionarySetValue(mproxy, CFSTR("HTTPPort"), CFNumberCreate(0, kCFNumberIntType, &port));
CFDictionarySetValue(mproxy, CFSTR("HTTPSEnable"), CFNumberCreate(0, kCFNumberIntType, &enable));
CFDictionarySetValue(mproxy, CFSTR("HTTPSProxy"), cfHost);
CFDictionarySetValue(mproxy, CFSTR("HTTPSPort"), CFNumberCreate(0, kCFNumberIntType, &port));
CFRelease(cfHost);
}else{
CFDictionaryRemoveValue(mproxy, CFSTR("HTTPEnable"));
CFDictionaryRemoveValue(mproxy, CFSTR("HTTPProxy"));
CFDictionaryRemoveValue(mproxy, CFSTR("HTTPPort"));
CFDictionaryRemoveValue(mproxy, CFSTR("HTTPSEnable"));
CFDictionaryRemoveValue(mproxy, CFSTR("HTTPSProxy"));
CFDictionaryRemoveValue(mproxy, CFSTR("HTTPSPort"));
}
CFDictionarySetValue(mface, CFSTR("Proxies"), mproxy);
CFDictionarySetValue(mset, service, mface);
SCPreferencesPathSetValue(pref, CFSTR("/NetworkServices/"), mset);
success = SCPreferencesCommitChanges(pref);
printf("success: %d\n", success);
success = SCPreferencesApplyChanges(pref);
printf("success: %d\n", success);
CFRelease(mface);
CFRelease(mproxy);
}
CFRelease(mset);
CFRelease(pref);
free(keysTypeRef);
free(valuesTypeRef);
}
void PcapLiveDeviceList::setDnsServers()
{
#ifdef WIN32
FIXED_INFO * fixedInfo;
ULONG ulOutBufLen;
DWORD dwRetVal;
IP_ADDR_STRING * pIPAddr;
uint8_t buf1[sizeof(FIXED_INFO)];
fixedInfo = (FIXED_INFO *) buf1;
ulOutBufLen = sizeof( FIXED_INFO );
dwRetVal = GetNetworkParams( fixedInfo, &ulOutBufLen );
uint8_t buf2[ulOutBufLen];
if(ERROR_BUFFER_OVERFLOW == dwRetVal)
{
fixedInfo = (FIXED_INFO *)buf2;
}
if ((dwRetVal = GetNetworkParams( fixedInfo, &ulOutBufLen )) != 0)
LOG_ERROR("Call to GetNetworkParams failed. Return Value: %08lx\n", dwRetVal);
else
{
m_DnsServers.push_back(IPv4Address(fixedInfo->DnsServerList.IpAddress.String));
int i = 1;
LOG_DEBUG("Default DNS server IP #%d: %s\n", i++, fixedInfo->DnsServerList.IpAddress.String );
pIPAddr = fixedInfo->DnsServerList.Next;
while ( pIPAddr )
{
m_DnsServers.push_back(IPv4Address(pIPAddr->IpAddress.String));
LOG_DEBUG("Default DNS server IP #%d: %s\n", i++, pIPAddr->IpAddress.String);
pIPAddr = pIPAddr -> Next;
}
}
#elif LINUX
std::string command = "nmcli dev list | grep IP4.DNS";
std::string dnsServersInfo = executeShellCommand(command);
if (dnsServersInfo == "")
{
LOG_DEBUG("Error retrieving DNS server list: call to nmcli gave no output");
return;
}
std::istringstream stream(dnsServersInfo);
std::string line;
int i = 1;
while(std::getline(stream, line))
{
std::istringstream lineStream(line);
std::string headline;
std::string dnsIP;
lineStream >> headline;
lineStream >> dnsIP;
IPv4Address dnsIPAddr(dnsIP);
if (!dnsIPAddr.isValid())
continue;
if (std::find(m_DnsServers.begin(), m_DnsServers.end(), dnsIPAddr) == m_DnsServers.end())
{
m_DnsServers.push_back(dnsIPAddr);
LOG_DEBUG("Default DNS server IP #%d: %s\n", i++, dnsIPAddr.toString().c_str());
}
}
#elif MAC_OS_X
SCDynamicStoreRef dynRef = SCDynamicStoreCreate(kCFAllocatorSystemDefault, CFSTR("iked"), NULL, NULL);
if (dynRef == NULL)
{
LOG_DEBUG("Couldn't set DNS server list: failed to retrieve SCDynamicStore");
return;
}
CFDictionaryRef dnsDict = (CFDictionaryRef)SCDynamicStoreCopyValue(dynRef,CFSTR("State:/Network/Global/DNS"));
if (dnsDict == NULL)
{
LOG_DEBUG("Couldn't set DNS server list: failed to get DNS dictionary");
CFRelease(dynRef);
return;
}
CFArrayRef serverAddresses = (CFArrayRef)CFDictionaryGetValue(dnsDict, CFSTR("ServerAddresses"));
if (serverAddresses == NULL)
{
LOG_DEBUG("Couldn't set DNS server list: server addresses array is null");
CFRelease(dynRef);
CFRelease(dnsDict);
return;
}
CFIndex count = CFArrayGetCount(serverAddresses);
for (CFIndex i = 0; i < count; i++)
{
CFStringRef serverAddress = (CFStringRef)CFArrayGetValueAtIndex(serverAddresses, i);
if (serverAddress == NULL)
continue;
uint8_t buf[20];
char* serverAddressCString = (char*)buf;
CFStringGetCString(serverAddress, serverAddressCString, 20, kCFStringEncodingUTF8);
m_DnsServers.push_back(IPv4Address(serverAddressCString));
LOG_DEBUG("Default DNS server IP #%d: %s\n", (int)(i+1), serverAddressCString);
}
CFRelease(dynRef);
CFRelease(dnsDict);
#endif
}
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);
}
}
HRESULT HostDnsServiceDarwin::update()
{
m_llNameServers.clear();
m_llSearchStrings.clear();
m_DomainName.setNull();
CFPropertyListRef propertyRef = SCDynamicStoreCopyValue(g_store,
kStateNetworkGlobalDNSKey);
/**
* 0:vvl@nb-mbp-i7-2(0)# scutil
* > get State:/Network/Global/DNS
* > d.show
* <dictionary> {
* DomainName : vvl-domain
* SearchDomains : <array> {
* 0 : vvl-domain
* 1 : de.vvl-domain.com
* }
* ServerAddresses : <array> {
* 0 : 192.168.1.4
* 1 : 192.168.1.1
* 2 : 8.8.4.4
* }
* }
*/
if (!propertyRef)
return S_OK;
CFStringRef domainNameRef = (CFStringRef)CFDictionaryGetValue(
static_cast<CFDictionaryRef>(propertyRef), CFSTR("DomainName"));
if (domainNameRef)
{
const char *pszDomainName = CFStringGetCStringPtr(domainNameRef,
CFStringGetSystemEncoding());
if (pszDomainName)
m_DomainName = com::Utf8Str(pszDomainName);
}
int i, arrayCount;
CFArrayRef serverArrayRef = (CFArrayRef)CFDictionaryGetValue(
static_cast<CFDictionaryRef>(propertyRef), CFSTR("ServerAddresses"));
if (serverArrayRef)
{
arrayCount = CFArrayGetCount(serverArrayRef);
for (i = 0; i < arrayCount; ++i)
{
CFStringRef serverAddressRef = (CFStringRef)CFArrayGetValueAtIndex(serverArrayRef, i);
if (!serverArrayRef)
continue;
const char *pszServerAddress = CFStringGetCStringPtr(serverAddressRef,
CFStringGetSystemEncoding());
if (!pszServerAddress)
continue;
m_llNameServers.push_back(com::Utf8Str(pszServerAddress));
}
}
CFArrayRef searchArrayRef = (CFArrayRef)CFDictionaryGetValue(
static_cast<CFDictionaryRef>(propertyRef), CFSTR("SearchDomains"));
if (searchArrayRef)
{
arrayCount = CFArrayGetCount(searchArrayRef);
for (i = 0; i < arrayCount; ++i)
{
CFStringRef searchStringRef = (CFStringRef)CFArrayGetValueAtIndex(searchArrayRef, i);
if (!searchArrayRef)
continue;
const char *pszSearchString = CFStringGetCStringPtr(searchStringRef,
CFStringGetSystemEncoding());
if (!pszSearchString)
continue;
m_llSearchStrings.push_back(com::Utf8Str(pszSearchString));
}
}
CFRelease(propertyRef);
this->HostDnsService::update();
return S_OK;
}
CFNetDiagnosticStatus CFNetDiagnosticCopyNetworkStatusPassively(CFNetDiagnosticRef details, CFStringRef *description) {
CFMutableDictionaryRef detailsDict = (CFMutableDictionaryRef)details;
CFNetDiagnosticStatus retval = kCFNetDiagnosticConnectionIndeterminate;
CFStringRef serviceID;
SCDynamicStoreRef store;
store = SCDynamicStoreCreate(kCFAllocatorDefault, CFSTR("CFNetDiagnostics"), NULL, NULL);
if(store) {
serviceID = CFDictionaryGetValue(detailsDict, _CFNetDiagnosticServiceIDKey);
if(serviceID) {
//If there is a specific ServiceID we only scan on it. We can only get in this position through SPIs
retval = _CFNetDiagnosticCopyNetworkStatusPassivelyInterfaceSpecific(store, serviceID, description);
} else {
//Iterate through all serviceIDs. If any are good, then we return it
CFStringRef pattern = NULL;
CFDictionaryRef dict = NULL;
CFArrayRef serviceOrder = NULL;
CFIndex i, count;
CFNetDiagnosticStatus serviceState = kCFNetDiagnosticConnectionDown;
pattern = SCDynamicStoreKeyCreateNetworkGlobalEntity( NULL,
(CFStringRef) kSCDynamicStoreDomainSetup,
(CFStringRef) kSCEntNetIPv4 );
if(pattern) {
dict = SCDynamicStoreCopyValue( store, pattern );
CFRelease( pattern );
}
if(dict) {
serviceOrder = CFDictionaryGetValue(dict, CFSTR("ServiceOrder"));
CFRetain(serviceOrder);
CFRelease(dict);
}
if(serviceOrder) {
count = CFArrayGetCount(serviceOrder);
retval = kCFNetDiagnosticConnectionDown;
for ( i = 0; i < count; i++ ) {
serviceID = CFArrayGetValueAtIndex(serviceOrder, i);
serviceState = _CFNetDiagnosticCopyNetworkStatusPassivelyInterfaceSpecific(store, serviceID, description);
if(serviceState == kCFNetDiagnosticConnectionDown) {
retval = kCFNetDiagnosticConnectionDown;
if (description) {
*description = CFCopyLocalizedStringFromTableInBundle( CFSTR("CONNECTION_DOWN"),
NULL,
CFBundleGetBundleWithIdentifier(CFSTR("com.apple.CFNetwork")),
"This computer's Internet connect appears to be offline.");
}
} else if (serviceState == kCFNetDiagnosticConnectionIndeterminate) {
retval = kCFNetDiagnosticConnectionIndeterminate;
if (description) {
*description = CFCopyLocalizedStringFromTableInBundle( CFSTR("CONNECTION_INDETERMINATE"),
NULL,
CFBundleGetBundleWithIdentifier(CFSTR("com.apple.CFNetwork")),
"This computer's Internet may be offline.");
}
} else if (serviceState == kCFNetDiagnosticConnectionUp) {
retval = kCFNetDiagnosticConnectionUp;
if (description) {
*description = CFCopyLocalizedStringFromTableInBundle( CFSTR("CONNECTION_UP"),
NULL,
CFBundleGetBundleWithIdentifier(CFSTR("com.apple.CFNetwork")),
"This computer's Internet may be online.");
}
break;
} else {
//FIXME
//NOT REACHED log an error
}
}
CFRelease(serviceOrder);
}
}
CFRelease(store);
}
return retval;
}
