static void
add_supplemental_proxies(CFMutableArrayRef proxies, CFDictionaryRef services, CFArrayRef service_order)
{
const void * keys_q[N_QUICK];
const void ** keys = keys_q;
CFIndex i;
CFIndex n_order;
CFIndex n_services;
const void * vals_q[N_QUICK];
const void ** vals = vals_q;
n_services = isA_CFDictionary(services) ? CFDictionaryGetCount(services) : 0;
if (n_services == 0) {
return; // if no services
}
if (n_services > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
keys = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
vals = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
}
n_order = isA_CFArray(service_order) ? CFArrayGetCount(service_order) : 0;
CFDictionaryGetKeysAndValues(services, keys, vals);
for (i = 0; i < n_services; i++) {
uint32_t defaultOrder;
CFDictionaryRef proxy;
CFMutableDictionaryRef proxyWithDNS = NULL;
CFDictionaryRef service = (CFDictionaryRef)vals[i];
if (!isA_CFDictionary(service)) {
continue;
}
proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
if (!isA_CFDictionary(proxy)) {
continue;
}
if ((G_supplemental_proxies_follow_dns != NULL) && CFBooleanGetValue(G_supplemental_proxies_follow_dns)) {
CFDictionaryRef dns;
CFArrayRef matchDomains;
CFArrayRef matchOrders;
if (!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomains) &&
CFDictionaryGetValueIfPresent(service, kSCEntNetDNS, (const void **)&dns) &&
isA_CFDictionary(dns) &&
CFDictionaryGetValueIfPresent(dns, kSCPropNetDNSSupplementalMatchDomains, (const void **)&matchDomains) &&
isA_CFArray(matchDomains)) {
proxyWithDNS = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionarySetValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchDomains, matchDomains);
if (CFDictionaryGetValueIfPresent(dns, kSCPropNetDNSSupplementalMatchOrders, (const void **)&matchOrders) &&
isA_CFArray(matchOrders)) {
CFDictionarySetValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchOrders, matchOrders);
} else {
CFDictionaryRemoveValue(proxyWithDNS, kSCPropNetProxiesSupplementalMatchOrders);
}
proxy = proxyWithDNS;
}
}
defaultOrder = DEFAULT_MATCH_ORDER
- (DEFAULT_MATCH_ORDER / 2)
+ ((DEFAULT_MATCH_ORDER / 1000) * i);
if ((n_order > 0) &&
!CFArrayContainsValue(service_order, CFRangeMake(0, n_order), keys[i])) {
// push out services not specified in service order
defaultOrder += (DEFAULT_MATCH_ORDER / 1000) * n_services;
}
add_supplemental(proxies, proxy, defaultOrder);
if (proxyWithDNS != NULL) CFRelease(proxyWithDNS);
}
if (keys != keys_q) {
CFAllocatorDeallocate(NULL, keys);
CFAllocatorDeallocate(NULL, vals);
}
return;
}
/* 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
booterExit(pid_t pid, int status, struct rusage *rusage, void *context)
{
Boolean again = FALSE;
CFStringRef name;
Boolean ok = TRUE;
kickeeRef target = (kickeeRef)context;
name = CFDictionaryGetValue(target->dict, CFSTR("name"));
if (WIFEXITED(status)) {
SCLog(TRUE, LOG_DEBUG,
CFSTR(" target=%@: exit status = %d"),
name,
WEXITSTATUS(status));
if (WEXITSTATUS(status) != 0) {
ok = FALSE;
}
} else if (WIFSIGNALED(status)) {
SCLog(TRUE, LOG_DEBUG,
CFSTR(" target=%@: terminated w/signal = %d"),
name,
WTERMSIG(status));
ok = FALSE;
} else {
SCLog(TRUE, LOG_DEBUG,
CFSTR(" target=%@: exit status = %d"),
name,
status);
ok = FALSE;
}
if (ok) {
if (target->needsKick) {
again = TRUE; /* one more time */
} else {
target->active = FALSE; /* normal exit, no more requests */
}
}
if (!ok) {
if (CFDictionaryContainsKey(target->dict, CFSTR("postName"))) {
CFDictionaryRef oldDict = target->dict;
CFMutableDictionaryRef newDict = CFDictionaryCreateMutableCopy(NULL, 0, oldDict);
/*
* if this target specifies both a BSD notification and
* a script to be executed then we want to continue to
* post the BSD notifications (and not execute the
* script). As such, remove the script reference from
* the dictionary.
*/
CFDictionaryRemoveValue(newDict, CFSTR("execCommand"));
CFDictionaryRemoveValue(newDict, CFSTR("execGID"));
CFDictionaryRemoveValue(newDict, CFSTR("execUID"));
CFDictionaryRemoveValue(newDict, CFSTR("changedKeysAsArguments"));
target->dict = newDict;
CFRelease(oldDict);
/* ... and allow BSD notifications */
target->active = FALSE;
} else {
/*
* If the target action can't be performed this time then
* there's not much point in trying again. As such, I close
* the session and the kickee target released.
*/
cleanupKicker(target);
}
} else if (again) {
booter(target);
}
return;
}
static GstFlowReturn
gst_vtenc_encode_frame (GstVTEnc * self, GstBuffer * buf)
{
GstVTApi *vt = self->ctx->vt;
CMTime ts, duration;
GstCoreMediaMeta *meta;
CVPixelBufferRef pbuf = NULL;
VTStatus vt_status;
GstFlowReturn ret = GST_FLOW_OK;
guint i;
self->cur_inbuf = buf;
ts = CMTimeMake (GST_TIME_AS_MSECONDS (GST_BUFFER_TIMESTAMP (buf)), 1000);
duration = CMTimeMake
(GST_TIME_AS_MSECONDS (GST_BUFFER_DURATION (buf)), 1000);
meta = gst_buffer_get_core_media_meta (buf);
if (meta != NULL) {
pbuf = gst_core_media_buffer_get_pixel_buffer (buf);
}
if (pbuf == NULL) {
GstVTEncFrame *frame;
CVReturn cv_ret;
frame = gst_vtenc_frame_new (buf, &self->video_info);
if (!frame)
goto cv_error;
{
const size_t num_planes = GST_VIDEO_FRAME_N_PLANES (&frame->videoframe);
void *plane_base_addresses[GST_VIDEO_MAX_PLANES];
size_t plane_widths[GST_VIDEO_MAX_PLANES];
size_t plane_heights[GST_VIDEO_MAX_PLANES];
size_t plane_bytes_per_row[GST_VIDEO_MAX_PLANES];
OSType pixel_format_type;
size_t i;
for (i = 0; i < num_planes; i++) {
plane_base_addresses[i] =
GST_VIDEO_FRAME_PLANE_DATA (&frame->videoframe, i);
plane_widths[i] = GST_VIDEO_FRAME_COMP_WIDTH (&frame->videoframe, i);
plane_heights[i] = GST_VIDEO_FRAME_COMP_HEIGHT (&frame->videoframe, i);
plane_bytes_per_row[i] =
GST_VIDEO_FRAME_COMP_STRIDE (&frame->videoframe, i);
plane_bytes_per_row[i] =
GST_VIDEO_FRAME_COMP_STRIDE (&frame->videoframe, i);
}
switch (GST_VIDEO_INFO_FORMAT (&self->video_info)) {
case GST_VIDEO_FORMAT_I420:
pixel_format_type = kCVPixelFormatType_420YpCbCr8Planar;
break;
case GST_VIDEO_FORMAT_NV12:
pixel_format_type = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
break;
default:
goto cv_error;
}
cv_ret = CVPixelBufferCreateWithPlanarBytes (NULL,
self->negotiated_width, self->negotiated_height,
pixel_format_type,
frame,
GST_VIDEO_FRAME_SIZE (&frame->videoframe),
num_planes,
plane_base_addresses,
plane_widths,
plane_heights,
plane_bytes_per_row, gst_pixel_buffer_release_cb, frame, NULL, &pbuf);
if (cv_ret != kCVReturnSuccess) {
gst_vtenc_frame_free (frame);
goto cv_error;
}
}
}
GST_OBJECT_LOCK (self);
self->expect_keyframe = CFDictionaryContainsKey (self->options,
*(vt->kVTEncodeFrameOptionKey_ForceKeyFrame));
if (self->expect_keyframe)
gst_vtenc_clear_cached_caps_downstream (self);
vt_status = self->ctx->vt->VTCompressionSessionEncodeFrame (self->session,
pbuf, ts, duration, self->options, NULL, NULL);
if (vt_status != 0) {
GST_WARNING_OBJECT (self, "VTCompressionSessionEncodeFrame returned %d",
vt_status);
}
self->ctx->vt->VTCompressionSessionCompleteFrames (self->session,
kCMTimeInvalid);
GST_OBJECT_UNLOCK (self);
CVPixelBufferRelease (pbuf);
self->cur_inbuf = NULL;
gst_buffer_unref (buf);
if (self->cur_outbufs->len > 0) {
meta =
gst_buffer_get_core_media_meta (g_ptr_array_index (self->cur_outbufs,
0));
if (!gst_vtenc_negotiate_downstream (self, meta->sample_buf))
ret = GST_FLOW_NOT_NEGOTIATED;
}
for (i = 0; i != self->cur_outbufs->len; i++) {
GstBuffer *buf = g_ptr_array_index (self->cur_outbufs, i);
if (ret == GST_FLOW_OK) {
ret = gst_pad_push (self->srcpad, buf);
} else {
gst_buffer_unref (buf);
}
}
g_ptr_array_set_size (self->cur_outbufs, 0);
return ret;
cv_error:
{
self->cur_inbuf = NULL;
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
}
static GstFlowReturn
gst_vtenc_encode_frame (GstVTEnc * self, GstBuffer * buf)
{
GstCVApi *cv = self->ctx->cv;
GstVTApi *vt = self->ctx->vt;
CMTime ts, duration;
CVPixelBufferRef pbuf = NULL;
VTStatus vt_status;
GstFlowReturn ret = GST_FLOW_OK;
guint i;
self->cur_inbuf = buf;
ts = self->ctx->cm->CMTimeMake
(GST_TIME_AS_MSECONDS (GST_BUFFER_TIMESTAMP (buf)), 1000);
duration = self->ctx->cm->CMTimeMake
(GST_TIME_AS_MSECONDS (GST_BUFFER_DURATION (buf)), 1000);
if (GST_IS_CORE_MEDIA_BUFFER (buf)) {
GstCoreMediaBuffer *cmbuf = GST_CORE_MEDIA_BUFFER_CAST (buf);
pbuf = gst_core_media_buffer_get_pixel_buffer (cmbuf);
}
if (pbuf == NULL) {
CVReturn cv_ret;
cv_ret = cv->CVPixelBufferCreateWithBytes (NULL,
self->negotiated_width, self->negotiated_height,
kCVPixelFormatType_422YpCbCr8Deprecated, GST_BUFFER_DATA (buf),
self->negotiated_width * 2,
(CVPixelBufferReleaseBytesCallback) gst_buffer_unref, buf, NULL, &pbuf);
if (cv_ret != kCVReturnSuccess)
goto cv_error;
gst_buffer_ref (buf);
}
GST_OBJECT_LOCK (self);
self->expect_keyframe = CFDictionaryContainsKey (self->options,
*(vt->kVTEncodeFrameOptionKey_ForceKeyFrame));
if (self->expect_keyframe)
gst_vtenc_clear_cached_caps_downstream (self);
vt_status = self->ctx->vt->VTCompressionSessionEncodeFrame (self->session,
pbuf, ts, duration, self->options, NULL, NULL);
if (vt_status != 0) {
GST_WARNING_OBJECT (self, "VTCompressionSessionEncodeFrame returned %d",
vt_status);
}
self->ctx->vt->VTCompressionSessionCompleteFrames (self->session,
*(self->ctx->cm->kCMTimeInvalid));
GST_OBJECT_UNLOCK (self);
cv->CVPixelBufferRelease (pbuf);
self->cur_inbuf = NULL;
gst_buffer_unref (buf);
if (self->cur_outbufs->len > 0) {
GstCoreMediaBuffer *cmbuf =
GST_CORE_MEDIA_BUFFER_CAST (g_ptr_array_index (self->cur_outbufs, 0));
if (!gst_vtenc_negotiate_downstream (self, cmbuf->sample_buf))
ret = GST_FLOW_NOT_NEGOTIATED;
}
for (i = 0; i != self->cur_outbufs->len; i++) {
GstBuffer *buf = g_ptr_array_index (self->cur_outbufs, i);
if (ret == GST_FLOW_OK) {
gst_buffer_set_caps (buf, GST_PAD_CAPS (self->srcpad));
ret = gst_pad_push (self->srcpad, buf);
} else {
gst_buffer_unref (buf);
}
}
g_ptr_array_set_size (self->cur_outbufs, 0);
return ret;
cv_error:
{
self->cur_inbuf = NULL;
gst_buffer_unref (buf);
return GST_FLOW_ERROR;
}
}
__private_extern__
CF_RETURNS_RETAINED CFDictionaryRef
proxy_configuration_update(CFDictionaryRef defaultProxy,
CFDictionaryRef services,
CFArrayRef serviceOrder,
CFDictionaryRef servicesInfo)
{
CFIndex i;
CFMutableDictionaryRef myDefault;
Boolean myOrderAdded = FALSE;
CFMutableDictionaryRef newProxy = NULL;
CFIndex n_proxies;
CFDictionaryRef proxy;
CFMutableArrayRef proxies;
// establish full list of proxies
proxies = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
// collect (and add) any "supplemental" proxy configurations
add_supplemental_proxies(proxies, services, serviceOrder);
// add the "default" proxy
add_default_proxy(proxies, defaultProxy, &myOrderAdded);
// sort proxies, cleanup
n_proxies = CFArrayGetCount(proxies);
if (n_proxies > 1) {
CFArraySortValues(proxies, CFRangeMake(0, n_proxies), compareDomain, NULL);
}
// cleanup
for (i = n_proxies - 1; i >= 0; i--) {
proxy = CFArrayGetValueAtIndex(proxies, i);
if ((i > 0) &&
!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
// remove non-supplemental proxy
CFArrayRemoveValueAtIndex(proxies, i);
n_proxies--;
continue;
}
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, PROXY_MATCH_ORDER_KEY);
CFDictionaryRemoveValue(newProxy, ORDER_KEY);
CFArraySetValueAtIndex(proxies, i, newProxy);
CFRelease(newProxy);
}
// update the default proxy
myDefault = CFDictionaryCreateMutableCopy(NULL,
0,
CFArrayGetValueAtIndex(proxies, 0));
if (myOrderAdded && (n_proxies > 1)) {
CFDictionaryRef proxy;
proxy = CFArrayGetValueAtIndex(proxies, 1);
if (CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
// if not a supplemental "default" proxy (a match domain name is
// present)
CFDictionaryRemoveValue(myDefault, PROXY_MATCH_ORDER_KEY);
}
}
CFArraySetValueAtIndex(proxies, 0, myDefault);
CFRelease(myDefault);
// establish proxy configuration
if (n_proxies > 0) {
CFDictionaryRef app_layer;
CFDictionaryRef scoped;
CFArrayRef serviceOrderAll;
Boolean skip = FALSE;
CFArrayRef supplemental;
proxy = CFArrayGetValueAtIndex(proxies, 0);
if (!CFDictionaryContainsKey(proxy, kSCPropNetProxiesSupplementalMatchDomain)) {
// if we have "a" default (non-supplemental) proxy
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
skip = TRUE;
} else {
newProxy = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
serviceOrderAll = service_order_copy_all(services, serviceOrder);
// collect (and add) any "supplemental" proxy configurations
supplemental = copy_supplemental_proxies(proxies, skip);
if (supplemental != NULL) {
CFDictionarySetValue(newProxy, kSCPropNetProxiesSupplemental, supplemental);
CFRelease(supplemental);
}
// collect (and add) any "scoped" proxy configurations
scoped = copy_scoped_proxies(services, serviceOrderAll);
if (scoped != NULL) {
CFDictionarySetValue(newProxy, kSCPropNetProxiesScoped, scoped);
CFRelease(scoped);
}
// collect (and add) any "services" based proxy configurations
app_layer = copy_app_layer_vpn_proxies(services, serviceOrderAll, servicesInfo);
if (app_layer != NULL) {
CFDictionarySetValue(newProxy, kSCPropNetProxiesServices, app_layer);
CFRelease(app_layer);
}
if (serviceOrderAll != NULL) {
CFRelease(serviceOrderAll);
}
} else {
newProxy = NULL;
}
CFRelease(proxies);
return newProxy;
}
//-----------------------------------------------------------------------------
void C700::RestorePGDataDic(CFPropertyListRef data, int pgnum)
{
int editProg = mEfx->GetPropertyValue(kAudioUnitCustomProperty_EditingProgram);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_EditingProgram, pgnum);
CFDictionaryRef dict = static_cast<CFDictionaryRef>(data);
CFNumberRef cfnum;
CFDataRef cfdata = reinterpret_cast<CFDataRef>(CFDictionaryGetValue(dict, kSaveKey_brrdata));
int size = CFDataGetLength(cfdata);
const UInt8 *dataptr = CFDataGetBytePtr(cfdata);
BRRData brr;
brr.data = const_cast<unsigned char*>(dataptr);
brr.size = size;
mEfx->SetBRRData(&brr);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_Loop,
brr.data[brr.size-9]&2?true:false);
int value;
if (CFDictionaryContainsKey(dict, kSaveKey_looppoint)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_looppoint));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_LoopPoint, value);
}
double dvalue;
if (CFDictionaryContainsKey(dict, kSaveKey_samplerate)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_samplerate));
CFNumberGetValue(cfnum, kCFNumberDoubleType, &dvalue);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_Rate, dvalue);
}
if (CFDictionaryContainsKey(dict, kSaveKey_basekey)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_basekey));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_BaseKey, value);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_BaseKey, 60);
}
if (CFDictionaryContainsKey(dict, kSaveKey_lowkey)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_lowkey));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_LowKey, value);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_LowKey, 0);
}
if (CFDictionaryContainsKey(dict, kSaveKey_highkey)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_highkey));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_HighKey,value );
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_HighKey,127 );
}
if (CFDictionaryContainsKey(dict, kSaveKey_ar)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_ar));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_AR, value);
}
if (CFDictionaryContainsKey(dict, kSaveKey_dr)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_dr));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_DR, value);
}
if (CFDictionaryContainsKey(dict, kSaveKey_sl)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_sl));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_SL, value);
}
if (CFDictionaryContainsKey(dict, kSaveKey_sr)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_sr));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_SR, value);
}
if (CFDictionaryContainsKey(dict, kSaveKey_SustainMode)) {
CFBooleanRef cfbool = reinterpret_cast<CFBooleanRef>(CFDictionaryGetValue(dict, kSaveKey_SustainMode));
mEfx->SetPropertyValue(kAudioUnitCustomProperty_SustainMode,CFBooleanGetValue(cfbool) ? 1.0f:.0f);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_SustainMode, 1.0f);
}
if (CFDictionaryContainsKey(dict, kSaveKey_volL)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_volL));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_VolL, value);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_VolL, 100);
}
if (CFDictionaryContainsKey(dict, kSaveKey_volR)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_volR));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_VolR, value);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_VolR, 100);
}
if (CFDictionaryContainsKey(dict, kSaveKey_echo)) {
CFBooleanRef cfbool = reinterpret_cast<CFBooleanRef>(CFDictionaryGetValue(dict, kSaveKey_echo));
mEfx->SetPropertyValue(kAudioUnitCustomProperty_Echo,CFBooleanGetValue(cfbool) ? 1.0f:.0f);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_Echo, .0f);
}
if (CFDictionaryContainsKey(dict, kSaveKey_bank)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_bank));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_Bank, value );
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_Bank, 0 );
}
if (CFDictionaryContainsKey(dict, kSaveKey_MonoMode)) {
CFBooleanRef cfbool = reinterpret_cast<CFBooleanRef>(CFDictionaryGetValue(dict, kSaveKey_MonoMode));
mEfx->SetPropertyValue(kAudioUnitCustomProperty_MonoMode,CFBooleanGetValue(cfbool) ? 1.0f:.0f);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_MonoMode, .0f);
}
if (CFDictionaryContainsKey(dict, kSaveKey_PortamentoOn)) {
CFBooleanRef cfbool = reinterpret_cast<CFBooleanRef>(CFDictionaryGetValue(dict, kSaveKey_PortamentoOn));
mEfx->SetPropertyValue(kAudioUnitCustomProperty_PortamentoOn,CFBooleanGetValue(cfbool) ? 1.0f:.0f);
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_PortamentoOn, .0f);
}
if (CFDictionaryContainsKey(dict, kSaveKey_PortamentoRate)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_PortamentoRate));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_PortamentoRate, value );
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_PortamentoRate, 0 );
}
if (CFDictionaryContainsKey(dict, kSaveKey_NoteOnPriority)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_NoteOnPriority));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_NoteOnPriority, value );
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_NoteOnPriority, 64 );
}
if (CFDictionaryContainsKey(dict, kSaveKey_ReleasePriority)) {
cfnum = reinterpret_cast<CFNumberRef>(CFDictionaryGetValue(dict, kSaveKey_ReleasePriority));
CFNumberGetValue(cfnum, kCFNumberIntType, &value);
mEfx->SetPropertyValue(kAudioUnitCustomProperty_ReleasePriority, value );
}
else {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_ReleasePriority, 0 );
}
if (CFDictionaryContainsKey(dict, kSaveKey_ProgName)) {
char pgname[PROGRAMNAME_MAX_LEN];
CFStringGetCString(reinterpret_cast<CFStringRef>(CFDictionaryGetValue(dict, kSaveKey_ProgName)),
pgname, PROGRAMNAME_MAX_LEN, kCFStringEncodingUTF8);
mEfx->SetProgramName(pgname);
}
else {
mEfx->SetProgramName("");
}
//元波形ファイル情報を復元
if (CFDictionaryContainsKey(dict, kSaveKey_SourceFile)) {
CFDataRef urlData = reinterpret_cast<CFDataRef>(CFDictionaryGetValue(dict, kSaveKey_SourceFile));
CFURLRef url = CFURLCreateWithBytes( NULL, CFDataGetBytePtr(urlData),
CFDataGetLength(urlData), kCFStringEncodingUTF8, NULL );
CFStringRef pathStr = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
char path[PATH_LEN_MAX];
CFStringGetCString(pathStr, path, PATH_LEN_MAX-1, kCFStringEncodingUTF8);
mEfx->SetSourceFilePath(path);
CFRelease(pathStr);
CFRelease(url);
CFBooleanRef cfbool = reinterpret_cast<CFBooleanRef>(CFDictionaryGetValue(dict, kSaveKey_IsEmphasized));
mEfx->SetPropertyValue(kAudioUnitCustomProperty_IsEmaphasized, CFBooleanGetValue(cfbool) ? 1.0f:.0f);
}
else {
mEfx->SetSourceFilePath("");
mEfx->SetPropertyValue(kAudioUnitCustomProperty_IsEmaphasized, .0f);
}
//UIに変更を反映
if (pgnum == editProg) {
mEfx->SetPropertyValue(kAudioUnitCustomProperty_EditingProgram, editProg);
}
mEfx->GetGenerator()->RefreshKeyMap();
}
/*************************************************************************
*
* hu_AddVendorProductToCFDict( inCFMutableDictionaryRef, inVendorID, inVendorCFStringRef, inProductID, inProductCFStringRef )
*
* Purpose: add a vendor & product to a dictionary
*
* Inputs: inCFMutableDictionaryRef - the dictionary
* inVendorID - the elements vendor ID
* inProductID - the elements product ID
* inProductCFStringRef - the string to be added
*
* Returns: Boolean - if successful
*/
static Boolean hu_AddVendorProductToCFDict(CFMutableDictionaryRef inCFMutableDictionaryRef,
long inVendorID,
CFStringRef inVendorCFStringRef,
long inProductID,
CFStringRef inProductCFStringRef) {
Boolean results = FALSE;
if ( inCFMutableDictionaryRef && ( CFDictionaryGetTypeID() == CFGetTypeID(inCFMutableDictionaryRef) ) ) {
CFMutableDictionaryRef vendorCFMutableDictionaryRef;
CFStringRef vendorKeyCFStringRef;
CFMutableDictionaryRef productCFMutableDictionaryRef;
CFStringRef productKeyCFStringRef;
// if the vendor dictionary doesn't exist
vendorKeyCFStringRef = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%ld"), inVendorID);
if ( CFDictionaryGetValueIfPresent(inCFMutableDictionaryRef, vendorKeyCFStringRef,
(const void **) &vendorCFMutableDictionaryRef) )
{
// copy it.
vendorCFMutableDictionaryRef = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, vendorCFMutableDictionaryRef);
} else { // ...otherwise...
// create it.
vendorCFMutableDictionaryRef = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
results = TRUE;
}
// if the vendor name key doesn't exist
if ( !CFDictionaryContainsKey(vendorCFMutableDictionaryRef, kNameKeyCFStringRef) ) {
// create it.
CFDictionaryAddValue(vendorCFMutableDictionaryRef, kNameKeyCFStringRef, inVendorCFStringRef);
results = TRUE;
}
// if the product key exists in the vendor dictionary
productKeyCFStringRef = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%ld"), inProductID);
if ( CFDictionaryGetValueIfPresent(vendorCFMutableDictionaryRef, productKeyCFStringRef,
(const void **) &productCFMutableDictionaryRef) )
{
// copy it.
productCFMutableDictionaryRef = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, productCFMutableDictionaryRef);
} else { // ...otherwise...
// create it.
productCFMutableDictionaryRef = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
results = TRUE;
}
// if the product name key doesn't exist
if ( !CFDictionaryContainsKey(productCFMutableDictionaryRef, kNameKeyCFStringRef) ) {
// create it.
CFDictionaryAddValue(productCFMutableDictionaryRef, kNameKeyCFStringRef, inProductCFStringRef);
results = TRUE;
}
if ( vendorCFMutableDictionaryRef ) {
if ( productCFMutableDictionaryRef ) {
if ( results ) {
CFDictionarySetValue(vendorCFMutableDictionaryRef, productKeyCFStringRef, productCFMutableDictionaryRef);
}
CFRelease(productCFMutableDictionaryRef);
}
if ( results ) {
CFDictionarySetValue(inCFMutableDictionaryRef, vendorKeyCFStringRef, vendorCFMutableDictionaryRef);
}
CFRelease(vendorCFMutableDictionaryRef);
}
if ( productKeyCFStringRef ) {
CFRelease(productKeyCFStringRef);
}
if ( vendorKeyCFStringRef ) {
CFRelease(vendorKeyCFStringRef);
}
}
return (results);
} // hu_AddVendorProductToCFDict
static void
filter_exception(const void *key, const void *value, void *context)
{
SecExceptionFilterContext *ctx = (SecExceptionFilterContext *)context;
if (!ctx) { return; }
SecTrustOptionFlags options = ctx->flags;
CFMutableDictionaryRef filteredException = ctx->filteredException;
CFStringRef keystr = (CFStringRef)key;
if (ctx->oldException && CFDictionaryContainsKey(ctx->oldException, key)) {
// Keep existing exception in filtered dictionary, regardless of options
CFDictionaryAddValue(filteredException, key, CFDictionaryGetValue(ctx->oldException, key));
return;
}
bool allowed = false;
if (CFEqual(keystr, CFSTR("SHA1Digest"))) {
allowed = true; // this key is informational and always permitted
}
else if (CFEqual(keystr, CFSTR("NotValidBefore"))) {
allowed = ((options & kSecTrustOptionAllowExpired) != 0);
}
else if (CFEqual(keystr, CFSTR("ValidLeaf"))) {
allowed = ((options & kSecTrustOptionAllowExpired) != 0);
}
else if (CFEqual(keystr, CFSTR("ValidIntermediates"))) {
allowed = ((options & kSecTrustOptionAllowExpired) != 0);
}
else if (CFEqual(keystr, CFSTR("ValidRoot"))) {
if (((options & kSecTrustOptionAllowExpired) != 0) ||
((options & kSecTrustOptionAllowExpiredRoot) != 0)) {
allowed = true;
}
}
else if (CFEqual(keystr, CFSTR("AnchorTrusted"))) {
bool implicitAnchors = ((options & kSecTrustOptionImplicitAnchors) != 0);
// Implicit anchors option only filters exceptions for self-signed certs
if (implicitAnchors && ctx->trustRef &&
(ctx->certIX < SecTrustGetCertificateCount(ctx->trustRef))) {
Boolean isSelfSigned = false;
SecCertificateRef cert = SecTrustGetCertificateAtIndex(ctx->trustRef, ctx->certIX);
if (cert && (errSecSuccess == SecCertificateIsSelfSigned(cert, &isSelfSigned)) &&
isSelfSigned) {
allowed = true;
}
}
}
else if (CFEqual(keystr, CFSTR("KeyUsage")) ||
CFEqual(keystr, CFSTR("ExtendedKeyUsage")) ||
CFEqual(keystr, CFSTR("BasicConstraints")) ||
CFEqual(keystr, CFSTR("NonEmptySubject")) ||
CFEqual(keystr, CFSTR("IdLinkage"))) {
// Cannot override these exceptions
allowed = false;
}
else {
// Unhandled exceptions should not be overridden,
// but we want to know which ones we're missing
char *cstr = CFStringToCString(keystr);
syslog(LOG_ERR, "Unfiltered exception: %s", (cstr) ? cstr : "<NULL>");
if (cstr) { free(cstr); }
allowed = false;
}
if (allowed) {
CFDictionaryAddValue(filteredException, key, value);
}
}
__private_extern__
int
__SCDynamicStoreRemoveValue(SCDynamicStoreRef store, CFStringRef key, Boolean internal)
{
CFDictionaryRef dict;
CFMutableDictionaryRef newDict;
SCDynamicStorePrivateRef storePrivate = (SCDynamicStorePrivateRef)store;
int sc_status = kSCStatusOK;
CFStringRef sessionKey;
SC_trace(_configd_trace, "%s : %5d : %@\n",
internal ? "*remove" : "remove ",
storePrivate->server,
key);
/*
* Ensure that this key exists.
*/
dict = CFDictionaryGetValue(storeData, key);
if ((dict == NULL) || (CFDictionaryContainsKey(dict, kSCDData) == FALSE)) {
/* key doesn't exist (or data never defined) */
sc_status = kSCStatusNoKey;
goto done;
}
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
/*
* Mark this key as "changed". Any "watchers" will be
* notified as soon as the lock is released.
*/
CFSetAddValue(changedKeys, key);
/*
* Add this key to a deferred cleanup list so that, after
* the change notifications are posted, any associated
* regex keys can be removed.
*/
CFSetAddValue(deferredRemovals, key);
/*
* Check if this is a session key and, if so, add it
* to the (session) removal list
*/
sessionKey = CFDictionaryGetValue(newDict, kSCDSession);
if (sessionKey) {
CFStringRef removedKey;
/* We are no longer a session key! */
CFDictionaryRemoveValue(newDict, kSCDSession);
/* add this session key to the (session) removal list */
removedKey = CFStringCreateWithFormat(NULL, 0, CFSTR("%@:%@"), sessionKey, key);
CFSetAddValue(removedSessionKeys, removedKey);
CFRelease(removedKey);
}
/*
* Remove data and update/remove the dictionary store entry.
*/
CFDictionaryRemoveValue(newDict, kSCDData);
if (CFDictionaryGetCount(newDict) > 0) {
/* this key is still being "watched" */
CFDictionarySetValue(storeData, key, newDict);
} else {
/* no information left, remove the empty dictionary */
CFDictionaryRemoveValue(storeData, key);
}
CFRelease(newDict);
if (!internal) {
/* push changes */
__SCDynamicStorePush();
}
done:
return sc_status;
}
/*************************************************************************
*
* hu_AddDeviceElementToUsageXML( inDevice, inElement )
*
* Purpose: add a device and it's elements to our usage( XML ) file
*
* Inputs: inDevice - the device
* inElement - the element
*
* Returns: Boolean - if successful
*/
static Boolean hu_AddDeviceElementToUsageXML(IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef) {
Boolean results = FALSE;
if ( gUsageCFPropertyListRef ) {
CFRelease(gUsageCFPropertyListRef);
}
gUsageCFPropertyListRef =
hu_XMLLoad( CFSTR(
"HID_device_usage_strings"), CFSTR("plist") );
if ( gUsageCFPropertyListRef ) {
CFMutableDictionaryRef tCFMutableDictionaryRef =
CFDictionaryCreateMutableCopy(
kCFAllocatorDefault,
0,
gUsageCFPropertyListRef);
if ( tCFMutableDictionaryRef ) {
CFMutableDictionaryRef vendorCFMutableDictionaryRef;
CFMutableDictionaryRef productCFMutableDictionaryRef;
CFStringRef productKeyCFStringRef;
CFStringRef usageKeyCFStringRef;
// if the vendor dictionary exists...
long vendorID = IOHIDDevice_GetVendorID(inIOHIDDeviceRef);
CFStringRef vendorKeyCFStringRef = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%ld"), vendorID);
if ( vendorKeyCFStringRef ) {
if ( CFDictionaryGetValueIfPresent(tCFMutableDictionaryRef, vendorKeyCFStringRef,
(const void **) &vendorCFMutableDictionaryRef) )
{
// ...copy it...
vendorCFMutableDictionaryRef = CFDictionaryCreateMutableCopy(kCFAllocatorDefault,
0,
vendorCFMutableDictionaryRef);
} else { // ...otherwise...
// ...create it.
vendorCFMutableDictionaryRef = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
results = TRUE;
}
// if the vendor name key doesn't exist...
if ( !CFDictionaryContainsKey(vendorCFMutableDictionaryRef, kNameKeyCFStringRef) ) {
CFStringRef manCFStringRef = IOHIDDevice_GetManufacturer(inIOHIDDeviceRef);
// ...create it.
CFDictionaryAddValue(vendorCFMutableDictionaryRef, kNameKeyCFStringRef, manCFStringRef);
results = TRUE;
}
// if the product key exists in the vendor dictionary...
long productID = IOHIDDevice_GetProductID(inIOHIDDeviceRef);
productKeyCFStringRef = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%ld"), productID);
if ( CFDictionaryGetValueIfPresent(vendorCFMutableDictionaryRef, productKeyCFStringRef,
(const void **) &productCFMutableDictionaryRef) )
{
// ...copy it...
productCFMutableDictionaryRef = CFDictionaryCreateMutableCopy(kCFAllocatorDefault,
0,
productCFMutableDictionaryRef);
} else { // ...otherwise...
// ...create it.
productCFMutableDictionaryRef = CFDictionaryCreateMutable(kCFAllocatorDefault,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
results = TRUE;
}
// if the product name key doesn't exist...
if ( !CFDictionaryContainsKey(productCFMutableDictionaryRef, kNameKeyCFStringRef) ) {
CFStringRef productCFStringRef = IOHIDDevice_GetProduct(inIOHIDDeviceRef);
// ...create it.
CFDictionaryAddValue(productCFMutableDictionaryRef, kNameKeyCFStringRef, productCFStringRef);
results = TRUE;
}
// if the usage key doesn't exist in the product dictionary...
uint32_t usagePage = IOHIDElementGetUsagePage(inIOHIDElementRef);
uint32_t usage = IOHIDElementGetUsagePage(inIOHIDElementRef);
usageKeyCFStringRef = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%ld:%ld"), usagePage, usage);
if ( usageKeyCFStringRef ) {
if ( !CFDictionaryContainsKey(productCFMutableDictionaryRef, usageKeyCFStringRef) ) {
// find it's generic name
CFStringRef usageCFStringRef = HIDCopyUsageName(usagePage, usage);
if ( usageCFStringRef ) {
// and add that.
CFDictionaryAddValue(productCFMutableDictionaryRef, usageKeyCFStringRef, usageCFStringRef);
results = TRUE;
CFRelease(usageCFStringRef);
}
}
CFRelease(usageKeyCFStringRef);
}
if ( vendorCFMutableDictionaryRef ) {
if ( productCFMutableDictionaryRef ) {
if ( results ) {
CFDictionarySetValue(vendorCFMutableDictionaryRef, productKeyCFStringRef, productCFMutableDictionaryRef);
}
CFRelease(productCFMutableDictionaryRef);
}
if ( results ) {
CFDictionarySetValue(tCFMutableDictionaryRef, vendorKeyCFStringRef, vendorCFMutableDictionaryRef);
}
CFRelease(vendorCFMutableDictionaryRef);
}
CFRelease(vendorKeyCFStringRef);
}
if ( productKeyCFStringRef ) {
CFRelease(productKeyCFStringRef);
}
if ( results ) {
hu_XMLSave( tCFMutableDictionaryRef,
CFSTR(
"HID_device_usage_strings"), CFSTR("plist") );
}
CFRelease(
tCFMutableDictionaryRef);
}
}
return (results);
} // hu_AddDeviceElementToUsageXML
void RunAppOnDeviceWithIdentifier(char *udid, char *identifier, bool waitForDebugger)
{
SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid);
if (device) {
sdmmd_return_t result = SDMMD_AMDeviceConnect(device);
if (SDM_MD_CallSuccessful(result)) {
result = SDMMD_AMDeviceStartSession(device);
if (SDM_MD_CallSuccessful(result)) {
CFDictionaryRef response;
CFArrayRef lookupValues = SDMMD_ApplicationLookupDictionary();
CFMutableDictionaryRef optionsDict = SDMMD_create_dict();
CFDictionarySetValue(optionsDict, CFSTR("ReturnAttributes"), lookupValues);
result = SDMMD_AMDeviceLookupApplications(device, optionsDict, &response);
if (SDM_MD_CallSuccessful(result)) {
CFStringRef bundleIdentifier = CFStringCreateWithCString(kCFAllocatorDefault, identifier, kCFStringEncodingUTF8);
CFDictionaryRef details = NULL;
if (CFDictionaryContainsKey(response, bundleIdentifier)) {
details = CFDictionaryGetValue(response, bundleIdentifier);
}
CFSafeRelease(bundleIdentifier);
if (details) {
SDMMD_AMDeviceStopSession(device);
SDMMD_AMDeviceDisconnect(device);
SDMMD_AMDebugConnectionRef dconn = SDMMD_AMDebugConnectionCreateForDevice(device);
sdmmd_return_t result = SDMMD_AMDebugConnectionStart(dconn);
bool launchSuccess = false;
if (SDM_MD_CallSuccessful(result)) {
// setting max packet size
CFMutableArrayRef maxPacketArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(maxPacketArgs, CFSTR("1024"));
DebuggerCommandRef maxPacket = SDMMD_CreateDebuggingCommand(kDebugQSetMaxPacketSize, NULL, maxPacketArgs);
CFSafeRelease(maxPacketArgs);
CFDataRef maxPacketResponse = NULL;
result = SDMMD_DebuggingSend(dconn, maxPacket, &maxPacketResponse);
CFSafeRelease(maxPacketResponse);
SDMMD_DebuggingCommandRelease(maxPacket);
// setting the working directory
CFStringRef path = CFDictionaryGetValue(details, CFSTR("Path"));
CFStringRef container = CFDictionaryGetValue(details, CFSTR("Container"));
if (!container) {
CFURLRef pathURL = CFURLCreateWithString(kCFAllocatorDefault, path, NULL);
CFURLRef containerURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, pathURL);
container = CFURLGetString(containerURL);
CFSafeRelease(pathURL);
}
CFMutableArrayRef containerPathArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(containerPathArgs, container);
DebuggerCommandRef containerPath = SDMMD_CreateDebuggingCommand(kDebugQSetWorkingDir, NULL, containerPathArgs);
CFSafeRelease(containerPathArgs);
CFDataRef containerPathResponse = NULL;
result = SDMMD_DebuggingSend(dconn, containerPath, &containerPathResponse);
CFSafeRelease(containerPathResponse);
SDMMD_DebuggingCommandRelease(containerPath);
// setting launch args
CFStringRef commandFormat = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("A%d,0,"), (uint32_t)CFStringGetLength(path) * 0x2);
CFMutableArrayRef setLaunchArgsArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(setLaunchArgsArgs, path);
DebuggerCommandRef setLaunchArgs = SDMMD_CreateDebuggingCommand(kDebugCUSTOMCOMMAND, commandFormat, setLaunchArgsArgs);
CFSafeRelease(setLaunchArgsArgs);
CFSafeRelease(commandFormat);
CFDataRef setLaunchArgsResponse = NULL;
result = SDMMD_DebuggingSend(dconn, setLaunchArgs, &setLaunchArgsResponse);
CFSafeRelease(setLaunchArgsResponse);
SDMMD_DebuggingCommandRelease(setLaunchArgs);
// Check for launch success
CFMutableArrayRef launchSuccessArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
DebuggerCommandRef launchSuccessCommand = SDMMD_CreateDebuggingCommand(kDebugqLaunchSuccess, NULL, launchSuccessArgs);
CFSafeRelease(launchSuccessArgs);
CFDataRef launchSuccessResponse = NULL;
result = SDMMD_DebuggingSend(dconn, launchSuccessCommand, &launchSuccessResponse);
if (launchSuccessResponse) {
char *launchSuccessResponseAsString = (char *)CFDataGetBytePtr(launchSuccessResponse);
launchSuccess = !strncmp(launchSuccessResponseAsString, "OK", 2);
if (!launchSuccess) {
printf("Launch failure: %s\n", launchSuccessResponseAsString);
}
}
CFSafeRelease(launchSuccessResponse);
SDMMD_DebuggingCommandRelease(launchSuccessCommand);
if (launchSuccess) {
printf("Launch success\n");
if (!waitForDebugger) {
printf("Continuing with execution...\n");
// setting thread to attach
CFMutableArrayRef setThreadArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(setThreadArgs, CFSTR(""));
DebuggerCommandRef setThread = SDMMD_CreateDebuggingCommand(kDebugCUSTOMCOMMAND, CFSTR("Hc0"), setThreadArgs);
CFSafeRelease(setThreadArgs);
CFDataRef setThreadResponse = NULL;
result = SDMMD_DebuggingSend(dconn, setThread, &setThreadResponse);
CFSafeRelease(setThreadResponse);
SDMMD_DebuggingCommandRelease(setThread);
// setting continue with execution
CFMutableArrayRef contArgs = CFArrayCreateMutable(kCFAllocatorDefault, 0x0, &kCFTypeArrayCallBacks);
CFArrayAppendValue(contArgs, CFSTR(""));
DebuggerCommandRef cont = SDMMD_CreateDebuggingCommand(kDebugc, NULL, contArgs);
CFSafeRelease(contArgs);
CFDataRef contResponse = NULL;
result = SDMMD_DebuggingSend(dconn, cont, &contResponse);
CFSafeRelease(contResponse);
SDMMD_DebuggingCommandRelease(cont);
}
else {
printf("Waiting for debugger to attach...\n");
CFRunLoopRun();
}
}
}
/*
sdmmd_return_t result = SDMMD_StartDebuggingSessionOnDevice(device, &connection);
if (SDM_MD_CallSuccessful(result)) {
bool launchSuccess = false;
CFStringRef path = CFDictionaryGetValue(details, CFSTR("Path"));
CFStringRef encodedPath = SDMMD_EncodeDebuggingString(path);
CFStringRef container = CFDictionaryGetValue(details, CFSTR("Container"));
if (!container) {
CFURLRef pathURL = CFURLCreateWithString(kCFAllocatorDefault, path, NULL);
CFURLRef containerURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, pathURL);
container = CFURLGetString(containerURL);
CFSafeRelease(pathURL);
//CFSafeRelease(containerURL);
}
if (container) {
CFStringRef containerPath = SDMMD_EncodeDebuggingString(container);
sdmmd_debug_return_t dresult;
CFStringRef maxPacket = SDMMD_EncodeDebuggingString(CFSTR("1024"));
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugQSetMaxPacketSize], maxPacket);
CFSafeRelease(maxPacket);
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugQSetWorkingDir], containerPath);
CFSafeRelease(containerPath);
CFStringRef commandFormat = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%d,0,%s"), (uint32_t)CFStringGetLength(encodedPath), CFStringGetCStringPtr(encodedPath, kCFStringEncodingUTF8));
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugA], commandFormat);
CFSafeRelease(commandFormat);
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugH], CFSTR("c0"));
dresult = SDMMD_DebuggingSend(connection, KnownDebugCommands[kDebugc], CFSTR(""));
launchSuccess = true;
}
CFSafeRelease(encodedPath);
if (launchSuccess) {
CFRunLoopRun();
}
}
*/
}
}
}
}
}
}
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;
}
//////
//
// DBPluginLoadPlugins
// returns -1 if the plugin dictionary cannot be
// created, otherwise returns 0
//
/////
int DBPluginLoadPlugins(const char* plugin_path) {
if (plugins == NULL) {
plugins = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &cfDictionaryPluginValueCallBacks);
}
if (plugins == NULL) return -1;
//
// If the path contains colons, split the path and
// search each path component. If there are no
// colons, CFStringCreateArrayBySeparatingStrings()
// will return an array with one element being the
// entire path.
//
CFStringRef str = cfstr(plugin_path);
CFArrayRef array = CFStringCreateArrayBySeparatingStrings(NULL, str, CFSTR(":"));
CFRelease(str);
CFIndex i, path_argc = CFArrayGetCount(array);
char** path_argv = malloc(sizeof(char*)*(path_argc+1));
for (i = 0; i < path_argc; ++i) {
path_argv[i] = strdup_cfstr(CFArrayGetValueAtIndex(array, i));
}
path_argv[i] = NULL;
CFRelease(array);
//
// Search the directories for plugins
//
FTSENT* ent;
FTS* dir = fts_open((char * const *)path_argv, FTS_LOGICAL, NULL);
while ((ent = fts_read(dir)) != NULL) {
DBPlugin* plugin = NULL;
if (strstr(ent->fts_name, ".so")) {
//fprintf(stderr, "plugin: loading %s\n", ent->fts_accpath);
void* handle = dlopen(ent->fts_accpath, RTLD_LAZY | RTLD_LOCAL);
if (handle) {
DBPluginInitializeFunc func = dlsym(handle, "initialize");
if (!func) {
fprintf(stderr, "plugin: cannot find initialize for: %s\n%s\n", ent->fts_accpath, dlerror());
return -1;
}
plugin = _DBPluginInitialize();
if (!plugin) {
fprintf(stderr, "plugin: failed to initialize %s\n", ent->fts_accpath);
return -1;
}
_DBPluginSetCurrentPlugin(plugin);
(*func)(kDBPluginCurrentVersion); // Call out to C plugin
// XXX: check for error?
} else {
fprintf(stderr, "Could not dlopen plugin: %s\n", ent->fts_name);
}
#if HAVE_TCL_PLUGINS
} else if (strstr(ent->fts_name, ".tcl")) {
plugin = _DBPluginInitialize();
_DBPluginSetCurrentPlugin(plugin);
load_tcl_plugin(plugin, ent->fts_accpath); // Calls out to Tcl plugin
#endif
}
if (plugin) {
if (plugin->name == NULL) {
fprintf(stderr, "warning: plugin has no name (skipping): %s\n", ent->fts_name);
} else if (plugin->type == kDBPluginNullType) {
fprintf(stderr, "warning: plugin has no type (skipping): %s\n", ent->fts_name);
} else {
if (CFDictionaryContainsKey(plugins, plugin->name)) {
fprintf(stderr,
"Error: already have a plugin loaded with name '%s' when "
"trying to load %s\n",
strdup_cfstr(plugin->name), ent->fts_accpath);
return -1;
}
CFDictionarySetValue(plugins, plugin->name, plugin);
}
}
ent = ent->fts_link;
}
fts_close(dir);
//
// Release the path array
//
for (i = 0; i < path_argc; ++i) {
free(path_argv[i]);
}
free(path_argv);
return 0;
}
static CFDictionaryRef
copy_app_layer_vpn_proxies(CFDictionaryRef services, CFArrayRef order, CFDictionaryRef services_info)
{
CFMutableDictionaryRef app_layer_proxies = NULL;
CFIndex i;
CFIndex n_order;
if (!isA_CFDictionary(services_info)) {
return NULL;
}
// iterate over services
n_order = isA_CFArray(order) ? CFArrayGetCount(order) : 0;
for (i = 0; i < n_order; i++) {
CFMutableDictionaryRef newProxy;
CFDictionaryRef proxy;
CFDictionaryRef service;
CFStringRef serviceID;
CFDictionaryRef vpn;
CFStringRef vpn_key;
serviceID = CFArrayGetValueAtIndex(order, i);
service = CFDictionaryGetValue(services, serviceID);
if (!isA_CFDictionary(service)) {
// if no service
continue;
}
proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
if (!isA_CFDictionary(proxy)) {
// if no proxy
continue;
}
vpn_key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainSetup,
serviceID,
kSCEntNetVPN);
vpn = CFDictionaryGetValue(services_info, vpn_key);
CFRelease(vpn_key);
if (!isA_CFDictionary(vpn) || !CFDictionaryContainsKey(vpn, kSCPropNetVPNAppRules)) {
// if not app-layer vpn
continue;
}
if ((app_layer_proxies != NULL) &&
CFDictionaryContainsKey(app_layer_proxies, serviceID)) {
// if we've already processed this [app_layer_proxies] interface
continue;
}
// add [app_layer_proxies] proxy entry
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
if (app_layer_proxies == NULL) {
app_layer_proxies = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(app_layer_proxies, serviceID, newProxy);
CFRelease(newProxy);
}
return app_layer_proxies;
}
bool CACFDictionary::HasKey(const CFStringRef inKey) const
{
return CFDictionaryContainsKey(mCFDictionary, inKey) != 0;
}
static CFDictionaryRef
copy_scoped_proxies(CFDictionaryRef services, CFArrayRef order)
{
CFIndex i;
CFIndex n_order;
CFMutableDictionaryRef scoped = NULL;
// iterate over services
n_order = isA_CFArray(order) ? CFArrayGetCount(order) : 0;
for (i = 0; i < n_order; i++) {
char if_name[IF_NAMESIZE];
CFStringRef interface;
CFMutableDictionaryRef newProxy;
CFDictionaryRef proxy;
CFDictionaryRef service;
CFStringRef serviceID;
serviceID = CFArrayGetValueAtIndex(order, i);
service = CFDictionaryGetValue(services, serviceID);
if (!isA_CFDictionary(service)) {
// if no service
continue;
}
proxy = CFDictionaryGetValue(service, kSCEntNetProxies);
if (!isA_CFDictionary(proxy)) {
// if no proxy
continue;
}
interface = CFDictionaryGetValue(proxy, kSCPropInterfaceName);
if (interface == NULL) {
// if no [scoped] interface
continue;
}
if ((scoped != NULL) &&
CFDictionaryContainsKey(scoped, interface)) {
// if we've already processed this [scoped] interface
continue;
}
if ((_SC_cfstring_to_cstring(interface,
if_name,
sizeof(if_name),
kCFStringEncodingASCII) == NULL) ||
((if_nametoindex(if_name)) == 0)) {
// if interface index not available
continue;
}
// add [scoped] proxy entry
// ... and remove keys we don't want in a [scoped] proxy
CFRetain(interface);
newProxy = CFDictionaryCreateMutableCopy(NULL, 0, proxy);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchDomains);
CFDictionaryRemoveValue(newProxy, kSCPropNetProxiesSupplementalMatchOrders);
CFDictionaryRemoveValue(newProxy, kSCPropInterfaceName);
if (scoped == NULL) {
scoped = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(scoped, interface, newProxy);
CFRelease(newProxy);
CFRelease(interface);
}
return scoped;
}
CFDictionaryRef APCreateDictionaryForLicenseData(CFDataRef data)
{
if (!rsaKey->n || !rsaKey->e)
return NULL;
// Make the property list from the data
CFStringRef errorString = NULL;
CFPropertyListRef propertyList;
propertyList = CFPropertyListCreateFromXMLData(kCFAllocatorDefault, data, kCFPropertyListMutableContainers, &errorString);
if (errorString || CFDictionaryGetTypeID() != CFGetTypeID(propertyList) || !CFPropertyListIsValid(propertyList, kCFPropertyListXMLFormat_v1_0)) {
if (propertyList)
CFRelease(propertyList);
return NULL;
}
// Load the signature
CFMutableDictionaryRef licenseDictionary = (CFMutableDictionaryRef)propertyList;
if (!CFDictionaryContainsKey(licenseDictionary, CFSTR("Signature"))) {
CFRelease(licenseDictionary);
return NULL;
}
CFDataRef sigData = CFDictionaryGetValue(licenseDictionary, CFSTR("Signature"));
CFIndex sigDataLength = CFDataGetLength(sigData);
UInt8 sigBytes[sigDataLength];
CFDataGetBytes(sigData, CFRangeMake(0, sigDataLength), sigBytes);
CFDictionaryRemoveValue(licenseDictionary, CFSTR("Signature"));
// Decrypt the signature
int checkDigestMaxSize = RSA_size(rsaKey)-11;
unsigned char checkDigest[checkDigestMaxSize];
if (RSA_public_decrypt((int) sigDataLength, sigBytes, checkDigest, rsaKey, RSA_PKCS1_PADDING) != SHA_DIGEST_LENGTH) {
CFRelease(licenseDictionary);
return NULL;
}
// Get the license hash
CFMutableStringRef hashCheck = CFStringCreateMutable(kCFAllocatorDefault,0);
int hashIndex;
for (hashIndex = 0; hashIndex < SHA_DIGEST_LENGTH; hashIndex++)
CFStringAppendFormat(hashCheck, nil, CFSTR("%02x"), checkDigest[hashIndex]);
APSetHash(hashCheck);
CFRelease(hashCheck);
if (blacklist && (CFArrayContainsValue(blacklist, CFRangeMake(0, CFArrayGetCount(blacklist)), hash) == true))
return NULL;
// Get the number of elements
CFIndex count = CFDictionaryGetCount(licenseDictionary);
// Load the keys and build up the key array
CFMutableArrayRef keyArray = CFArrayCreateMutable(kCFAllocatorDefault, count, NULL);
CFStringRef keys[count];
CFDictionaryGetKeysAndValues(licenseDictionary, (const void**)&keys, NULL);
int i;
for (i = 0; i < count; i++)
CFArrayAppendValue(keyArray, keys[i]);
// Sort the array
int context = kCFCompareCaseInsensitive;
CFArraySortValues(keyArray, CFRangeMake(0, count), (CFComparatorFunction)CFStringCompare, &context);
// Setup up the hash context
SHA_CTX ctx;
SHA1_Init(&ctx);
// Convert into UTF8 strings
for (i = 0; i < count; i++)
{
char *valueBytes;
CFIndex valueLengthAsUTF8;
CFStringRef key = CFArrayGetValueAtIndex(keyArray, i);
CFStringRef value = CFDictionaryGetValue(licenseDictionary, key);
// Account for the null terminator
valueLengthAsUTF8 = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value), kCFStringEncodingUTF8) + 1;
valueBytes = (char *)malloc(valueLengthAsUTF8);
CFStringGetCString(value, valueBytes, valueLengthAsUTF8, kCFStringEncodingUTF8);
SHA1_Update(&ctx, valueBytes, strlen(valueBytes));
free(valueBytes);
}
unsigned char digest[SHA_DIGEST_LENGTH];
SHA1_Final(digest, &ctx);
if (keyArray != NULL)
CFRelease(keyArray);
// Check if the signature is a match
for (i = 0; i < SHA_DIGEST_LENGTH; i++) {
if (checkDigest[i] ^ digest[i]) {
CFRelease(licenseDictionary);
return NULL;
}
}
// If it's a match, we return the dictionary; otherwise, we never reach this
return licenseDictionary;
}
void simpleDictionaryExample(void) {
CFMutableDictionaryRef dict;
CFTypeRef value;
Boolean booleanResult;
CFNumberRef number;
int someInt = 42;
// Create a pretty standard mutable dictionary: CF type keys, CF type values.
// If you only have a few values to initialize with, it might also make sense to use an immutable
// dictionary, which is more efficient.
// With the standard callbacks used below, the keys and values will be retained/released as they
// are added to and removed from the CFDictionary. CFHash() and CFEqual() will be called
// on the keys to determine matches.
// If you are using just CFStrings as keys, it might also make sense to use kCFCopyStringDictionaryKeyCallBacks
// for the key callbacks. This callback set will copy the keys, which is more safe. (Note that copying is
// fast for strings if the string is actually immutable, so there's no performance hit.)
dict = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
// Put some stuff in the dictionary
CFDictionarySetValue(dict, CFSTR("A String Key"), CFSTR("A String Value"));
// Use a CFNumber() as a value, also as a key
number = CFNumberCreate(NULL, kCFNumberIntType, &someInt);
CFDictionarySetValue(dict, CFSTR("Another string key"), number);
CFDictionarySetValue(dict, number, CFSTR("Another string value"));
// Because inserting the CFNumber in the CFDictionary retains it,
// we can give up ownership and the number will be properly released
// when the dictionary is released...
CFRelease(number);
// Now print the dictionary and do some queries...
show(CFSTR("Dictionary: %@"), dict);
// Should find the CFString "A String Value"
// Note that the keys don't just have to be ==, because CFEqual() compares values of CFTypes
// Also note that the returned value should not be freed, as it is owned by the dictionary
value = CFDictionaryGetValue(dict, CFSTR("A String Key"));
show(CFSTR("Value for key \"A String Key\": %@"), value);
// Other ways to look up (in order to distinguish NULL value from whether the key is there at all...)
booleanResult = CFDictionaryContainsKey(dict, CFSTR("A String Key"));
booleanResult = CFDictionaryGetValueIfPresent(dict, CFSTR("A String Key"), &value);
// Should return NULL, as this key doesn't exist
value = CFDictionaryGetValue(dict, CFSTR("This key isn't in the dictionary"));
// Now free the dictionary along with all the keys and values
CFRelease(dict);
}
static void
flatten(SCPreferencesRef prefs,
CFStringRef key,
CFDictionaryRef base)
{
CFDictionaryRef subset;
CFStringRef link;
CFMutableDictionaryRef myDict;
CFStringRef myKey;
CFIndex i;
CFIndex nKeys;
const void **keys;
const void **vals;
if (!CFDictionaryGetValueIfPresent(base, kSCResvLink, (const void **)&link)) {
/* if this dictionary is not linked */
subset = base;
} else {
/* if __LINK__ key is present */
subset = SCPreferencesPathGetValue(prefs, link);
if (!subset) {
/* if error with link */
SCLog(TRUE, LOG_ERR,
CFSTR("SCPreferencesPathGetValue(,%@,) failed: %s"),
link,
SCErrorString(SCError()));
return;
}
}
if (CFDictionaryContainsKey(subset, kSCResvInactive)) {
/* if __INACTIVE__ key is present */
return;
}
myKey = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@%@"),
kSCDynamicStoreDomainSetup,
key);
myDict = (CFMutableDictionaryRef)CFDictionaryGetValue(newPrefs, myKey);
if (myDict) {
myDict = CFDictionaryCreateMutableCopy(NULL,
0,
(CFDictionaryRef)myDict);
} else {
myDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
nKeys = CFDictionaryGetCount(subset);
if (nKeys > 0) {
keys = CFAllocatorAllocate(NULL, nKeys * sizeof(CFStringRef) , 0);
vals = CFAllocatorAllocate(NULL, nKeys * sizeof(CFPropertyListRef), 0);
CFDictionaryGetKeysAndValues(subset, keys, vals);
for (i = 0; i < nKeys; i++) {
if (CFGetTypeID((CFTypeRef)vals[i]) != CFDictionaryGetTypeID()) {
/* add this key/value to the current dictionary */
CFDictionarySetValue(myDict, keys[i], vals[i]);
} else {
CFStringRef subKey;
/* flatten [sub]dictionaries */
subKey = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("%@%s%@"),
key,
CFEqual(key, CFSTR("/")) ? "" : "/",
keys[i]);
flatten(prefs, subKey, vals[i]);
CFRelease(subKey);
}
}
CFAllocatorDeallocate(NULL, keys);
CFAllocatorDeallocate(NULL, vals);
}
if (CFDictionaryGetCount(myDict) > 0) {
/* add this dictionary to the new preferences */
CFDictionarySetValue(newPrefs, myKey, myDict);
}
CFRelease(myDict);
CFRelease(myKey);
return;
}
