static void
interface_update_status(const char *if_name, CFBooleanRef active,
boolean_t attach)
{
CFStringRef key = NULL;
CFMutableDictionaryRef newDict = NULL;
key = create_interface_key(if_name);
newDict = copy_entity(key);
/* if new status available, update cache */
if (active == NULL) {
CFDictionaryRemoveValue(newDict, kSCPropNetLinkActive);
} else {
CFDictionarySetValue(newDict, kSCPropNetLinkActive, active);
}
if (attach == TRUE) {
/* the interface was attached, remove stale state */
CFDictionaryRemoveValue(newDict, kSCPropNetLinkDetaching);
}
/* update status */
if (CFDictionaryGetCount(newDict) > 0) {
cache_SCDynamicStoreSetValue(store, key, newDict);
} else {
cache_SCDynamicStoreRemoveValue(store, key);
}
CFRelease(key);
CFRelease(newDict);
return;
}
static VALUE
find_class_path(VALUE klass)
{
struct fc_result arg;
arg.name = 0;
arg.path = 0;
arg.klass = klass;
arg.track = rb_cObject;
arg.prev = 0;
CFMutableDictionaryRef iv_dict = rb_class_ivar_dict(rb_cObject);
if (iv_dict != NULL) {
ivar_dict_foreach(iv_dict, fc_i, (VALUE)&arg);
}
if (arg.path == 0) {
st_foreach_safe(rb_class_tbl, fc_i, (st_data_t)&arg);
}
if (arg.path) {
iv_dict = rb_class_ivar_dict_or_create(klass);
CFDictionarySetValue(iv_dict, (const void *)id_classpath,
(const void *)arg.path);
CFDictionaryRemoveValue(iv_dict, (const void *)id_tmp_classpath);
return arg.path;
}
if (!RCLASS_RUBY(klass)) {
VALUE name = rb_str_new2(class_getName((Class)klass));
iv_dict = rb_class_ivar_dict_or_create(klass);
CFDictionarySetValue(iv_dict, (const void *)id_classpath,
(const void *)name);
CFDictionaryRemoveValue(iv_dict, (const void *)id_tmp_classpath);
return name;
}
return Qnil;
}
__private_extern__ void _CFBundlePlugInLoaded(CFBundleRef bundle) {
CFDictionaryRef infoDict = CFBundleGetInfoDictionary(bundle);
CFStringRef tempStr;
CFPlugInDynamicRegisterFunction func = NULL;
if (!__CFBundleGetPlugInData(bundle)->_isPlugIn || __CFBundleGetPlugInData(bundle)->_isDoingDynamicRegistration || !infoDict || !CFBundleIsExecutableLoaded(bundle)) return;
tempStr = (CFStringRef)CFDictionaryGetValue(infoDict, CFSTR("CFPlugInNeedsDynamicRegistration"));
if (tempStr && CFGetTypeID(tempStr) == CFStringGetTypeID() && CFStringCompare(tempStr, CFSTR("YES"), kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
CFDictionaryRemoveValue((CFMutableDictionaryRef)infoDict, CFSTR("CFPlugInNeedsDynamicRegistration"));
tempStr = (CFStringRef)CFDictionaryGetValue(infoDict, kCFPlugInDynamicRegisterFunctionKey);
if (!tempStr || CFGetTypeID(tempStr) != CFStringGetTypeID() || CFStringGetLength(tempStr) <= 0) tempStr = CFSTR("CFPlugInDynamicRegister");
__CFBundleGetPlugInData(bundle)->_loadOnDemand = false;
__CFBundleGetPlugInData(bundle)->_isDoingDynamicRegistration = true;
/* Find the symbol and call it. */
func = (CFPlugInDynamicRegisterFunction)CFBundleGetFunctionPointerForName(bundle, tempStr);
if (func) {
func(bundle);
// MF:!!! Unload function is never called. Need to deal with this!
}
__CFBundleGetPlugInData(bundle)->_isDoingDynamicRegistration = false;
if (__CFBundleGetPlugInData(bundle)->_loadOnDemand && __CFBundleGetPlugInData(bundle)->_instanceCount == 0) CFBundleUnloadExecutable(bundle); // Unload now if we can/should.
} else {
CFDictionaryRemoveValue((CFMutableDictionaryRef)infoDict, CFSTR("CFPlugInNeedsDynamicRegistration"));
}
}
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;
}
void SFB::Audio::Metadata::SetValue(CFStringRef key, CFTypeRef value)
{
if(nullptr == key)
return;
if(nullptr == value) {
if(CFDictionaryContainsKey(mMetadata, key))
CFDictionarySetValue(mChangedMetadata, key, kCFNull);
else
CFDictionaryRemoveValue(mChangedMetadata, key);
}
else {
CFTypeRef savedValue = CFDictionaryGetValue(mMetadata, key);
// Revert the change if the new value is the save as the saved value
if(CFDictionaryContainsKey(mChangedMetadata, key)) {
if(savedValue && CFEqual(savedValue, value))
CFDictionaryRemoveValue(mChangedMetadata, key);
else
CFDictionarySetValue(mChangedMetadata, key, value);
}
// If a saved value exists only register the change if the new value is different
else if(savedValue && !CFEqual(savedValue, value))
CFDictionarySetValue(mChangedMetadata, key, value);
// If no saved value exists for the key register the change
else if(nullptr == savedValue)
CFDictionarySetValue(mChangedMetadata, key, value);
}
}
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;
}
/* :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;
}
/*
* Function: EAPOLClientProfileSetInformation
*
* Purpose:
* Associate additional information with the profile using the given
* application identifier.
*
* If info is NULL, the information for the particular application is cleared.
*
* Note:
* applicationID must be an application identifier e.g. "com.mycompany.myapp".
*/
Boolean
EAPOLClientProfileSetInformation(EAPOLClientProfileRef profile,
CFStringRef applicationID,
CFDictionaryRef information)
{
if (applicationID_is_valid(applicationID) == FALSE) {
return (FALSE);
}
if (information == NULL) {
if (profile->information != NULL) {
CFDictionaryRemoveValue(profile->information, applicationID);
}
}
else {
if (isA_CFDictionary(information) == NULL) {
return (FALSE);
}
if (profile->information == NULL) {
profile->information
= CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
}
CFDictionarySetValue(profile->information, applicationID, information);
}
return (TRUE);
}
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;
}
void SFB::Audio::Metadata::MergeChangedMetadataIntoMetadata()
{
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(mMetadata, keys[i]);
else
CFDictionarySetValue(mMetadata, keys[i], values[i]);
}
free(keys), keys = nullptr;
free(values), values = nullptr;
CFDictionaryRemoveAllValues(mChangedMetadata);
auto iter = std::begin(mPictures);
while(iter != std::end(mPictures)) {
auto picture = *iter;
if(AttachedPicture::ChangeState::Removed == picture->mState)
iter = mPictures.erase(iter);
else {
picture->MergeChangedMetadataIntoMetadata();
picture->mState = AttachedPicture::ChangeState::Saved;
++iter;
}
}
}
void
rb_gc_copy_finalizer(VALUE dest, VALUE obj)
{
VALUE table;
if (__os_finalizers == NULL)
return;
if (NATIVE(obj)) {
if (!rb_objc_flag_check((void *)obj, FL_FINALIZE))
return;
}
else {
if (!FL_TEST(obj, FL_FINALIZE))
return;
}
table = (VALUE)CFDictionaryGetValue((CFDictionaryRef)__os_finalizers,
(const void *)obj);
if (table == 0) {
CFDictionaryRemoveValue(__os_finalizers, (const void *)dest);
}
else {
CFDictionarySetValue(__os_finalizers, (const void *)dest,
(const void *)table);
}
}
__private_extern__
void
interface_update_quality_metric(const char *if_name,
int quality)
{
CFStringRef key = NULL;
CFMutableDictionaryRef newDict = NULL;
CFNumberRef linkquality = NULL;
key = create_linkquality_key(if_name);
newDict = copy_entity(key);
if (quality != IFNET_LQM_THRESH_UNKNOWN) {
linkquality = CFNumberCreate(NULL, kCFNumberIntType, &quality);
CFDictionarySetValue(newDict, kSCPropNetLinkQuality, linkquality);
CFRelease(linkquality);
} else {
CFDictionaryRemoveValue(newDict, kSCPropNetLinkQuality);
}
/* update status */
if (CFDictionaryGetCount(newDict) > 0) {
cache_SCDynamicStoreSetValue(store, key, newDict);
} else {
cache_SCDynamicStoreRemoveValue(store, key);
}
CFRelease(key);
CFRelease(newDict);
return;
}
STATIC void
remove_old_linklocal_modifiers(CFMutableDictionaryRef modifiers)
{
CFIndex count;
count = CFDictionaryGetCount(modifiers);
if (count > 0) {
int i;
const void * keys[count];
CFDateRef now;
const void * values[count];
now = CFDateCreate(NULL, CFAbsoluteTimeGetCurrent());
CFDictionaryGetKeysAndValues(modifiers, keys, values);
for (i = 0; i < count; i++) {
CFDictionaryRef dict = (CFDictionaryRef)values[i];
if (linklocal_modifier_has_expired(dict, now)) {
CFStringRef key = (CFStringRef)keys[i];
CFDictionaryRemoveValue(modifiers, key);
}
}
CFRelease(now);
}
return;
}
static VALUE
classname(VALUE klass)
{
VALUE path = Qnil;
if (klass == 0) {
klass = rb_cObject;
}
CFMutableDictionaryRef iv_dict = rb_class_ivar_dict(klass);
if (iv_dict != NULL) {
if (!CFDictionaryGetValueIfPresent((CFDictionaryRef)iv_dict,
(const void *)id_classpath, (const void **)&path)) {
if (!CFDictionaryGetValueIfPresent((CFDictionaryRef)iv_dict,
(const void *)id_classid, (const void **)&path)) {
return find_class_path(klass);
}
path = rb_str_dup(path);
OBJ_FREEZE(path);
CFDictionarySetValue(iv_dict, (const void *)id_classpath,
(const void *)path);
CFDictionaryRemoveValue(iv_dict, (const void *)id_classid);
}
if (TYPE(path) != T_STRING) {
rb_bug("class path is not set properly");
}
return path;
}
return find_class_path(klass);
}
void CFMessagePortInvalidate(CFMessagePortRef ms) {
__CFGenericValidateType(ms, __kCFMessagePortTypeID);
if (!__CFMessagePortIsDeallocing(ms)) {
CFRetain(ms);
}
__CFMessagePortLock(ms);
if (__CFMessagePortIsValid(ms)) {
CFMessagePortInvalidationCallBack callout = ms->_icallout;
CFRunLoopSourceRef source = ms->_source;
CFMachPortRef replyPort = ms->_replyPort;
CFMachPortRef port = ms->_port;
CFStringRef name = ms->_name;
void *info = NULL;
__CFMessagePortUnsetValid(ms);
if (!__CFMessagePortIsRemote(ms)) {
info = ms->_context.info;
ms->_context.info = NULL;
}
ms->_source = NULL;
ms->_replyPort = NULL;
__CFMessagePortUnlock(ms);
__CFSpinLock(&__CFAllMessagePortsLock);
if (NULL != (__CFMessagePortIsRemote(ms) ? __CFAllRemoteMessagePorts : __CFAllLocalMessagePorts)) {
CFDictionaryRemoveValue(__CFMessagePortIsRemote(ms) ? __CFAllRemoteMessagePorts : __CFAllLocalMessagePorts, name);
}
__CFSpinUnlock(&__CFAllMessagePortsLock);
if (NULL != callout) {
callout(ms, info);
}
// We already know we're going invalid, don't need this callback
// anymore; plus, this solves a reentrancy deadlock; also, this
// must be done before the deallocate of the Mach port, to
// avoid a race between the notification message which could be
// handled in another thread, and this NULL'ing out.
CFMachPortSetInvalidationCallBack(port, NULL);
// For hashing and equality purposes, cannot get rid of _port here
if (!__CFMessagePortIsRemote(ms) && NULL != ms->_context.release) {
ms->_context.release(info);
}
if (NULL != source) {
CFRunLoopSourceInvalidate(source);
CFRelease(source);
}
if (NULL != replyPort) {
CFMachPortInvalidate(replyPort);
CFRelease(replyPort);
}
if (__CFMessagePortIsRemote(ms)) {
// Get rid of our extra ref on the Mach port gotten from bs server
mach_port_deallocate(mach_task_self(), CFMachPortGetPort(port));
}
} else {
__CFMessagePortUnlock(ms);
}
if (!__CFMessagePortIsDeallocing(ms)) {
CFRelease(ms);
}
}
__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 void
CFSocketFinalize (CFTypeRef cf)
{
CFSocketRef s = (CFSocketRef)cf;
#if HAVE_LIBDISPATCH
dispatch_queue_t q = dispatch_get_global_queue(
DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_source_cancel(s->_readSource);
dispatch_source_cancel(s->_writeSource);
// Wait for source handlers to complete
// before we proceed to destruction.
dispatch_barrier_sync_f(q, NULL, DummyBarrier);
if (s->_source != NULL)
CFRelease(s->_source);
#endif
if (s->_socket != -1)
{
GSMutexLock (&_kCFSocketObjectsLock);
CFDictionaryRemoveValue(_kCFSocketObjects,
(void*)(uintptr_t) s->_socket);
closesocket (s->_socket);
GSMutexUnlock (&_kCFSocketObjectsLock);
}
if (s->_address)
CFRelease (s->_address);
if (s->_peerAddress)
CFRelease (s->_peerAddress);
}
//
// Given a bag of attribute values, automagically come up with a SecCode
// without any other information.
// This is meant to be the "just do what makes sense" generic call, for callers
// who don't want to engage in the fascinating dance of manual guest enumeration.
//
// Note that we expect the logic embedded here to change over time (in backward
// compatible fashion, one hopes), and that it's all right to use heuristics here
// as long as it's done sensibly.
//
// Be warned that the present logic is quite a bit ad-hoc, and will likely not
// handle arbitrary combinations of proxy hosting, dynamic hosting, and dedicated
// hosting all that well.
//
SecCode *SecCode::autoLocateGuest(CFDictionaryRef attributes, SecCSFlags flags)
{
// special case: with no attributes at all, return the root of trust
if (CFDictionaryGetCount(attributes) == 0)
return KernelCode::active()->retain();
// main logic: we need a pid, and we'll take a canonical guest id as an option
int pid = 0;
if (!cfscan(attributes, "{%O=%d}", kSecGuestAttributePid, &pid))
CSError::throwMe(errSecCSUnsupportedGuestAttributes, kSecCFErrorGuestAttributes, attributes);
if (SecCode *process =
KernelCode::active()->locateGuest(attributes)) {
SecPointer<SecCode> code;
code.take(process); // locateGuest gave us a retained object
if (code->staticCode()->flag(kSecCodeSignatureHost)) {
// might be a code host. Let's find out
CFRef<CFMutableDictionaryRef> rest = makeCFMutableDictionary(attributes);
CFDictionaryRemoveValue(rest, kSecGuestAttributePid);
if (SecCode *guest = code->locateGuest(rest))
return guest;
}
if (!CFDictionaryGetValue(attributes, kSecGuestAttributeCanonical)) {
// only "soft" attributes, and no hosting is happening. Return the (non-)host itself
return code.yield();
}
}
MacOSError::throwMe(errSecCSNoSuchCode);
}
static VTStatus
gst_vtenc_enqueue_buffer (void *data, int a2, int a3, int a4,
CMSampleBufferRef sbuf, int a6, int a7)
{
GstVTEnc *self = data;
gboolean is_keyframe;
GstBuffer *buf;
/* This may happen if we don't have enough bitrate */
if (sbuf == NULL)
goto beach;
is_keyframe = gst_vtenc_buffer_is_keyframe (self, sbuf);
if (self->expect_keyframe) {
if (!is_keyframe)
goto beach;
CFDictionaryRemoveValue (self->options,
*(self->ctx->vt->kVTEncodeFrameOptionKey_ForceKeyFrame));
}
self->expect_keyframe = FALSE;
buf = gst_core_media_buffer_new (self->ctx, sbuf);
gst_buffer_copy_metadata (buf, self->cur_inbuf, GST_BUFFER_COPY_TIMESTAMPS);
if (is_keyframe) {
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
} else {
GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
}
g_ptr_array_add (self->cur_outbufs, buf);
beach:
return kVTSuccess;
}
static void normalizeHTTPResponseHeaderFields(CFMutableDictionaryRef fields)
{
// Normalize headers
if (CFDictionaryContainsKey(fields, CFSTR("Date")))
CFDictionarySetValue(fields, CFSTR("Date"), CFSTR("Sun, 16 Nov 2008 17:00:00 GMT"));
if (CFDictionaryContainsKey(fields, CFSTR("Last-Modified")))
CFDictionarySetValue(fields, CFSTR("Last-Modified"), CFSTR("Sun, 16 Nov 2008 16:55:00 GMT"));
if (CFDictionaryContainsKey(fields, CFSTR("Etag")))
CFDictionarySetValue(fields, CFSTR("Etag"), CFSTR("\"301925-21-45c7d72d3e780\""));
if (CFDictionaryContainsKey(fields, CFSTR("Server")))
CFDictionarySetValue(fields, CFSTR("Server"), CFSTR("Apache/2.2.9 (Unix) mod_ssl/2.2.9 OpenSSL/0.9.7l PHP/5.2.6"));
// Remove headers
CFDictionaryRemoveValue(fields, CFSTR("Connection"));
CFDictionaryRemoveValue(fields, CFSTR("Keep-Alive"));
}
static CFDictionaryRef _CFUserNotificationModifiedDictionary(CFAllocatorRef allocator, CFDictionaryRef dictionary, SInt32 token, SInt32 timeout, CFStringRef source) {
CFMutableDictionaryRef md = CFDictionaryCreateMutable(allocator, 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFNumberRef tokenNumber = CFNumberCreate(allocator, kCFNumberSInt32Type, &token);
CFNumberRef timeoutNumber = CFNumberCreate(allocator, kCFNumberSInt32Type, &timeout);
CFURLRef url = NULL;
CFStringRef path = NULL;
if (dictionary) CFDictionaryApplyFunction(dictionary, _CFUserNotificationAddToDictionary, md);
if (source) CFDictionaryAddValue(md, kCFUserNotificationAlertSourceKey, source);
if (tokenNumber) {
CFDictionaryAddValue(md, kCFUserNotificationTokenKey, tokenNumber);
CFRelease(tokenNumber);
}
if (timeoutNumber) {
CFDictionaryAddValue(md, kCFUserNotificationTimeoutKey, timeoutNumber);
CFRelease(timeoutNumber);
}
url = CFDictionaryGetValue(md, kCFUserNotificationIconURLKey);
if (url && CFGetTypeID((CFTypeRef)url) == CFURLGetTypeID()) {
url = CFURLCopyAbsoluteURL(url);
CFDictionaryRemoveValue(md, kCFUserNotificationIconURLKey);
path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
CFDictionaryAddValue(md, kCFUserNotificationIconPathKey, path);
CFRelease(url);
CFRelease(path);
}
url = CFDictionaryGetValue(md, kCFUserNotificationSoundURLKey);
if (url && CFGetTypeID((CFTypeRef)url) == CFURLGetTypeID()) {
url = CFURLCopyAbsoluteURL(url);
CFDictionaryRemoveValue(md, kCFUserNotificationSoundURLKey);
path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
CFDictionaryAddValue(md, kCFUserNotificationSoundPathKey, path);
CFRelease(url);
CFRelease(path);
}
url = CFDictionaryGetValue(md, kCFUserNotificationLocalizationURLKey);
if (url && CFGetTypeID((CFTypeRef)url) == CFURLGetTypeID()) {
url = CFURLCopyAbsoluteURL(url);
CFDictionaryRemoveValue(md, kCFUserNotificationLocalizationURLKey);
path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
CFDictionaryAddValue(md, kCFUserNotificationLocalizationPathKey, path);
CFRelease(url);
CFRelease(path);
}
return md;
}
/*
* Function: AFPUser_set_random_password
* Purpose:
* Set a random password for the user and returns it in passwd.
* Do not change the password again until AFPUSER_PASSWORD_CHANGE_INTERVAL
* has elapsed. This overcomes the problem where every client
* request packet is duplicated. In that case, the client tries to use
* a password that subsequently gets changed when the duplicate arrives.
*/
Boolean
AFPUser_set_random_password(AFPUserRef user,
char * passwd, size_t passwd_len)
{
CFDateRef last_set;
Boolean ok = TRUE;
CFDateRef now;
CFStringRef pw;
ODRecordRef record;
now = CFDateCreate(NULL, CFAbsoluteTimeGetCurrent());
pw = CFDictionaryGetValue(user, kAFPUserPassword);
last_set = CFDictionaryGetValue(user, kAFPUserDatePasswordLastSet);
if (pw != NULL && last_set != NULL
&& (CFDateGetTimeIntervalSinceDate(now, last_set)
< AFPUSER_PASSWORD_CHANGE_INTERVAL)) {
/* return what we have */
#ifdef TEST_AFPUSERS
printf("No need to change the password %d < %d\n",
(int)CFDateGetTimeIntervalSinceDate(now, last_set),
AFPUSER_PASSWORD_CHANGE_INTERVAL);
#endif /* TEST_AFPUSERS */
(void)_SC_cfstring_to_cstring(pw, passwd, passwd_len,
kCFStringEncodingASCII);
CFDictionarySetValue(user, kAFPUserDatePasswordLastSet, now);
}
else {
generate_random_password(passwd, passwd_len);
record = (ODRecordRef)CFDictionaryGetValue(user, kAFPUserODRecord);
pw = CFStringCreateWithCString(NULL, passwd, kCFStringEncodingASCII);
ok = ODRecordChangePassword(record, NULL, pw, NULL);
if (ok) {
CFDictionarySetValue(user, kAFPUserPassword, pw);
CFDictionarySetValue(user, kAFPUserDatePasswordLastSet, now);
}
else {
my_log(LOG_NOTICE, "AFPUser_set_random_password:"******" ODRecordChangePassword() failed");
CFDictionaryRemoveValue(user, kAFPUserPassword);
CFDictionaryRemoveValue(user, kAFPUserDatePasswordLastSet);
}
CFRelease(pw);
}
CFRelease(now);
return ok;
}
// Remove item
void
OPL_DSNList::removeItem(UInt32 idx)
{
CFNumberRef num = CFNumberCreate(NULL, kCFNumberSInt32Type, &idx);
CFDictionaryRemoveValue(m_items, num);
CFRelease(num);
}
//------------------------------------------------------------------------------
// IOMIGMachPortCacheRemove
//------------------------------------------------------------------------------
void IOMIGMachPortCacheRemove(mach_port_t port)
{
pthread_mutex_lock(&__ioPortCacheLock);
CFDictionaryRemoveValue(__ioPortCache, (void *)port);
pthread_mutex_unlock(&__ioPortCacheLock);
}
/**
* Remove an existing position in a #PLIST_DICT node.
* Removed position will be freed using #plist_free
*
* @param node the node of type #PLIST_DICT
* @param key The identifier of the item to remove. Assert if identifier is not present.
*/
void plist_dict_remove_item(plist_t node, const char* key)
{
CFStringRef keyRef = CFStringCreateWithBytesNoCopy(kCFAllocatorDefault, (UInt8 *)key, strlen(key), kCFStringEncodingUTF8, FALSE, kCFAllocatorNull);
if (keyRef) {
CFDictionaryRemoveValue((CFMutableDictionaryRef) node, keyRef);
CFRelease(keyRef);
}
}
/*
* Function: EAPOLClientConfigurationRemoveProfile
*
* Purpose:
* Remove the specified profile from the configuration.
*
* Returns:
* FALSE if the profile is invalid or not in the configuration,
* TRUE otherwise.
*/
Boolean
EAPOLClientConfigurationRemoveProfile(EAPOLClientConfigurationRef cfg,
EAPOLClientProfileRef profile)
{
CFStringRef profileID = EAPOLClientProfileGetID(profile);
CFDataRef ssid;
if (EAPOLClientConfigurationGetProfileWithID(cfg, profileID) != profile) {
/* trying to remove profile that isn't part of the configuration */
return (FALSE);
}
ssid = EAPOLClientProfileGetWLANSSIDAndSecurityType(profile, NULL);
if (ssid != NULL) {
CFDictionaryRemoveValue(cfg->ssids, ssid);
}
CFDictionaryRemoveValue(cfg->profiles, profileID);
return (TRUE);
}
__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;
}
void CFErrorSetCallBackForDomain(CFStringRef domainName, CFErrorUserInfoKeyCallBack callBack) {
if (!_CFErrorCallBackTable) _CFErrorInitializeCallBackTable();
__CFSpinLock(&_CFErrorSpinlock);
if (callBack) {
CFDictionarySetValue(_CFErrorCallBackTable, domainName, callBack);
} else {
CFDictionaryRemoveValue(_CFErrorCallBackTable, domainName);
}
__CFSpinUnlock(&_CFErrorSpinlock);
}
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;
}
