static CFMutableDictionaryRef
copyIF(CFStringRef key, CFMutableDictionaryRef oldIFs, CFMutableDictionaryRef newIFs)
{
CFDictionaryRef dict = NULL;
CFMutableDictionaryRef newDict = NULL;
if (CFDictionaryGetValueIfPresent(newIFs, key, (const void **)&dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
} else {
dict = cache_SCDynamicStoreCopyValue(store, key);
if (dict) {
CFDictionarySetValue(oldIFs, key, dict);
if (isA_CFDictionary(dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6Addresses);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6DestAddresses);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6Flags);
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6PrefixLength);
#ifdef NOTYET
CFDictionaryRemoveValue(newDict, kSCPropNetIPv6ScopeID);
#endif /* NOTYET */
}
CFRelease(dict);
}
}
if (!newDict) {
newDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
return newDict;
}
CFDictionaryRef SFB::Audio::Metadata::CreateDictionaryRepresentation() const
{
CFMutableDictionaryRef dictionaryRepresentation = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, mMetadata);
CFIndex count = CFDictionaryGetCount(mChangedMetadata);
CFTypeRef *keys = (CFTypeRef *)malloc(sizeof(CFTypeRef) * (size_t)count);
CFTypeRef *values = (CFTypeRef *)malloc(sizeof(CFTypeRef) * (size_t)count);
CFDictionaryGetKeysAndValues(mChangedMetadata, keys, values);
for(CFIndex i = 0; i < count; ++i) {
if(kCFNull == values[i])
CFDictionaryRemoveValue(dictionaryRepresentation, keys[i]);
else
CFDictionarySetValue(dictionaryRepresentation, keys[i], values[i]);
}
free(keys), keys = nullptr;
free(values), values = nullptr;
CFMutableArray pictureArray = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
for(auto picture : GetAttachedPictures()) {
CFDictionary pictureRepresentation = picture->CreateDictionaryRepresentation();
CFArrayAppendValue(pictureArray, pictureRepresentation);
}
if(0 < CFArrayGetCount(pictureArray)) {
CFDictionarySetValue(dictionaryRepresentation, kAttachedPicturesKey, pictureArray);
}
return dictionaryRepresentation;
}
// Assumes the domain has already been locked
static void _loadXMLDomainIfStale(CFURLRef url, _CFXMLPreferencesDomain *domain) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
int idx;
if (domain->_domainDict) {
CFDateRef modDate;
CFAbsoluteTime modTime;
CFURLRef testURL = url;
if (CFDictionaryGetCount(domain->_domainDict) == 0) {
// domain never existed; check the parent directory, not the child
testURL = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR(".."), kCFURLPOSIXPathStyle, true, url);
}
modDate = (CFDateRef )CFURLCreatePropertyFromResource(alloc, testURL, kCFURLFileLastModificationTime, NULL);
modTime = modDate ? CFDateGetAbsoluteTime(modDate) : 0.0;
// free before possible return. we can test non-NULL of modDate but don't depend on contents after this.
if (testURL != url) CFRelease(testURL);
if (modDate) CFRelease(modDate);
if (modDate != NULL && modTime < domain->_lastReadTime) { // We're up-to-date
return;
}
}
// We're out-of-date; destroy domainDict and reload
if (domain->_domainDict) {
CFRelease(domain->_domainDict);
domain->_domainDict = NULL;
}
// We no longer lock on read; instead, we assume parse failures are because someone else is writing the file, and just try to parse again. If we fail 3 times in a row, we assume the file is corrupted. REW, 7/13/99
for (idx = 0; idx < 3; idx ++) {
CFDataRef data;
if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &data, NULL, NULL, NULL) || !data) {
// Either a file system error (so we can't read the file), or an empty (or perhaps non-existant) file
domain->_domainDict = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
break;
} else {
CFTypeRef pList = CFPropertyListCreateFromXMLData(alloc, data, kCFPropertyListImmutable, NULL);
CFRelease(data);
if (pList && CFGetTypeID(pList) == CFDictionaryGetTypeID()) {
domain->_domainDict = CFDictionaryCreateMutableCopy(alloc, 0, (CFDictionaryRef)pList);
CFRelease(pList);
break;
} else if (pList) {
CFRelease(pList);
}
// Assume the file is being written; sleep for a short time (to allow the write to complete) then re-read
__CFMilliSleep(150);
}
}
if (!domain->_domainDict) {
// Failed to ever load
domain->_domainDict = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
domain->_lastReadTime = CFAbsoluteTimeGetCurrent();
}
CF_PRIVATE UCalendar *__CFCalendarCreateUCalendar(CFStringRef calendarID, CFStringRef localeID, CFTimeZoneRef tz) {
if (calendarID) {
CFDictionaryRef components = CFLocaleCreateComponentsFromLocaleIdentifier(kCFAllocatorSystemDefault, localeID);
CFMutableDictionaryRef mcomponents = CFDictionaryCreateMutableCopy(kCFAllocatorSystemDefault, 0, components);
CFDictionarySetValue(mcomponents, kCFLocaleCalendarIdentifier, calendarID);
localeID = CFLocaleCreateLocaleIdentifierFromComponents(kCFAllocatorSystemDefault, mcomponents);
CFRelease(mcomponents);
CFRelease(components);
}
char buffer[BUFFER_SIZE];
const char *cstr = CFStringGetCStringPtr(localeID, kCFStringEncodingASCII);
if (NULL == cstr) {
if (CFStringGetCString(localeID, buffer, BUFFER_SIZE, kCFStringEncodingASCII)) cstr = buffer;
}
if (NULL == cstr) {
if (calendarID) CFRelease(localeID);
return NULL;
}
UChar ubuffer[BUFFER_SIZE];
CFStringRef tznam = CFTimeZoneGetName(tz);
CFIndex cnt = CFStringGetLength(tznam);
if (BUFFER_SIZE < cnt) cnt = BUFFER_SIZE;
CFStringGetCharacters(tznam, CFRangeMake(0, cnt), (UniChar *)ubuffer);
UErrorCode status = U_ZERO_ERROR;
UCalendar *cal = ucal_open(ubuffer, cnt, cstr, UCAL_DEFAULT, &status);
if (calendarID) CFRelease(localeID);
return cal;
}
VALUE
rb_singleton_class_clone(VALUE obj)
{
VALUE klass = RBASIC(obj)->klass;
if (!RCLASS_SINGLETON(klass)) {
return klass;
}
// Create new singleton class.
VALUE clone = rb_objc_create_class(NULL, RCLASS_SUPER(klass));
// Copy ivars.
CFMutableDictionaryRef ivar_dict = rb_class_ivar_dict(klass);
if (ivar_dict != NULL) {
CFMutableDictionaryRef cloned_ivar_dict =
CFDictionaryCreateMutableCopy(NULL, 0, (CFDictionaryRef)ivar_dict);
rb_class_ivar_set_dict(clone, cloned_ivar_dict);
CFMakeCollectable(cloned_ivar_dict);
}
// Copy methods.
rb_vm_copy_methods((Class)klass, (Class)clone);
rb_singleton_class_attached(clone, obj);
if (RCLASS_SUPER(clone) == rb_cRubyObject) {
long v = RCLASS_VERSION(clone) ^ RCLASS_IS_OBJECT_SUBCLASS;
RCLASS_SET_VERSION(clone, v);
}
RCLASS_SET_VERSION_FLAG(clone, RCLASS_IS_SINGLETON);
return clone;
}
CFArrayRef SRCopyItems(CFArrayRef keychains, CFArrayRef classes) {
CFMutableArrayRef allItems = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
CFMutableDictionaryRef query = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(query, kSecMatchSearchList, keychains);
CFDictionarySetValue(query, kSecReturnRef, kCFBooleanTrue);
CFDictionarySetValue(query, kSecReturnAttributes, kCFBooleanTrue);
CFDictionarySetValue(query, kSecMatchLimit, kSecMatchLimitAll);
for (int i = 0; i < CFArrayGetCount(classes); i++) {
CFTypeRef class = CFArrayGetValueAtIndex(classes, i);
CFDictionarySetValue(query, kSecClass, class);
CFArrayRef items = NULL;
OSStatus status = SecItemCopyMatching(query, (CFTypeRef *)&items);
// If there are not results, that's fine; this class is just empty
if (errSecItemNotFound != status) {
SRHandleError(status, true);
for (int j = 0; j < CFArrayGetCount(items); j++) {
CFDictionaryRef properties = CFArrayGetValueAtIndex(items, j);
CFMutableDictionaryRef newProperties = CFDictionaryCreateMutableCopy(NULL, 0, properties);
CFDictionarySetValue(newProperties, kSRAttrClass, class);
CFArrayAppendValue(allItems, newProperties);
CFRelease(newProperties);
}
CFRelease(items);
}
}
static CFDictionaryRef
SecItemCopyAttributeDictionary(CFTypeRef ref) {
CFDictionaryRef refDictionary = NULL;
CFTypeID typeID = CFGetTypeID(ref);
if (typeID == SecKeyGetTypeID()) {
refDictionary = SecKeyCopyAttributeDictionary((SecKeyRef)ref);
} else if (typeID == SecCertificateGetTypeID()) {
refDictionary =
SecCertificateCopyAttributeDictionary((SecCertificateRef)ref);
} else if (typeID == SecIdentityGetTypeID()) {
assert(false);
SecIdentityRef identity = (SecIdentityRef)ref;
SecCertificateRef cert = NULL;
SecKeyRef key = NULL;
if (!SecIdentityCopyCertificate(identity, &cert) &&
!SecIdentityCopyPrivateKey(identity, &key))
{
CFDataRef data = SecCertificateCopyData(cert);
CFDictionaryRef key_dict = SecKeyCopyAttributeDictionary(key);
if (key_dict && data) {
refDictionary = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, key_dict);
CFDictionarySetValue((CFMutableDictionaryRef)refDictionary,
CFSTR(CERTIFICATE_DATA_COLUMN_LABEL), data);
}
CFReleaseNull(key_dict);
CFReleaseNull(data);
}
CFReleaseNull(cert);
CFReleaseNull(key);
} else {
refDictionary = NULL;
}
return refDictionary;
}
__private_extern__
void
do_dictRemoveKey(int argc, char **argv)
{
CFStringRef key;
CFMutableDictionaryRef val;
if (value == NULL) {
SCPrint(TRUE, stdout, CFSTR("d.remove: dictionary must be initialized.\n"));
return;
}
if (!isA_CFDictionary(value)) {
SCPrint(TRUE, stdout, CFSTR("d.remove: data (fetched from configuration server) is not a dictionary.\n"));
return;
}
val = CFDictionaryCreateMutableCopy(NULL, 0, value);
CFRelease(value);
value = val;
key = CFStringCreateWithCString(NULL, argv[0], kCFStringEncodingUTF8);
CFDictionaryRemoveValue((CFMutableDictionaryRef)value, key);
CFRelease(key);
return;
}
static OSStatus WorkaroundNetworkPrefsBug(CFDictionaryRef *entitiesDictPtr)
// If this is an Ethernet interface and LCPEchoEnabled is false,
// set it to true. This works around what I think is a bug in
// the Network preferences panel <rdar://problem/3182846> where the
// LCPEchoEnabled flag is mysteriously set to false for PCI Ethernet
// interfaces.
{
OSStatus err;
CFStringRef hardwarePath[2];
CFStringRef lcpPath[2];
CFStringRef hardwareStr;
CFNumberRef lcpValue;
long enabled;
hardwarePath[0] = kSCEntNetInterface;
hardwarePath[1] = kSCPropNetInterfaceHardware;
lcpPath[0] = kSCEntNetPPP;
lcpPath[1] = kSCPropNetPPPLCPEchoEnabled;
hardwareStr = NULL; // just to make debugging easier
lcpValue = NULL;
err = noErr;
if ( CFQDictionaryGetValueAtPath(*entitiesDictPtr, (const void **) hardwarePath, 2, (const void **) &hardwareStr) == noErr
&& CFEqual(hardwareStr, kSCEntNetEthernet)
&& CFQDictionaryGetValueAtPath(*entitiesDictPtr, (const void **) lcpPath, 2, (const void **) &lcpValue) == noErr
&& CFNumberGetValue(lcpValue, kCFNumberLongType, &enabled)
&& (enabled == 0) ) {
CFMutableDictionaryRef newDict;
CFNumberRef numRef;
if ( ! gRunQuiet ) {
fprintf(stderr, "Applied workaround\n");
}
numRef = NULL;
newDict = CFDictionaryCreateMutableCopy(NULL, 0, *entitiesDictPtr);
err = CFQError(newDict);
if (err == noErr) {
enabled = true;
numRef = CFNumberCreate(NULL, kCFNumberLongType, &enabled);
err = CFQError(numRef);
}
if (err == noErr) {
err = CFQDictionarySetValueAtPath(newDict, (const void **) lcpPath, 2, numRef);
}
if (err == noErr) {
CFQRelease(*entitiesDictPtr);
*entitiesDictPtr = newDict;
newDict = NULL;
}
CFQRelease(newDict);
CFQRelease(numRef);
}
return err;
}
static Boolean
_SCBondInterfaceSetMode(SCBondInterfaceRef bond, CFNumberRef mode)
{
SCNetworkInterfacePrivateRef interfacePrivate = (SCNetworkInterfacePrivateRef)bond;
Boolean needs_release = FALSE;
Boolean ok = TRUE;
assert(bond != NULL);
if (mode == NULL) {
int mode_num = IF_BOND_MODE_LACP;
mode = CFNumberCreate(NULL, kCFNumberIntType, &mode_num);
needs_release = TRUE;
}
// set mode in the stored preferences
if (interfacePrivate->prefs != NULL) {
CFDictionaryRef dict;
CFMutableDictionaryRef newDict;
CFStringRef path;
path = CFStringCreateWithFormat(NULL,
NULL,
CFSTR("/%@/%@/%@"),
kSCPrefVirtualNetworkInterfaces,
kSCNetworkInterfaceTypeBond,
interfacePrivate->entity_device);
dict = SCPreferencesPathGetValue(interfacePrivate->prefs, path);
if (!isA_CFDictionary(dict)) {
// if the prefs are confused
CFRelease(path);
_SCErrorSet(kSCStatusFailed);
ok = FALSE;
goto done;
}
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
CFDictionarySetValue(newDict, kSCPropVirtualNetworkInterfacesBondMode, mode);
if (!CFEqual(dict, newDict)) {
ok = SCPreferencesPathSetValue(interfacePrivate->prefs, path, newDict);
}
CFRelease(newDict);
CFRelease(path);
}
if (ok) {
CFRetain(mode);
if (interfacePrivate->bond.mode != NULL) {
CFRelease(interfacePrivate->bond.mode);
}
interfacePrivate->bond.mode = mode;
}
done :
if (needs_release) CFRelease(mode);
return ok;
}
__private_extern__
void
link_add(const char *if_name)
{
CFStringRef interface;
CFStringRef cacheKey;
CFDictionaryRef dict;
CFMutableDictionaryRef newDict = NULL;
CFArrayRef ifList;
CFMutableArrayRef newIFList = NULL;
interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
cacheKey = SCDynamicStoreKeyCreateNetworkInterface(NULL,
kSCDynamicStoreDomainState);
dict = cache_SCDynamicStoreCopyValue(store, cacheKey);
if (dict) {
if (isA_CFDictionary(dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
ifList = CFDictionaryGetValue(newDict, kSCPropNetInterfaces);
if (isA_CFArray(ifList)) {
newIFList = CFArrayCreateMutableCopy(NULL, 0, ifList);
}
}
CFRelease(dict);
}
if (!newDict) {
newDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
if (!newIFList) {
newIFList = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
}
if (CFArrayContainsValue(newIFList,
CFRangeMake(0, CFArrayGetCount(newIFList)),
interface) == FALSE) {
CFArrayAppendValue(newIFList, interface);
CFDictionarySetValue(newDict, kSCPropNetInterfaces, newIFList);
}
cache_SCDynamicStoreSetValue(store, cacheKey, newDict);
link_update_status(if_name, TRUE);
#ifdef KEV_DL_LINK_QUALITY_METRIC_CHANGED
link_update_quality_metric(if_name);
#endif /* KEV_DL_LINK_QUALITY_METRIC_CHANGED */
CFRelease(cacheKey);
CFRelease(interface);
if (newDict) CFRelease(newDict);
if (newIFList) CFRelease(newIFList);
return;
}
__private_extern__ Boolean
__setPrefsConfiguration(SCPreferencesRef prefs,
CFStringRef path,
CFDictionaryRef config,
Boolean keepInactive)
{
CFDictionaryRef curConfig;
CFMutableDictionaryRef newConfig = NULL;
Boolean ok;
if ((config != NULL) && !isA_CFDictionary(config)) {
_SCErrorSet(kSCStatusInvalidArgument);
return FALSE;
}
curConfig = SCPreferencesPathGetValue(prefs, path);
if (config != NULL) {
newConfig = CFDictionaryCreateMutableCopy(NULL, 0, config);
}
if (keepInactive) {
if (config == NULL) {
newConfig = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
if (isA_CFDictionary(curConfig) && CFDictionaryContainsKey(curConfig, kSCResvInactive)) {
// if currently disabled
CFDictionarySetValue(newConfig, kSCResvInactive, kCFBooleanTrue);
} else {
// if currently enabled
CFDictionaryRemoveValue(newConfig, kSCResvInactive);
}
}
// set new configuration
if (_SC_CFEqual(curConfig, newConfig)) {
// if no change
if (newConfig != NULL) CFRelease(newConfig);
ok = TRUE;
} else if (newConfig != NULL) {
// if new configuration (or we are preserving a disabled state)
ok = SCPreferencesPathSetValue(prefs, path, newConfig);
CFRelease(newConfig);
} else {
ok = SCPreferencesPathRemoveValue(prefs, path);
if (!ok && (SCError() == kSCStatusNoKey)) {
ok = TRUE;
}
}
return ok;
}
VALUE
rb_mod_init_copy(VALUE clone, SEL sel, VALUE orig)
{
rb_obj_init_copy(clone, 0, orig);
VALUE super;
if (!RCLASS_RUBY(orig)) {
super = orig;
rb_warn("cloning class `%s' is not supported, creating a " \
"subclass instead", rb_class2name(orig));
}
else {
super = RCLASS_SUPER(orig);
}
RCLASS_SET_SUPER(clone, super);
// Copy flags.
unsigned long version_flag = RCLASS_IS_RUBY_CLASS;
if ((RCLASS_VERSION(super) & RCLASS_IS_OBJECT_SUBCLASS)
== RCLASS_IS_OBJECT_SUBCLASS) {
version_flag |= RCLASS_IS_OBJECT_SUBCLASS;
}
if (RCLASS_MODULE(orig)) {
version_flag |= RCLASS_IS_MODULE;
}
RCLASS_SET_VERSION(clone, version_flag);
if (!class_isMetaClass((Class)clone)) {
// Clear type info.
RCLASS_SET_VERSION(*(Class *)clone, RCLASS_VERSION(*(Class *)clone));
}
// Copy methods.
rb_vm_copy_methods((Class)orig, (Class)clone);
if (!class_isMetaClass((Class)orig)) {
rb_vm_copy_methods(*(Class *)orig, *(Class *)clone);
}
// Copy ivars.
CFMutableDictionaryRef orig_dict = rb_class_ivar_dict(orig);
CFMutableDictionaryRef clone_dict;
if (orig_dict != NULL) {
clone_dict = CFDictionaryCreateMutableCopy(NULL, 0, orig_dict);
rb_class_ivar_set_dict(clone, clone_dict);
CFMakeCollectable(clone_dict);
}
else {
clone_dict = rb_class_ivar_dict_or_create(clone);
}
// Remove the classpath & classid (name) so that they are not
// copied over the new module / class.
CFDictionaryRemoveValue(clone_dict, (const void *)id_classpath);
CFDictionaryRemoveValue(clone_dict, (const void *)id_classid);
return clone;
}
__private_extern__
Boolean
__remove_password(SCPreferencesRef prefs,
CFDictionaryRef config,
CFStringRef passwordKey,
CFStringRef encryptionKey,
CFStringRef encryptionKeyChainValue,
CFStringRef unique_id,
CFDictionaryRef *newConfig)
{
CFStringRef encryption = NULL;
Boolean ok = FALSE;
// check for keychain password
if (config != NULL) {
encryption = CFDictionaryGetValue(config, encryptionKey);
}
if ((encryption == NULL) ||
(isA_CFString(encryption) &&
CFEqual(encryption, encryptionKeyChainValue))) {
// remove keychain password
if (prefs != NULL) {
ok = _SCPreferencesSystemKeychainPasswordItemRemove(prefs, unique_id);
} else {
ok = _SCSecKeychainPasswordItemRemove(NULL, unique_id);
}
}
// as needed, check if we have an in-line password that we can remove
if (!ok && (encryption == NULL) && (config != NULL)) {
CFDataRef inline_password;
inline_password = CFDictionaryGetValue(config, passwordKey);
inline_password = __copy_legacy_password(inline_password);
if (inline_password != NULL) {
CFRelease(inline_password);
ok = TRUE;
}
}
if (newConfig != NULL) {
if (ok && (config != NULL)) {
CFMutableDictionaryRef temp;
temp = CFDictionaryCreateMutableCopy(NULL, 0, config);
CFDictionaryRemoveValue(temp, passwordKey);
CFDictionaryRemoveValue(temp, encryptionKey);
*newConfig = (CFDictionaryRef)temp;
} else {
*newConfig = NULL;
}
}
return ok;
}
int SetHibernateMode(int mode, CFStringRef ps) {
CFNumberRef target_hm;
CFDictionaryRef tmp_settings = 0;
CFMutableDictionaryRef settings = 0;
CFDictionaryRef tmp_node = 0;
CFMutableDictionaryRef node = 0;
IOReturn ret;
int result = 0;
target_hm = CFNumberCreate(kCFAllocatorDefault, hm_type, &mode); /* Create a CFNumber with the mode value */
tmp_settings = IOPMCopyPMPreferences(); /* Get the power management preferences */
if(!tmp_settings) { /* On failure, quit */
CFRelease(tmp_settings);
CFRelease(target_hm);
return 1;
}
settings = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, tmp_settings); /* Copy the preferences to a mutable dictionary */
CFRelease(tmp_settings);
tmp_node = isA_CFDictionary(CFDictionaryGetValue(settings, ps)); /* Get the power source dictionary */
if(tmp_node) {
node = CFDictionaryCreateMutableCopy(0, 0, tmp_node); /* On success, copy it to a mutable dictionary */
if(node) {
CFDictionarySetValue(node, CFSTR("Hibernate Mode"), target_hm); /* Set the hibernate mode to its new value */
CFDictionarySetValue(settings, ps, node); /* link the new power source dictionary to the pm preferences*/
CFRelease(node);
}
}
if(kIOReturnSuccess != (ret = IOPMSetPMPreferences(settings))) { /* Set the new pm preferences */
if(ret == kIOReturnNotPrivileged) { /* On failure, quit */
printf("deepsleep must be run as root...\n");
} else {
printf("Error 0x%08x writing Energy Saver preferences to disk\n", ret);
}
result = 1;
}
CFRelease(settings); /* Cleanup */
CFRelease(target_hm);
return result;
}
static int TearOffSignatureAndHashManifest(CFDictionaryRef manifestDict, CFDataRef* signature, CFDataRef* manifest_data)
{
int result = -1;
CFMutableDictionaryRef new_manifest_dict = NULL;
CFStringRef sig_data_str = NULL;
CFDataRef sig_data = NULL;
CFDataRef prop_list = NULL;
CFDataRef decoded_sig_data = NULL;
if (NULL == manifestDict || NULL == signature || NULL == manifest_data)
{
return result;
}
*signature = NULL;
*manifest_data = NULL;
new_manifest_dict = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, CFDictionaryGetCount(manifestDict), manifestDict);
sig_data_str = (CFStringRef)CFDictionaryGetValue(new_manifest_dict, CFSTR("Signature"));
if (NULL == sig_data_str)
{
CFRelease(new_manifest_dict);
return result;
}
sig_data = CFStringCreateExternalRepresentation(kCFAllocatorDefault, sig_data_str, kCFStringEncodingUTF8, 0);
if (NULL == sig_data)
{
CFRelease(sig_data_str);
CFRelease(new_manifest_dict);
return result;
}
if (Base64Data(sig_data, 0, &decoded_sig_data))
{
CFRelease(sig_data);
CFRelease(new_manifest_dict);
return result;
}
*signature = decoded_sig_data;
CFDictionaryRemoveValue(new_manifest_dict, CFSTR("Signature"));
prop_list = CFPropertyListCreateXMLData (kCFAllocatorDefault, new_manifest_dict);
CFRelease(new_manifest_dict);
if (NULL == prop_list)
{
return result;
}
(void)CreateHashForData(prop_list, 1, manifest_data);
result = (NULL == *manifest_data) ? -1 : 0;
return result;
}
Boolean
SCNetworkSetSetServiceOrder(SCNetworkSetRef set, CFArrayRef newOrder)
{
CFDictionaryRef dict;
CFMutableDictionaryRef newDict;
Boolean ok;
CFStringRef path;
SCNetworkSetPrivateRef setPrivate = (SCNetworkSetPrivateRef)set;
if (!isA_SCNetworkSet(set)) {
_SCErrorSet(kSCStatusInvalidArgument);
return FALSE;
}
if (isA_CFArray(newOrder)) {
CFIndex i;
CFIndex n = CFArrayGetCount(newOrder);
for (i = 0; i < n; i++) {
CFStringRef serviceID;
serviceID = CFArrayGetValueAtIndex(newOrder, i);
if (!isA_CFString(serviceID)) {
_SCErrorSet(kSCStatusInvalidArgument);
return FALSE;
}
}
} else {
_SCErrorSet(kSCStatusInvalidArgument);
return FALSE;
}
path = SCPreferencesPathKeyCreateSetNetworkGlobalEntity(NULL, setPrivate->setID, kSCEntNetIPv4);
if (path == NULL) {
return FALSE;
}
dict = SCPreferencesPathGetValue(setPrivate->prefs, path);
if (dict != NULL) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
} else {
newDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(newDict, kSCPropNetServiceOrder, newOrder);
ok = SCPreferencesPathSetValue(setPrivate->prefs, path, newDict);
CFRelease(newDict);
CFRelease(path);
return ok;
}
/* Create a mutable dictionary that is based on the subdictionary for key
with any attributes from the top level dict merged in. */
static CFMutableDictionaryRef merge_params(CFDictionaryRef dict,
CFStringRef key) {
CFDictionaryRef subdict = CFDictionaryGetValue(dict, key);
CFMutableDictionaryRef result;
if (subdict) {
result = CFDictionaryCreateMutableCopy(NULL, 0, subdict);
/* Add everything in dict not already in result to result. */
CFDictionaryApplyFunction(dict, merge_params_applier, result);
} else {
result = CFDictionaryCreateMutableCopy(NULL, 0, dict);
}
/* Remove values that only belong in the top level dict. */
CFDictionaryRemoveValue(result, kSecPublicKeyAttrs);
CFDictionaryRemoveValue(result, kSecPrivateKeyAttrs);
CFDictionaryRemoveValue(result, kSecAttrKeyType);
CFDictionaryRemoveValue(result, kSecAttrKeySizeInBits);
return result;
}
__private_extern__
void
link_remove(const char *if_name)
{
CFStringRef interface;
CFStringRef cacheKey;
CFDictionaryRef dict;
CFMutableDictionaryRef newDict = NULL;
CFArrayRef ifList;
CFMutableArrayRef newIFList = NULL;
CFIndex i;
interface = CFStringCreateWithCString(NULL, if_name, kCFStringEncodingMacRoman);
cacheKey = SCDynamicStoreKeyCreateNetworkInterface(NULL,
kSCDynamicStoreDomainState);
dict = cache_SCDynamicStoreCopyValue(store, cacheKey);
if (dict) {
if (isA_CFDictionary(dict)) {
newDict = CFDictionaryCreateMutableCopy(NULL, 0, dict);
ifList = CFDictionaryGetValue(newDict, kSCPropNetInterfaces);
if (isA_CFArray(ifList)) {
newIFList = CFArrayCreateMutableCopy(NULL, 0, ifList);
}
}
CFRelease(dict);
}
if (!newIFList ||
((i = CFArrayGetFirstIndexOfValue(newIFList,
CFRangeMake(0, CFArrayGetCount(newIFList)),
interface)) == kCFNotFound)
) {
/* we're not tracking this interface */
goto done;
}
CFArrayRemoveValueAtIndex(newIFList, i);
CFDictionarySetValue(newDict, kSCPropNetInterfaces, newIFList);
cache_SCDynamicStoreSetValue(store, cacheKey, newDict);
interface_remove(if_name);
done:
CFRelease(cacheKey);
CFRelease(interface);
if (newDict) CFRelease(newDict);
if (newIFList) CFRelease(newIFList);
return;
}
/* :nodoc: */
VALUE
rb_mod_init_copy(VALUE clone, SEL sel, VALUE orig)
{
static ID classpath = 0;
static ID classid = 0;
rb_obj_init_copy(clone, 0, orig);
{
VALUE super;
unsigned long version_flag;
if (!RCLASS_RUBY(orig)) {
super = orig;
rb_warn("cloning class `%s' is not supported, creating a " \
"subclass instead", rb_class2name(orig));
}
else {
super = RCLASS_SUPER(orig);
}
RCLASS_SET_SUPER(clone, super);
version_flag = RCLASS_IS_RUBY_CLASS;
if ((RCLASS_VERSION(super) & RCLASS_IS_OBJECT_SUBCLASS) == RCLASS_IS_OBJECT_SUBCLASS) {
version_flag |= RCLASS_IS_OBJECT_SUBCLASS;
}
RCLASS_SET_VERSION(clone, version_flag);
rb_vm_copy_methods((Class)orig, (Class)clone);
CFMutableDictionaryRef ivar_dict = rb_class_ivar_dict(orig);
if (ivar_dict != NULL) {
CFMutableDictionaryRef cloned_ivar_dict;
if (classpath == 0) {
classpath = rb_intern("__classpath__");
}
if (classid == 0) {
classid = rb_intern("__classid__");
}
cloned_ivar_dict = CFDictionaryCreateMutableCopy(NULL, 0,
(CFDictionaryRef)ivar_dict);
// Remove the classpath & classid (name) so that they are not
// copied over the new module / class
CFDictionaryRemoveValue(cloned_ivar_dict, (const void *)classpath);
CFDictionaryRemoveValue(cloned_ivar_dict, (const void *)classid);
CFMakeCollectable(cloned_ivar_dict);
rb_class_ivar_set_dict(clone, cloned_ivar_dict);
}
}
return clone;
}
static void __DAFileSystemProbeListAppendValue( const void * key, const void * value, void * context )
{
CFMutableDictionaryRef probe;
probe = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, value );
if ( probe )
{
CFDictionarySetValue( probe, kDAFileSystemKey, context );
CFArrayAppendValue( gDAFileSystemProbeList, probe );
CFRelease( probe );
}
}
__private_extern__ Boolean
__setPrefsEnabled(SCPreferencesRef prefs,
CFStringRef path,
Boolean enabled)
{
CFDictionaryRef curConfig;
CFMutableDictionaryRef newConfig = NULL;
Boolean ok = FALSE;
// preserve current configuration
curConfig = SCPreferencesPathGetValue(prefs, path);
if (curConfig != NULL) {
if (!isA_CFDictionary(curConfig)) {
_SCErrorSet(kSCStatusFailed);
return FALSE;
}
newConfig = CFDictionaryCreateMutableCopy(NULL, 0, curConfig);
if (enabled) {
// enable
CFDictionaryRemoveValue(newConfig, kSCResvInactive);
} else {
// disable
CFDictionarySetValue(newConfig, kSCResvInactive, kCFBooleanTrue);
}
} else {
if (!enabled) {
// disable
newConfig = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(newConfig, kSCResvInactive, kCFBooleanTrue);
}
}
// set new configuration
if (_SC_CFEqual(curConfig, newConfig)) {
// if no change
if (newConfig != NULL) CFRelease(newConfig);
ok = TRUE;
} else if (newConfig != NULL) {
// if updated configuration (or we are establishing as disabled)
ok = SCPreferencesPathSetValue(prefs, path, newConfig);
CFRelease(newConfig);
} else {
ok = SCPreferencesPathRemoveValue(prefs, path);
if (!ok && (SCError() == kSCStatusNoKey)) {
ok = TRUE;
}
}
return ok;
}
/* Erase the media in the currently opened device */
int PortBurn_StartErasing(void *handle, int type)
{
CFMutableDictionaryRef props;
PBHandle *h = (PBHandle *)handle;
if (h == NULL) {
return pbErrNoHandle;
}
if (h->device == NULL) {
return pbErrDeviceNotOpen;
}
if (h->burn != NULL || h->erase != NULL) {
return pbErrCannotStartErasing;
}
h->erase = DREraseCreate(h->device);
if (h->erase == NULL) {
return pbErrCannotPrepareToErase;
}
props = CFDictionaryCreateMutableCopy(NULL, 0, DREraseGetProperties(h->erase));
if (props == NULL) {
CFRelease(h->erase);
h->erase = NULL;
return pbErrCannotPrepareToErase;
}
CFDictionaryAddValue(props,
kDREraseTypeKey,
type ? kDREraseTypeComplete : kDREraseTypeQuick);
DREraseSetProperties(h->erase, props);
CFRelease(props);
h->frac = 0.0;
h->err = DREraseStart(h->erase);
if (h->err != noErr) {
CFRelease(h->erase);
h->erase = NULL;
return pbErrCannotStartErasing;
}
return pbSuccess;
}
/*
* Copy Events from on-disk file. We should be doing this only
* once, at start of the powerd.
*/
static void
copyScheduledRepeatPowerEvents(void)
{
SCPreferencesRef prefs;
CFDictionaryRef tmp;
prefs = SCPreferencesCreate(0,
CFSTR("PM-configd-AutoWake"),
CFSTR(kIOPMAutoWakePrefsPath));
if(!prefs) return;
if (repeatingPowerOff) CFRelease(repeatingPowerOff);
if (repeatingPowerOn) CFRelease(repeatingPowerOn);
tmp = (CFDictionaryRef)SCPreferencesGetValue(prefs, CFSTR(kIOPMRepeatingPowerOffKey));
if (tmp && isA_CFDictionary(tmp))
repeatingPowerOff = CFDictionaryCreateMutableCopy(0,0,tmp);
tmp = (CFDictionaryRef)SCPreferencesGetValue(prefs, CFSTR(kIOPMRepeatingPowerOnKey));
if (tmp && isA_CFDictionary(tmp))
repeatingPowerOn = CFDictionaryCreateMutableCopy(0,0,tmp);
CFRelease(prefs);
}
bool SOSItemUpdateOrAdd(CFStringRef service, CFStringRef accessibility, CFDataRef data, CFErrorRef *error)
{
CFDictionaryRef query = SOSItemCopyQueryForSyncItems(service, false);
CFDictionaryRef update = CFDictionaryCreateForCFTypes(kCFAllocatorDefault,
kSecValueData, data,
kSecAttrAccessible, accessibility,
NULL);
OSStatus saveStatus = SecItemUpdate(query, update);
if (errSecItemNotFound == saveStatus) {
CFMutableDictionaryRef add = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, query);
CFDictionaryForEach(update, ^(const void *key, const void *value) {
CFDictionaryAddValue(add, key, value);
});
static CFStringRef createLocaleIDFromLocaleAndCalendar(CFLocaleRef locale, CFCalendarRef calendar) {
CFMutableDictionaryRef dict;
{
CFDictionaryRef immutableDict = CFLocaleCreateComponentsFromLocaleIdentifier(kCFAllocatorSystemDefault, CFLocaleGetIdentifier(locale));
dict = CFDictionaryCreateMutableCopy(kCFAllocatorSystemDefault, 0, immutableDict);
CFRelease(immutableDict);
}
if (calendar) {
CFDictionarySetValue(dict, kCFLocaleCalendar, calendar);
}
CFStringRef localeID = CFLocaleCreateLocaleIdentifierFromComponents(kCFAllocatorSystemDefault, dict);
CFRelease(dict);
return localeID;
}
/* Set the active power profile */
int SetActiveProfile(int nb, CFStringRef ps, CFDictionaryRef profile) {
CFNumberRef target_nb;
CFMutableDictionaryRef custom_profile;
IOReturn ret;
int result = 0;
target_nb = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &nb); /* Create a CFNumber with the active profile value */
custom_profile = CFDictionaryCreateMutableCopy(0, 0, profile); /* Copy the preferences to a mutable dictionary */
CFDictionarySetValue(custom_profile, ps, target_nb); /* Set the active profile to its new value */
if(kIOReturnSuccess != (ret = IOPMSetActivePowerProfiles(custom_profile))) { /* Set the new profile */
printf("Error 0x%08x writing Energy Saver preferences to disk\n", ret); /* On failure, quit */
result = 1;
}
CFRelease(custom_profile);
CFRelease(target_nb);
return result;
}
static void writeFontDatabaseToPlist(CFPropertyListRef cgFontDBPropertyList, CFPropertyListRef filenamesFromRegistry)
{
if (!cgFontDBPropertyList)
return;
RetainPtr<CFDataRef> data;
if (!filenamesFromRegistry || CFGetTypeID(cgFontDBPropertyList) != CFDictionaryGetTypeID())
data.adoptCF(CFPropertyListCreateXMLData(kCFAllocatorDefault, cgFontDBPropertyList));
else {
RetainPtr<CFMutableDictionaryRef> dictionary(AdoptCF, CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 2, static_cast<CFDictionaryRef>(cgFontDBPropertyList)));
CFDictionarySetValue(dictionary.get(), fontFilenamesFromRegistryKey(), filenamesFromRegistry);
data.adoptCF(CFPropertyListCreateXMLData(kCFAllocatorDefault, dictionary.get()));
}
if (!data)
return;
safeCreateFile(fontsPlistPath(), data.get());
}
static CFDictionaryRef createConnectionProperties(bool shouldUseCredentialStorage, CFDictionaryRef clientProperties)
{
static const CFStringRef webKitPrivateSessionCF = CFSTR("WebKitPrivateSession");
static const CFStringRef _kCFURLConnectionSessionID = CFSTR("_kCFURLConnectionSessionID");
static const CFStringRef kCFURLConnectionSocketStreamProperties = CFSTR("kCFURLConnectionSocketStreamProperties");
CFDictionaryRef sessionID = shouldUseCredentialStorage ?
CFDictionaryCreate(0, 0, 0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks) :
CFDictionaryCreate(0, (const void**)&_kCFURLConnectionSessionID, (const void**)&webKitPrivateSessionCF, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFMutableDictionaryRef propertiesDictionary;
if (clientProperties)
propertiesDictionary = CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, clientProperties);
else
propertiesDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionaryAddValue(propertiesDictionary, (const void*)kCFURLConnectionSocketStreamProperties, (const void*)sessionID);
CFRelease(sessionID);
return propertiesDictionary;
}
static void convertWebResourceResponseToDictionary(CFMutableDictionaryRef propertyList)
{
CFDataRef responseData = static_cast<CFDataRef>(CFDictionaryGetValue(propertyList, CFSTR("WebResourceResponse"))); // WebResourceResponseKey in WebResource.m
if (CFGetTypeID(responseData) != CFDataGetTypeID())
return;
RetainPtr<CFURLResponseRef> response = adoptCF(createCFURLResponseFromResponseData(responseData));
if (!response)
return;
RetainPtr<CFMutableDictionaryRef> responseDictionary = adoptCF(CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
RetainPtr<CFMutableStringRef> urlString = adoptCF(CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFURLGetString(CFURLResponseGetURL(response.get()))));
normalizeWebResourceURL(urlString.get());
CFDictionarySetValue(responseDictionary.get(), CFSTR("URL"), urlString.get());
RetainPtr<CFMutableStringRef> mimeTypeString = adoptCF(CFStringCreateMutableCopy(kCFAllocatorDefault, 0, CFURLResponseGetMIMEType(response.get())));
convertMIMEType(mimeTypeString.get());
CFDictionarySetValue(responseDictionary.get(), CFSTR("MIMEType"), mimeTypeString.get());
CFStringRef textEncodingName = CFURLResponseGetTextEncodingName(response.get());
if (textEncodingName)
CFDictionarySetValue(responseDictionary.get(), CFSTR("textEncodingName"), textEncodingName);
SInt64 expectedContentLength = CFURLResponseGetExpectedContentLength(response.get());
RetainPtr<CFNumberRef> expectedContentLengthNumber = adoptCF(CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &expectedContentLength));
CFDictionarySetValue(responseDictionary.get(), CFSTR("expectedContentLength"), expectedContentLengthNumber.get());
if (CFHTTPMessageRef httpMessage = CFURLResponseGetHTTPResponse(response.get())) {
RetainPtr<CFDictionaryRef> allHeaders = adoptCF(CFHTTPMessageCopyAllHeaderFields(httpMessage));
RetainPtr<CFMutableDictionaryRef> allHeaderFields = adoptCF(CFDictionaryCreateMutableCopy(kCFAllocatorDefault, 0, allHeaders.get()));
normalizeHTTPResponseHeaderFields(allHeaderFields.get());
CFDictionarySetValue(responseDictionary.get(), CFSTR("allHeaderFields"), allHeaderFields.get());
CFIndex statusCode = CFHTTPMessageGetResponseStatusCode(httpMessage);
RetainPtr<CFNumberRef> statusCodeNumber = adoptCF(CFNumberCreate(kCFAllocatorDefault, kCFNumberCFIndexType, &statusCode));
CFDictionarySetValue(responseDictionary.get(), CFSTR("statusCode"), statusCodeNumber.get());
}
CFDictionarySetValue(propertyList, CFSTR("WebResourceResponse"), responseDictionary.get());
}