自学教程：C++ CFGetAllocator函数代码示例

static CFTypeRef fileCopyProperty(struct _CFStream *stream, CFStringRef propertyName, void *info) {        CFTypeRef result = NULL;    _CFFileStreamContext *fileStream = (_CFFileStreamContext *)info;    if (CFEqual(propertyName, kCFStreamPropertyFileCurrentOffset)) {                // NOTE that this does a lseek of 0 from the current location in        // order to populate the offset field which will then be used to        // create the resulting value.        if (!__CFBitIsSet(fileStream->flags, APPEND) && fileStream->fd != -1) {            fileStream->offset = lseek(fileStream->fd, 0, SEEK_CUR);        }                if (fileStream->offset != -1) {            result = CFNumberCreate(CFGetAllocator((CFTypeRef)stream), kCFNumberSInt64Type, &(fileStream->offset));        }#if DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI || DEPLOYMENT_TARGET_LINUX    } else if (CFEqual(propertyName, _kCFStreamPropertyFileNativeHandle)) {        int fd = fileStream->fd;        if (fd != -1) {            result = CFDataCreate(CFGetAllocator((CFTypeRef) stream), (const uint8_t *)&fd, sizeof(fd));        }#endif    }    return result;}

static CFStringRef __CFBinaryHeapCopyDescription(CFTypeRef cf) {    CFBinaryHeapRef heap = (CFBinaryHeapRef)cf;    CFMutableStringRef result;    CFIndex idx;    CFIndex cnt;    const void **list, *buffer[256];    cnt = __CFBinaryHeapCount(heap);    result = CFStringCreateMutable(CFGetAllocator(heap), 0);    CFStringAppendFormat(result, NULL, CFSTR("<CFBinaryHeap %p [%p]>{count = %lu, capacity = %lu, objects = (/n"), cf, CFGetAllocator(heap), (unsigned long)cnt, (unsigned long)__CFBinaryHeapCapacity(heap));    list = (cnt <= 128) ? (const void **)buffer : (const void **)CFAllocatorAllocate(kCFAllocatorSystemDefault, cnt * sizeof(void *), 0); // GC OK    if (__CFOASafe && list != buffer) __CFSetLastAllocationEventName(list, "CFBinaryHeap (temp)");    CFBinaryHeapGetValues(heap, list);    for (idx = 0; idx < cnt; idx++) {	CFStringRef desc = NULL;	const void *item = list[idx];	if (NULL != heap->_callbacks.copyDescription) {	    desc = heap->_callbacks.copyDescription(item);	}	if (NULL != desc) {	    CFStringAppendFormat(result, NULL, CFSTR("/t%lu : %@/n"), (unsigned long)idx, desc);	    CFRelease(desc);	} else {	    CFStringAppendFormat(result, NULL, CFSTR("/t%lu : <%p>/n"), (unsigned long)idx, item);	}    }    CFStringAppend(result, CFSTR(")}"));    if (list != buffer) CFAllocatorDeallocate(CFGetAllocator(heap), list); // GC OK    return result;}

static CFArrayRef SecTaskCopyAccessGroups(SecTaskRef task) {#if CHECK_ENTITLEMENTS    CFStringRef appID = SecTaskCopyStringForEntitlement(task,        kSecEntitlementApplicationIdentifier);    CFArrayRef groups = SecTaskCopyArrayOfStringsForEntitlement(task,        kSecEntitlementKeychainAccessGroups);    if (appID) {        if (groups) {            CFMutableArrayRef nGroups = CFArrayCreateMutableCopy(                CFGetAllocator(groups), CFArrayGetCount(groups) + 1, groups);            CFArrayAppendValue(nGroups, appID);            CFRelease(groups);            groups = nGroups;        } else {            groups = CFArrayCreate(CFGetAllocator(task),                (const void **)&appID, 1, &kCFTypeArrayCallBacks);        }        CFRelease(appID);    }#else    CFArrayRef groups = SecAccessGroupsGetCurrent();    if (groups)        CFRetain(groups);#endif    return groups;}

CF_PRIVATE Boolean _CFBundleDLLLoad(CFBundleRef bundle, CFErrorRef *error) {    CFErrorRef localError = NULL;    if (!bundle->_isLoaded) {        CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);        wchar_t buff[CFMaxPathSize];        if (executableURL && _CFURLGetWideFileSystemRepresentation(executableURL, true, (wchar_t *)buff, CFMaxPathSize)) {            bundle->_hModule = LoadLibraryW(buff);            if (bundle->_hModule) {                bundle->_isLoaded = true;            } else {                if (error) {                    localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError);                } else {                    CFLog(__kCFLogBundle, CFSTR("Failed to load bundle %@"), bundle);                }            }        } else {            if (error) {                localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);            } else {                CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);            }        }        if (executableURL) CFRelease(executableURL);    }    if (!bundle->_isLoaded && error) *error = localError;    return bundle->_isLoaded;}

static void *writeDataCreate(struct _CFStream *stream, void *info) {    _CFWriteDataStreamContext *ctxt = (_CFWriteDataStreamContext *)info;    _CFWriteDataStreamContext *newCtxt;    if (ctxt->bufferAllocator != kCFAllocatorNull) {        if (ctxt->bufferAllocator == NULL) ctxt->bufferAllocator = CFAllocatorGetDefault();        CFRetain(ctxt->bufferAllocator);        newCtxt = (_CFWriteDataStreamContext *)CFAllocatorAllocate(CFGetAllocator(stream), sizeof(_CFWriteDataStreamContext) + sizeof(_CFStreamByteBuffer) + BUF_SIZE, 0);        newCtxt->firstBuf = (_CFStreamByteBuffer *)(newCtxt + 1);        newCtxt->firstBuf->bytes = (UInt8 *)(newCtxt->firstBuf + 1);        newCtxt->firstBuf->capacity = BUF_SIZE;        newCtxt->firstBuf->length = 0;        newCtxt->firstBuf->next = NULL;        newCtxt->currentBuf = newCtxt->firstBuf;        newCtxt->bufferAllocator = ctxt->bufferAllocator;        newCtxt->scheduled = FALSE;    } else {        newCtxt = (_CFWriteDataStreamContext *)CFAllocatorAllocate(CFGetAllocator(stream), sizeof(_CFWriteDataStreamContext) + sizeof(_CFStreamByteBuffer), 0);        newCtxt->firstBuf = (_CFStreamByteBuffer *)(newCtxt+1);        newCtxt->firstBuf->bytes = ctxt->firstBuf->bytes;        newCtxt->firstBuf->capacity = ctxt->firstBuf->capacity;        newCtxt->firstBuf->length = 0;        newCtxt->firstBuf->next = NULL;        newCtxt->currentBuf = newCtxt->firstBuf;        newCtxt->bufferAllocator = kCFAllocatorNull;        newCtxt->scheduled = FALSE;    }    return (void *)newCtxt;}

static CFStringRef __CFDateCopyDescription(CFTypeRef cf) {    CFDateRef date = (CFDateRef)cf;    return CFStringCreateWithFormat(        CFGetAllocator(date),        NULL, CFSTR("<CFDate %p [%p]>{time = %0.09g}"),        cf, CFGetAllocator(date), date->_time);}

static void fileSchedule(struct _CFStream *stream, CFRunLoopRef runLoop, CFStringRef runLoopMode, void *info) {    _CFFileStreamContext *fileStream = (_CFFileStreamContext *)info;    Boolean isReadStream = (CFGetTypeID(stream) == CFReadStreamGetTypeID());    CFStreamStatus status = isReadStream ? CFReadStreamGetStatus((CFReadStreamRef)stream) : CFWriteStreamGetStatus((CFWriteStreamRef)stream);    if (fileStream->fd < 0 && status != kCFStreamStatusNotOpen) {        // Stream's already closed or error-ed out         return;    }#ifdef REAL_FILE_SCHEDULING    if (status == kCFStreamStatusNotOpen) {        if (!fileStream->rlInfo.rlArray) {            fileStream->rlInfo.rlArray = CFArrayCreateMutable(CFGetAllocator(stream), 0, &kCFTypeArrayCallBacks);        }        CFArrayAppendValue(fileStream->rlInfo.rlArray, runLoop);        CFArrayAppendValue(fileStream->rlInfo.rlArray, runLoopMode);    } else {        CFRunLoopSourceRef rlSrc;        if (!fileStream->rlInfo.cffd) {            constructCFFD(fileStream, isReadStream, stream);        }        rlSrc = CFFileDescriptorCreateRunLoopSource(CFGetAllocator(stream), fileStream->rlInfo.cffd, 0);        CFRunLoopAddSource(runLoop, rlSrc, runLoopMode);        CFRelease(rlSrc);    }#else    fileStream->scheduled++;    if (fileStream->scheduled == 1 && fileStream->fd > 0 && status == kCFStreamStatusOpen) {        if (isReadStream)            CFReadStreamSignalEvent((CFReadStreamRef)stream, kCFStreamEventHasBytesAvailable, NULL);        else            CFWriteStreamSignalEvent((CFWriteStreamRef)stream, kCFStreamEventCanAcceptBytes, NULL);    }#endif}

CF_EXPORT Boolean _CFBundleDlfcnPreflight(CFBundleRef bundle, CFErrorRef *error) {    Boolean retval = true;    CFErrorRef localError = NULL;    if (!bundle->_isLoaded) {        CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);        char buff[CFMaxPathSize];                retval = false;        if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED            retval = dlopen_preflight(buff);#endif            if (!retval && error) {                CFArrayRef archs = CFBundleCopyExecutableArchitectures(bundle);                CFStringRef debugString = NULL;                const char *errorString = dlerror();                if (errorString && strlen(errorString) > 0) debugString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString);                if (archs) {                    Boolean hasSuitableArch = false, hasRuntimeMismatch = false;                    CFIndex i, count = CFArrayGetCount(archs);                    SInt32 arch, curArch = _CFBundleCurrentArchitecture();                    for (i = 0; !hasSuitableArch && i < count; i++) {                        if (CFNumberGetValue((CFNumberRef)CFArrayGetValueAtIndex(archs, i), kCFNumberSInt32Type, (void *)&arch) && arch == curArch) hasSuitableArch = true;                    }#if defined(BINARY_SUPPORT_DYLD)                    if (hasSuitableArch) {                        uint32_t mainFlags = 0;                        if (_CFBundleGrokObjCImageInfoFromMainExecutable(NULL, &mainFlags) && (mainFlags & 0x2) != 0) {#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED                            uint32_t bundleFlags = 0;                            if (_CFBundleGetObjCImageInfo(bundle, NULL, &bundleFlags) && (bundleFlags & 0x2) == 0) hasRuntimeMismatch = true;#endif                        }                    }#endif /* BINARY_SUPPORT_DYLD */                    if (hasRuntimeMismatch) {                        localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableRuntimeMismatchError, debugString);                    } else if (!hasSuitableArch) {                        localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableArchitectureMismatchError, debugString);                    } else {                        localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLoadError, debugString);                    }                    CFRelease(archs);                } else {                    localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLoadError, debugString);                }                if (debugString) CFRelease(debugString);            }        } else {            if (error) localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);        }        if (executableURL) CFRelease(executableURL);    }    if (!retval && error) *error = localError;    return retval;}

CF_PRIVATE Boolean _CFBundleDYLDLoadFramework(CFBundleRef bundle, CFErrorRef *error) {    // !!! Framework loading should be better.  Can't unload frameworks.    CFErrorRef localError = NULL, *subError = (error ? &localError : NULL);    NSLinkEditErrors c = NSLinkEditUndefinedError;    int errorNumber = 0;    const char *fileName = NULL;    const char *errorString = NULL;    if (!bundle->_isLoaded) {        CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);        char buff[CFMaxPathSize];        if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {            void *image = (void *)NSAddImage(buff, NSADDIMAGE_OPTION_RETURN_ON_ERROR);#if LOG_BUNDLE_LOAD            printf("dyld load framework %p, add image of %s returns image %p/n", bundle, buff, image);#endif /* LOG_BUNDLE_LOAD */            if (image) {                bundle->_imageCookie = image;                bundle->_isLoaded = true;            } else {                NSLinkEditError(&c, &errorNumber, &fileName, &errorString);                if (error) {#if defined(BINARY_SUPPORT_DLFCN)                    _CFBundleDlfcnPreflight(bundle, subError);#endif /* BINARY_SUPPORT_DLFCN */                    if (!localError) {                        CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), debugString = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("error code %d, error number %d (%@)"), c, errorNumber, tempString);                        localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, debugString);                        if (tempString) CFRelease(tempString);                        if (debugString) CFRelease(debugString);                    }                } else {                    CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, fileName);                    CFLog(__kCFLogBundle, CFSTR("Error loading %@:  error code %d, error number %d (%@)"), executableString, c, errorNumber, tempString);                    if (tempString) CFRelease(tempString);                    if (executableString) CFRelease(executableString);                }            }        } else {            if (error) {                localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);            } else {                CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);            }        }        if (executableURL) CFRelease(executableURL);    }    if (!bundle->_isLoaded && error) *error = localError;    return bundle->_isLoaded;}

static Boolean _IOFileURLWritePropertiesToResource(CFURLRef url, CFDictionaryRef propertyDict, SInt32 *errorCode) {    CFTypeRef buffer[16];    void **keys;    void **values;    Boolean result = TRUE;    SInt32 index, count;    char cPath[CFMaxPathSize];    if (!CFURLGetFileSystemRepresentation(url, TRUE, cPath, CFMaxPathSize)) {        if (errorCode) *errorCode = kIOURLImproperArgumentsError;        return FALSE;    }    count = CFDictionaryGetCount(propertyDict);    if (count < 8) {        keys = buffer;        values = buffer+8;    } else {        keys = CFAllocatorAllocate(CFGetAllocator(url), sizeof(void *) * count * 2, 0);        values = keys + count;    }    CFDictionaryGetKeysAndValues(propertyDict, keys, values);    for (index = 0; index < count; index ++) {        CFStringRef key = keys[index];        CFTypeRef value = values[index];        if (CFEqual(key, kIOFileURLPOSIXMode) || CFEqual(key, kIOURLFilePOSIXMode)) {            SInt32 mode;            int err;            if (CFEqual(key, kIOURLFilePOSIXMode)) {                CFNumberRef modeNum = (CFNumberRef)value;                CFNumberGetValue(modeNum, kCFNumberSInt32Type, &mode);            } else {                const mode_t *modePtr = (const mode_t *)CFDataGetBytePtr((CFDataRef)value);                mode = *modePtr;            }            err = chmod(cPath, mode);            if (err != 0) result = FALSE;        } else {            result = FALSE;        }    }    if (keys != &buffer[0]) CFAllocatorDeallocate(CFGetAllocator(url), keys);    if (errorCode) *errorCode = result ? 0 : kIOURLUnknownError;    return result;}

/* Allocates new block of data with at least numNewValues more bytes than the current length. If clear is true, the new bytes up to at least the new length with be zeroed. */static void __CFDataGrow(CFMutableDataRef data, CFIndex numNewValues, Boolean clear) {    CFIndex oldLength = __CFDataLength(data);    CFIndex newLength = oldLength + numNewValues;    if (newLength > CFDATA_MAX_SIZE || newLength < 0) __CFDataHandleOutOfMemory(data, newLength * sizeof(uint8_t));    CFIndex capacity = __CFDataRoundUpCapacity(newLength);    CFIndex numBytes = __CFDataNumBytesForCapacity(capacity);    CFAllocatorRef allocator = CFGetAllocator(data);    void *bytes = NULL;    void *oldBytes = data->_bytes;    Boolean allocateCleared = clear && __CFDataShouldAllocateCleared(data, numBytes);    if (allocateCleared && !__CFDataUseAllocator(data) && (oldLength == 0 || (newLength / oldLength) > 4)) {	// If the length that needs to be zeroed is significantly greater than the length of the data, then calloc/memmove is probably more efficient than realloc/memset.	bytes = __CFDataAllocate(data, numBytes * sizeof(uint8_t), true);	if (NULL != bytes) {	    memmove(bytes, oldBytes, oldLength);	    __CFDataDeallocate(data);	}    }    if (bytes == NULL) {	// If the calloc/memmove approach either failed or was never attempted, then realloc.	allocateCleared = false;	if (__CFDataUseAllocator(data)) {	    bytes = CFAllocatorReallocate(allocator, oldBytes, numBytes * sizeof(uint8_t), 0);	} else {	    bytes = realloc(oldBytes, numBytes * sizeof(uint8_t));	}    }    if (NULL == bytes) __CFDataHandleOutOfMemory(data, numBytes * sizeof(uint8_t));    __CFDataSetCapacity(data, capacity);    __CFDataSetNumBytes(data, numBytes);    if (clear && !allocateCleared && oldLength < newLength) memset((uint8_t *)bytes + oldLength, 0, newLength - oldLength);    __CFDataSetNeedsToZero(data, !allocateCleared);    __CFAssignWithWriteBarrier((void **)&data->_bytes, bytes);    if (__CFOASafe) __CFSetLastAllocationEventName(data->_bytes, "CFData (store)");}

CF_EXPORT Boolean CFPlugInRegisterFactoryFunctionByName(CFUUIDRef factoryID, CFPlugInRef plugIn, CFStringRef functionName) {    // Create factories with plugIns from plugIn's allocator    // MF:!!! Should probably check that this worked, and maybe do some pre-checking to see if it already exists    // _CFPFactory *factory =    (void)_CFPFactoryCreateByName(CFGetAllocator(plugIn), factoryID, plugIn, functionName);    return true;}

__private_extern__ Boolean__SCPreferencesAddSession(SCPreferencesRef prefs){	CFAllocatorRef			allocator	= CFGetAllocator(prefs);	SCDynamicStoreContext		context		= { 0							  , (void *)prefs							  , NULL							  , NULL							  , NULL							  };	SCPreferencesPrivateRef		prefsPrivate	= (SCPreferencesPrivateRef)prefs;	/* establish a dynamic store session */	prefsPrivate->session = SCDynamicStoreCreate(allocator,						     prefsPrivate->name,						     prefsNotify,						     &context);	if (prefsPrivate->session == NULL) {		SCLog(_sc_verbose, LOG_INFO, CFSTR("__SCPreferencesAddSession SCDynamicStoreCreate() failed"));		return FALSE;	}	/* create the session "commit" key */	prefsPrivate->sessionKeyCommit = _SCPNotificationKey(NULL,							     prefsPrivate->prefsID,							     kSCPreferencesKeyCommit);	/* create the session "apply" key */	prefsPrivate->sessionKeyApply = _SCPNotificationKey(NULL,							    prefsPrivate->prefsID,							    kSCPreferencesKeyApply);	return TRUE;}

static CFStringRef__SCPreferencesCopyDescription(CFTypeRef cf) {	CFAllocatorRef		allocator	= CFGetAllocator(cf);	SCPreferencesPrivateRef prefsPrivate	= (SCPreferencesPrivateRef)cf;	CFMutableStringRef	result;	result = CFStringCreateMutable(allocator, 0);	CFStringAppendFormat(result, NULL, CFSTR("<SCPreferences %p [%p]> {"), cf, allocator);	CFStringAppendFormat(result, NULL, CFSTR("name = %@"), prefsPrivate->name);	CFStringAppendFormat(result, NULL, CFSTR(", id = %@"), prefsPrivate->prefsID);	CFStringAppendFormat(result, NULL, CFSTR(", path = %s"),			     prefsPrivate->newPath ? prefsPrivate->newPath : prefsPrivate->path);	if (prefsPrivate->accessed) {		CFStringAppendFormat(result, NULL, CFSTR(", accessed"));	}	if (prefsPrivate->changed) {		CFStringAppendFormat(result, NULL, CFSTR(", changed"));	}	if (prefsPrivate->locked) {		CFStringAppendFormat(result, NULL, CFSTR(", locked"));	}	if (prefsPrivate->helper_port != MACH_PORT_NULL) {		CFStringAppendFormat(result, NULL, CFSTR(", helper port = 0x%x"), prefsPrivate->helper_port);	}	CFStringAppendFormat(result, NULL, CFSTR("}"));	return result;}

static CFStringRef SecTaskCopyDebugDescription(CFTypeRef cfTask){    SecTaskRef task = (SecTaskRef) cfTask;    pid_t pid;    if (task->pid_self==-1) {        audit_token_to_au32(task->token, NULL, NULL, NULL, NULL, NULL, &pid, NULL, NULL);    } else {        pid = task->pid_self;    }#if USE_LIBPROC#define MAX_PROCNAME 32    char task_name[MAX_PROCNAME + 1] = {};    proc_name(pid, task_name, MAX_PROCNAME);#else    const char *task_name;    int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};    struct kinfo_proc kp;    size_t len = sizeof(kp);    if (sysctl(mib, 4, &kp, &len, NULL, 0) == -1 || len == 0)        task_name = strerror(errno);    else        task_name = kp.kp_proc.p_comm;#endif    return CFStringCreateWithFormat(CFGetAllocator(task), NULL, CFSTR("%s[%" PRIdPID "]/%d#%d LF=%d"), task_name, pid,									task->entitlementsLoaded, task->entitlements ? (int)CFDictionaryGetCount(task->entitlements) : -1, task->lastFailure);}

// Designated initializer; all node creation (except the wonky one created by the parser) should happen here.CFXMLNodeRef CFXMLNodeCreate(CFAllocatorRef alloc, CFXMLNodeTypeCode xmlType, CFStringRef dataString, const void *additionalData, CFIndex version) {    struct __CFXMLNode *node;    UInt32 extraSize;    // Add assertions checking xmlType against the presence/absence of additionalData & dataString    switch (xmlType) {        case kCFXMLNodeTypeDocument: extraSize = sizeof(CFXMLDocumentInfo); break;        case kCFXMLNodeTypeElement: extraSize = sizeof(CFXMLElementInfo); break;        case kCFXMLNodeTypeProcessingInstruction: extraSize = sizeof(CFXMLProcessingInstructionInfo); break;        case kCFXMLNodeTypeEntity: extraSize = sizeof(CFXMLEntityInfo); break;        case kCFXMLNodeTypeEntityReference: extraSize = sizeof(CFXMLEntityReferenceInfo); break;        case kCFXMLNodeTypeDocumentType: extraSize = sizeof(CFXMLDocumentTypeInfo); break;        case kCFXMLNodeTypeNotation: extraSize = sizeof(CFXMLNotationInfo); break;        case kCFXMLNodeTypeElementTypeDeclaration: extraSize = sizeof(CFXMLElementTypeDeclarationInfo); break;        case kCFXMLNodeTypeAttributeListDeclaration: extraSize = sizeof(CFXMLAttributeListDeclarationInfo); break;        default: extraSize = 0;    }    node = (struct __CFXMLNode *)_CFRuntimeCreateInstance(alloc, CFXMLNodeGetTypeID(), sizeof(struct __CFXMLNode) + extraSize - sizeof(CFRuntimeBase), NULL);    if (node) {        alloc = CFGetAllocator(node);        node->version = version;        node->dataTypeID = xmlType;        node->dataString = dataString ? (CFStringRef)CFStringCreateCopy(alloc, dataString) : NULL;        if (extraSize != 0) {            node->additionalData = (void *)((uint8_t *)node + sizeof(struct __CFXMLNode));            _copyAddlDataForType(alloc, xmlType, additionalData, node->additionalData);        } else {            node->additionalData = NULL;        }    }    return node;}

static CFStringRef __CFArrayCopyDescription(CFTypeRef cf) {    CFArrayRef array = (CFArrayRef)cf;    CFMutableStringRef result;    const CFArrayCallBacks *cb;    CFAllocatorRef allocator;    CFIndex idx, cnt;    cnt = __CFArrayGetCount(array);    allocator = CFGetAllocator(array);    result = CFStringCreateMutable(allocator, 0);    switch (__CFArrayGetType(array)) {    case __kCFArrayImmutable:	CFStringAppendFormat(result, NULL, CFSTR("<CFArray %p [%p]>{type = immutable, count = %lu, values = (%s"), cf, allocator, (unsigned long)cnt, cnt ? "/n" : "");	break;    case __kCFArrayDeque:	CFStringAppendFormat(result, NULL, CFSTR("<CFArray %p [%p]>{type = mutable-small, count = %lu, values = (%s"), cf, allocator, (unsigned long)cnt, cnt ? "/n" : "");	break;    }    cb = __CFArrayGetCallBacks(array);    for (idx = 0; idx < cnt; idx++) {	CFStringRef desc = NULL;	const void *val = __CFArrayGetBucketAtIndex(array, idx)->_item;	if (NULL != cb->copyDescription) {	    desc = (CFStringRef)INVOKE_CALLBACK1(cb->copyDescription, val);	}	if (NULL != desc) {	    CFStringAppendFormat(result, NULL, CFSTR("/t%lu : %@/n"), (unsigned long)idx, desc);	    CFRelease(desc);	} else {	    CFStringAppendFormat(result, NULL, CFSTR("/t%lu : <%p>/n"), (unsigned long)idx, val);	}    }    CFStringAppend(result, CFSTR(")}"));    return result;}

CFArrayRefSCPreferencesCopyKeyList(SCPreferencesRef prefs){	CFAllocatorRef		allocator;	CFArrayRef		keys;	SCPreferencesPrivateRef	prefsPrivate	= (SCPreferencesPrivateRef)prefs;	CFIndex			prefsCnt;	const void **		prefsKeys;	if (prefs == NULL) {		/* sorry, you must provide a session */		_SCErrorSet(kSCStatusNoPrefsSession);		return NULL;	}	__SCPreferencesAccess(prefs);	allocator = CFGetAllocator(prefs);	prefsCnt  = CFDictionaryGetCount(prefsPrivate->prefs);	if (prefsCnt > 0) {		prefsKeys = CFAllocatorAllocate(allocator, prefsCnt * sizeof(CFStringRef), 0);		CFDictionaryGetKeysAndValues(prefsPrivate->prefs, prefsKeys, NULL);		keys = CFArrayCreate(allocator, prefsKeys, prefsCnt, &kCFTypeArrayCallBacks);		CFAllocatorDeallocate(allocator, prefsKeys);	} else {		keys = CFArrayCreate(allocator, NULL, 0, &kCFTypeArrayCallBacks);	}	return keys;}

CFTypeRef CFMakeCollectable(CFTypeRef cf) {    if (NULL == cf) return NULL;    if (CF_IS_COLLECTABLE(cf)) {#if defined(DEBUG)        CFAllocatorRef allocator = CFGetAllocator(cf);        if (!CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {            CFLog(kCFLogLevelWarning, CFSTR("object %p with non-GC allocator %p passed to CFMakeCollectable."), cf, allocator);            HALT;        }#endif        if (!CFTYPE_IS_OBJC(cf)) {            CFRuntimeClass *cfClass = __CFRuntimeClassTable[__CFGenericTypeID_inline(cf)];            if (cfClass->version & (_kCFRuntimeResourcefulObject)) {                // don't allow the collector to manage uncollectable objects.                CFLog(kCFLogLevelWarning, CFSTR("uncollectable object %p passed to CFMakeCollectable."), cf);                HALT;            }        }        if (auto_zone_retain_count(__CFCollectableZone, cf) == 0) {            CFLog(kCFLogLevelWarning, CFSTR("object %p with 0 retain-count passed to CFMakeCollectable."), cf);            return cf;        }        auto_zone_release(__CFCollectableZone, (void *)cf);    }    return cf;}

CFDictionaryRef SecTaskCopyValuesForEntitlements(SecTaskRef task, CFArrayRef entitlements, CFErrorRef *error){    CFMutableDictionaryRef values = NULL;    require(check_task(task), out);    /* Load entitlements if necessary */    if (task->entitlementsLoaded == false) {        SecTaskLoadEntitlements(task, error);    }        /* Iterate over the passed in entitlements, populating the dictionary     * If entitlements were loaded but none were present, return an empty     * dictionary */    if (task->entitlementsLoaded == true) {                CFIndex i, count = CFArrayGetCount(entitlements);        values = CFDictionaryCreateMutable(CFGetAllocator(task), count, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);        if (task->entitlements != NULL) {            for (i = 0; i < count; i++) {                CFStringRef entitlement = CFArrayGetValueAtIndex(entitlements, i);                CFTypeRef value = CFDictionaryGetValue(task->entitlements, entitlement);                if (value != NULL) {                    CFDictionarySetValue(values, entitlement, value);                }            }        }    }out:    return values;}

static Boolean __CFBinaryHeapEqual(CFTypeRef cf1, CFTypeRef cf2) {    CFBinaryHeapRef heap1 = (CFBinaryHeapRef)cf1;    CFBinaryHeapRef heap2 = (CFBinaryHeapRef)cf2;    CFComparisonResult (*compare)(const void *, const void *, void *);    CFIndex idx;    CFIndex cnt;    const void **list1, **list2, *buffer[256];    cnt = __CFBinaryHeapCount(heap1);    if (cnt != __CFBinaryHeapCount(heap2)) return false;    compare = heap1->_callbacks.compare;    if (compare != heap2->_callbacks.compare) return false;    if (0 == cnt) return true;	/* after function comparison */    list1 = (cnt <= 128) ? (const void **)buffer : (const void **)CFAllocatorAllocate(kCFAllocatorSystemDefault, 2 * cnt * sizeof(void *), 0); // GC OK    if (__CFOASafe && list1 != buffer) __CFSetLastAllocationEventName(list1, "CFBinaryHeap (temp)");    list2 = (cnt <= 128) ? buffer + 128 : list1 + cnt;    CFBinaryHeapGetValues(heap1, list1);    CFBinaryHeapGetValues(heap2, list2);    for (idx = 0; idx < cnt; idx++) {	const void *val1 = list1[idx];	const void *val2 = list2[idx];// CF: which context info should be passed in? both?// CF: if the context infos are not equal, should the heaps not be equal?        if (val1 != val2) {             if (NULL == compare) return false;            if (!compare(val1, val2, heap1->_context.info)) return false;        }    }    if (list1 != buffer) CFAllocatorDeallocate(CFGetAllocator(heap1), list1); // GC OK    return true;}

static CFStringRef __CFDataCopyDescription(CFTypeRef cf) {    CFDataRef data = (CFDataRef)cf;    CFMutableStringRef result;    CFIndex idx;    CFIndex len;    const uint8_t *bytes;    len = __CFDataLength(data);    bytes = CFDataGetBytePtr(data);    result = CFStringCreateMutable(CFGetAllocator(data), 0);    CFStringAppendFormat(result, NULL, CFSTR("<CFData %p [%p]>{length = %u, capacity = %u, bytes = 0x"), cf, CFGetAllocator(data), len, __CFDataCapacity(data));    if (24 < len) {        for (idx = 0; idx < 16; idx += 4) {	    CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);	}        CFStringAppend(result, CFSTR(" ... "));        for (idx = len - 8; idx < len; idx += 4) {	    CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);	}    } else {        for (idx = 0; idx < len; idx++) {	    CFStringAppendFormat(result, NULL, CFSTR("%02x"), bytes[idx]);	}    }    CFStringAppend(result, CFSTR("}"));    return result;}

CFDictionaryRef CFPreferencesCopyMultiple(CFArrayRef keysToFetch, CFStringRef appName, CFStringRef user, CFStringRef host) {    CFPreferencesDomainRef domain;    CFMutableDictionaryRef result;    CFIndex idx, count;    CFAssert1(appName != NULL && user != NULL && host != NULL, __kCFLogAssertion, "%s(): Cannot access preferences for a NULL application name, user, or host", __PRETTY_FUNCTION__);    __CFGenericValidateType(appName, CFStringGetTypeID());    __CFGenericValidateType(user, CFStringGetTypeID());    __CFGenericValidateType(host, CFStringGetTypeID());    domain = _CFPreferencesStandardDomain(appName, user, host);    if (!domain) return NULL;    if (!keysToFetch) {        return _CFPreferencesDomainDeepCopyDictionary(domain);    } else {        __CFGenericValidateType(keysToFetch, CFArrayGetTypeID());        count = CFArrayGetCount(keysToFetch);        result = CFDictionaryCreateMutable(CFGetAllocator(domain), count, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);        if (!result) return NULL;        for (idx = 0; idx < count; idx ++) {            CFStringRef key = (CFStringRef)CFArrayGetValueAtIndex(keysToFetch, idx);            CFPropertyListRef value;            __CFGenericValidateType(key, CFStringGetTypeID());            value = _CFPreferencesDomainCreateValueForKey(domain, key);            if (value) {                CFDictionarySetValue(result, key, value);                CFRelease(value);            }        }    }    return result;}

void CFBinaryHeapRemoveMinimumValue(CFBinaryHeapRef heap) {    void *val;    CFIndex idx, cidx;    CFIndex cnt;    CFAllocatorRef allocator;    __CFGenericValidateType(heap, __kCFBinaryHeapTypeID);    cnt = __CFBinaryHeapCount(heap);    if (0 == cnt) return;    idx = 0;    __CFBinaryHeapSetNumBucketsUsed(heap, cnt - 1);    __CFBinaryHeapSetCount(heap, cnt - 1);    CFComparisonResult (*compare)(const void *, const void *, void *) = heap->_callbacks.compare;    allocator = CFGetAllocator(heap);    if (heap->_callbacks.release)	heap->_callbacks.release(allocator, heap->_buckets[idx]._item);    val = heap->_buckets[cnt - 1]._item;    cidx = (idx << 1) + 1;    while (cidx < __CFBinaryHeapCount(heap)) {	void *item = heap->_buckets[cidx]._item;	if (cidx + 1 < __CFBinaryHeapCount(heap)) {	    void *item2 = heap->_buckets[cidx + 1]._item;	    if ((!compare && item > item2) || (compare && kCFCompareGreaterThan == compare(item, item2, heap->_context.info))) {		cidx++;		item = item2;	    }	}	if ((!compare && item > val) || (compare && kCFCompareGreaterThan == compare(item, val, heap->_context.info))) break;	__CFAssignWithWriteBarrier((void **)&heap->_buckets[idx]._item, item);	idx = cidx;	cidx = (idx << 1) + 1;    }    __CFAssignWithWriteBarrier((void **)&heap->_buckets[idx]._item, val);}

void CFBinaryHeapAddValue(CFBinaryHeapRef heap, const void *value) {    CFIndex idx, pidx;    CFIndex cnt;    CFAllocatorRef allocator = CFGetAllocator(heap);    __CFGenericValidateType(heap, __kCFBinaryHeapTypeID);    switch (__CFBinaryHeapMutableVariety(heap)) {    case kCFBinaryHeapMutable:	if (__CFBinaryHeapNumBucketsUsed(heap) == __CFBinaryHeapCapacity(heap))	    __CFBinaryHeapGrow(heap, 1);	break;    }    cnt = __CFBinaryHeapCount(heap);    idx = cnt;    __CFBinaryHeapSetNumBucketsUsed(heap, cnt + 1);    __CFBinaryHeapSetCount(heap, cnt + 1);    CFComparisonResult (*compare)(const void *, const void *, void *) = heap->_callbacks.compare;    pidx = (idx - 1) >> 1;    while (0 < idx) {	void *item = heap->_buckets[pidx]._item;	if ((!compare && item <= value) || (compare && kCFCompareGreaterThan != compare(item, value, heap->_context.info))) break;	__CFAssignWithWriteBarrier((void **)&heap->_buckets[idx]._item, item);	idx = pidx;	pidx = (idx - 1) >> 1;    }    if (heap->_callbacks.retain) {	__CFAssignWithWriteBarrier((void **)&heap->_buckets[idx]._item, (void *)heap->_callbacks.retain(allocator, (void *)value));    } else {	__CFAssignWithWriteBarrier((void **)&heap->_buckets[idx]._item, (void *)value);    }}

static CFDataRef SecRSAPrivateKeyCopyPKCS1(SecKeyRef key){    ccrsa_full_ctx_t fullkey;    fullkey.full = key->key;	CFAllocatorRef allocator = CFGetAllocator(key);    return SecRSAPrivateKeyCreatePKCS1(allocator, fullkey);}

CF_PRIVATE Boolean _CFBundleDlfcnLoadBundle(CFBundleRef bundle, Boolean forceGlobal, CFErrorRef *error) {    CFErrorRef localError = NULL, *subError = (error ? &localError : NULL);    if (!bundle->_isLoaded) {        CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);        char buff[CFMaxPathSize];        if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) {            int mode = forceGlobal ? (RTLD_LAZY | RTLD_GLOBAL | RTLD_FIRST) : (RTLD_NOW | RTLD_LOCAL | RTLD_FIRST);            void *cookie = dlopen(buff, mode);#if LOG_BUNDLE_LOAD            printf("dlfcn load bundle %p, dlopen of %s mode 0x%x returns handle %p/n", bundle, buff, mode, cookie);#endif /* LOG_BUNDLE_LOAD */            if (cookie && cookie == bundle->_handleCookie) {                // during the call to dlopen, arbitrary init routines may have run and caused bundle->_handleCookie to be set, in which case proper reference counting requires that reference to be released with dlclose#if LOG_BUNDLE_LOAD                printf("dlfcn load bundle %p closing existing reference to handle %p/n", bundle, cookie);#endif /* LOG_BUNDLE_LOAD */                dlclose(bundle->_handleCookie);            }            bundle->_handleCookie = cookie;            if (bundle->_handleCookie) {                bundle->_isLoaded = true;            } else {                const char *dyldError = dlerror();                CFStringRef errorString = dyldError ? CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, dyldError) : NULL;                if (error) {                    _CFBundleDlfcnPreflight(bundle, subError);                    if (!localError) localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, errorString);                } else {                    CFStringRef executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, buff);                    CFLog(__kCFLogBundle, CFSTR("Error loading %@:  %@"), executableString, errorString ? errorString : CFSTR("(no additional info)"));                    if (executableString) CFRelease(executableString);                }                if (errorString) CFRelease(errorString);            }        } else {            if (error) {                localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError);            } else {                CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle);            }        }        if (executableURL) CFRelease(executableURL);    }    if (!bundle->_isLoaded && error) *error = localError;    return bundle->_isLoaded;}

static void constructCFFD(_CFFileStreamContext *fileStream, Boolean forRead, struct _CFStream *stream) {    CFFileDescriptorContext context = {0, stream, NULL, NULL, (void *)CFCopyDescription};    CFFileDescriptorRef cffd = CFFileDescriptorCreate(CFGetAllocator(stream), fileStream->fd, false, fileCallBack, &context);    CFFileDescriptorEnableCallBacks(cffd, forRead ? kCFFileDescriptorReadCallBack : kCFFileDescriptorWriteCallBack);    if (fileStream->rlInfo.rlArray) {        CFIndex i, c = CFArrayGetCount(fileStream->rlInfo.rlArray);        CFRunLoopSourceRef src = CFFileDescriptorCreateRunLoopSource(CFGetAllocator(stream), cffd, 0);        for (i = 0; i+1 < c; i += 2) {            CFRunLoopRef rl = (CFRunLoopRef)CFArrayGetValueAtIndex(fileStream->rlInfo.rlArray, i);            CFStringRef mode = CFArrayGetValueAtIndex(fileStream->rlInfo.rlArray, i+1);            CFRunLoopAddSource(rl, src, mode);        }        CFRelease(fileStream->rlInfo.rlArray);        CFRelease(src);    }        fileStream->rlInfo.cffd = cffd;}