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

boolSetXiphCommentFromMetadata(const AudioMetadata& metadata, TagLib::Ogg::XiphComment *tag){	assert(NULL != tag);	// Standard tags	SetXiphComment(tag, "ALBUM", metadata.GetAlbumTitle());	SetXiphComment(tag, "ARTIST", metadata.GetArtist());	SetXiphComment(tag, "ALBUMARTIST", metadata.GetAlbumArtist());	SetXiphComment(tag, "COMPOSER", metadata.GetComposer());	SetXiphComment(tag, "GENRE", metadata.GetGenre());	SetXiphComment(tag, "DATE", metadata.GetReleaseDate());	SetXiphComment(tag, "DESCRIPTION", metadata.GetComment());	SetXiphComment(tag, "TITLE", metadata.GetTitle());	SetXiphCommentNumber(tag, "TRACKNUMBER", metadata.GetTrackNumber());	SetXiphCommentNumber(tag, "TRACKTOTAL", metadata.GetTrackTotal());	SetXiphCommentBoolean(tag, "COMPILATION", metadata.GetCompilation());	SetXiphCommentNumber(tag, "DISCNUMBER", metadata.GetDiscNumber());	SetXiphCommentNumber(tag, "DISCTOTAL", metadata.GetDiscTotal());	SetXiphComment(tag, "ISRC", metadata.GetISRC());	SetXiphComment(tag, "MCN", metadata.GetMCN());		// Additional metadata	CFDictionaryRef additionalMetadata = metadata.GetAdditionalMetadata();	if(NULL != additionalMetadata) {		CFIndex count = CFDictionaryGetCount(additionalMetadata);				const void * keys [count];		const void * values [count];				CFDictionaryGetKeysAndValues(additionalMetadata, reinterpret_cast<const void **>(keys), reinterpret_cast<const void **>(values));				for(CFIndex i = 0; i < count; ++i) {			CFIndex keySize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(reinterpret_cast<CFStringRef>(keys[i])), kCFStringEncodingASCII);			char key [keySize + 1];						if(!CFStringGetCString(reinterpret_cast<CFStringRef>(keys[i]), key, keySize + 1, kCFStringEncodingASCII)) {				log4cxx::LoggerPtr logger = log4cxx::Logger::getLogger("org.sbooth.AudioEngine");				LOG4CXX_ERROR(logger, "CFStringGetCString failed");				continue;			}						SetXiphComment(tag, key, reinterpret_cast<CFStringRef>(values[i]));		}	}		// ReplayGain info	SetXiphCommentDouble(tag, "REPLAYGAIN_REFERENCE_LOUDNESS", metadata.GetReplayGainReferenceLoudness(), CFSTR("%2.1f dB"));	SetXiphCommentDouble(tag, "REPLAYGAIN_TRACK_GAIN", metadata.GetReplayGainReferenceLoudness(), CFSTR("%+2.2f dB"));	SetXiphCommentDouble(tag, "REPLAYGAIN_TRACK_PEAK", metadata.GetReplayGainTrackGain(), CFSTR("%1.8f"));	SetXiphCommentDouble(tag, "REPLAYGAIN_ALBUM_GAIN", metadata.GetReplayGainAlbumGain(), CFSTR("%+2.2f dB"));	SetXiphCommentDouble(tag, "REPLAYGAIN_ALBUM_PEAK", metadata.GetReplayGainAlbumPeak(), CFSTR("%1.8f"));	return true;}

static voidnc_listvpn(int argc, char **argv){	CFDictionaryRef		appDict = NULL;	CFArrayRef		appinfo = NULL;	int			i, j, count, subtypecount;	const void * *		keys = NULL;	CFMutableDictionaryRef optionsDict = NULL;	const void * *		values = NULL;	CFStringRef		vpntype = NULL;	optionsDict = CFDictionaryCreateMutable(NULL, 0,						&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);	CFDictionarySetValue(optionsDict, kLookupApplicationTypeKey, kApplicationTypeUser);	CFDictionarySetValue(optionsDict, kLookupAttributeKey, CFSTR("UIVPNPlugin"));	appDict = MobileInstallationLookup(optionsDict);	if (!isA_CFDictionary(appDict))		goto done;	count = CFDictionaryGetCount(appDict);	if (count > 0) {		keys = (const void * *)malloc(sizeof(CFTypeRef) * count);		values = (const void * *)malloc(sizeof(CFTypeRef) * count);		CFDictionaryGetKeysAndValues(appDict, keys, values);		for (i=0; i<count; i++) {			appinfo = CFDictionaryGetValue(values[i], CFSTR("UIVPNPlugin"));			if (appinfo) {				if (isA_CFString(appinfo)) {					nc_print_VPN_app_info((CFStringRef)appinfo, (CFDictionaryRef)values[i]);				}				else if (isA_CFArray(appinfo)) {					subtypecount = CFArrayGetCount((CFArrayRef)appinfo);					for(j=0; j<subtypecount; j++) {						vpntype = (CFStringRef)CFArrayGetValueAtIndex((CFArrayRef)appinfo, j);						nc_print_VPN_app_info(vpntype, (CFDictionaryRef)values[i]);					}				}			}		}	}done:	if (keys) free(keys);	if (values) free(values);	my_CFRelease(&optionsDict);	my_CFRelease(&appDict);	exit(0);}

extern pascal void CFQPropertyListShallowApplyFunction(CFPropertyListRef propList, 													   CFQPropertyListShallowApplierFunction func,													   void *context)	// See comment in header.{	assert(propList != NULL);	assert(func     != NULL);	// If this node is a dictionary, call "func" for each element.	//	// If this node is an array, call "func" for each element and 	// pass a CFNumber of the element's array index to its "key" 	// parameter.		if ( CFGetTypeID(propList) == CFDictionaryGetTypeID() ) {		CFIndex count;		CFIndex index;				count = CFDictionaryGetCount( (CFDictionaryRef) propList);				if (count > 0) {			const void **keys;						keys = (const void **) malloc( count * sizeof(const void *));			if (keys != NULL) {				CFDictionaryGetKeysAndValues( (CFDictionaryRef) propList, keys, NULL);								for (index = 0; index < count; index++) {					func(keys[index], CFDictionaryGetValue( (CFDictionaryRef) propList, keys[index]), context);				}				free(keys);			}		}	} else if ( CFGetTypeID(propList) == CFArrayGetTypeID() ) {		CFIndex count;		CFIndex index;				count = CFArrayGetCount( (CFArrayRef) propList);		for (index = 0; index < count; index++) {			CFNumberRef key;						key = CFNumberCreate(NULL, kCFNumberLongType, &index);			if (key != NULL) {				func(key, CFArrayGetValueAtIndex( (CFArrayRef) propList, index), context);				CFRelease(key);			}		}	} else {		assert(false);	}}

void _CFPreferencesDomainSetDictionary(CFPreferencesDomainRef domain, CFDictionaryRef dict) {    CFAllocatorRef alloc = __CFPreferencesAllocator();    CFDictionaryRef d = _CFPreferencesDomainDeepCopyDictionary(domain);    CFIndex idx, count = d ? CFDictionaryGetCount(d) : 0;    CFTypeRef *keys = (CFTypeRef *)CFAllocatorAllocate(alloc, count * sizeof(CFTypeRef), 0);    if (d) CFDictionaryGetKeysAndValues(d, keys, NULL);    for (idx = 0; idx < count; idx ++) {        _CFPreferencesDomainSet(domain, (CFStringRef)keys[idx], NULL);    }    CFAllocatorDeallocate(alloc, keys);    if (d) CFRelease(d);    if (dict && (count = CFDictionaryGetCount(dict)) != 0) {        CFStringRef *newKeys = (CFStringRef *)CFAllocatorAllocate(alloc, count * sizeof(CFStringRef), 0);        CFDictionaryGetKeysAndValues(dict, (const void **)newKeys, NULL);        for (idx = 0; idx < count; idx ++) {            CFStringRef key = newKeys[idx];            _CFPreferencesDomainSet(domain, key, (CFTypeRef)CFDictionaryGetValue(dict, key));        }            CFAllocatorDeallocate(alloc, newKeys);    }}

extern void GPDuplexClient_RemoveEveryObserver(GPDuplexClientRef client, void* observer, GPDuplexClientCallback callback) {	if (client != NULL) {		CFIndex count = CFDictionaryGetCount(client->observers);		CFNumberRef* typeNumbers = malloc(count * sizeof(CFNumberRef));		CFMutableSetRef* observerSets = malloc(count * sizeof(CFMutableSetRef));		CFDictionaryGetKeysAndValues(client->observers, (const void**)typeNumbers, (const void**)observerSets);				for (CFIndex i = 0; i < count; ++ i)			GPDuplexClient_RemoveObserverWithNumberAndObserverSet(client, observer, callback, typeNumbers[i], observerSets[i]);				free(typeNumbers);		free(observerSets);	}}

static void getVolatileKeysAndValues(CFAllocatorRef alloc, CFTypeRef context, void *domain, void **buf[], CFIndex *numKeyValuePairs) {    CFMutableDictionaryRef dict = (CFMutableDictionaryRef)domain;    CFIndex count = CFDictionaryGetCount(dict);    if (buf) {        void **values;        if ( count < *numKeyValuePairs ) {            values = *buf + count;            CFDictionaryGetKeysAndValues(dict, (const void **)*buf, (const void **)values);        } else if (alloc != kCFAllocatorNull) {            if (*buf) {                *buf = (void **)CFAllocatorReallocate(alloc, *buf, count * 2 * sizeof(void *), 0);            } else {                *buf = (void **)CFAllocatorAllocate(alloc, count*2*sizeof(void *), 0);            }            if (*buf) {                values = *buf + count;                CFDictionaryGetKeysAndValues(dict, (const void **)*buf, (const void **)values);            }        }    }    *numKeyValuePairs = count;}

CarbonEventHandler::~CarbonEventHandler(){	if (mHandlers != NULL) {		int count = CFDictionaryGetCount(mHandlers);		EventHandlerRef *theHandlers = (EventHandlerRef*) malloc(count * sizeof(EventHandlerRef));		CFDictionaryGetKeysAndValues(mHandlers, NULL, (const void **)theHandlers);				for (int i = 0; i < count; i++)			RemoveEventHandler(theHandlers[i]);		CFDictionaryRemoveAllValues(mHandlers);		CFRelease (mHandlers);		free(theHandlers);	}	}

QueryData genKextstat(QueryContext &context) {  QueryData results;  // Populate dict of kernel extensions.  CFDictionaryRef dict = OSKextCopyLoadedKextInfo(NULL, NULL);  CFIndex count = CFDictionaryGetCount(dict);  // Allocate memory for each extension parse.  auto values = (void **)malloc(sizeof(void *) * count);  CFDictionaryGetKeysAndValues(dict, nullptr, (const void **)values);  for (CFIndex j = 0; j < count; j++) {    // name    auto name = getKextString(values[j], CFSTR("CFBundleIdentifier"));    auto kextTag = getKextInt(values[j], CFSTR("OSBundleLoadTag"));    // Possibly limit expensive lookups.    if (!context.constraints["name"].matches(name)) {      continue;    }    if (!context.constraints["idx"].matches<int>(kextTag)) {      continue;    }    auto references = getKextInt(values[j], CFSTR("OSBundleRetainCount"));    // size    auto load_size = getKextBigInt(values[j], CFSTR("OSBundleLoadSize"));    auto wired_size = getKextBigInt(values[j], CFSTR("OSBundleWiredSize"));    auto version = getKextString(values[j], CFSTR("CFBundleVersion"));    // linked_against    auto linked = getKextLinked(values[j], CFSTR("OSBundleDependencies"));    Row r;    r["idx"] = INTEGER(kextTag);    r["refs"] = INTEGER(references);    r["size"] = BIGINT(load_size);    r["wired"] = BIGINT(wired_size);    r["name"] = name;    r["version"] = version;    r["linked_against"] = linked;    results.push_back(r);  }  CFRelease(dict);  free(values);  return results;}

void ResourceRequest::doUpdateResourceRequest(){    if (!m_cfRequest) {        *this = ResourceRequest();        return;    }    m_url = CFURLRequestGetURL(m_cfRequest.get());    m_cachePolicy = (ResourceRequestCachePolicy)CFURLRequestGetCachePolicy(m_cfRequest.get());    m_timeoutInterval = CFURLRequestGetTimeoutInterval(m_cfRequest.get());    m_firstPartyForCookies = CFURLRequestGetMainDocumentURL(m_cfRequest.get());    if (CFStringRef method = CFURLRequestCopyHTTPRequestMethod(m_cfRequest.get())) {        m_httpMethod = method;        CFRelease(method);    }    m_allowCookies = CFURLRequestShouldHandleHTTPCookies(m_cfRequest.get());    if (httpPipeliningEnabled())        m_priority = toResourceLoadPriority(wkGetHTTPPipeliningPriority(m_cfRequest.get()));    m_httpHeaderFields.clear();    if (CFDictionaryRef headers = CFURLRequestCopyAllHTTPHeaderFields(m_cfRequest.get())) {        CFIndex headerCount = CFDictionaryGetCount(headers);        Vector<const void*, 128> keys(headerCount);        Vector<const void*, 128> values(headerCount);        CFDictionaryGetKeysAndValues(headers, keys.data(), values.data());        for (int i = 0; i < headerCount; ++i)            m_httpHeaderFields.set((CFStringRef)keys[i], (CFStringRef)values[i]);        CFRelease(headers);    }    m_responseContentDispositionEncodingFallbackArray.clear();    RetainPtr<CFArrayRef> encodingFallbacks(AdoptCF, copyContentDispositionEncodingFallbackArray(m_cfRequest.get()));    if (encodingFallbacks) {        CFIndex count = CFArrayGetCount(encodingFallbacks.get());        for (CFIndex i = 0; i < count; ++i) {            CFStringEncoding encoding = reinterpret_cast<CFIndex>(CFArrayGetValueAtIndex(encodingFallbacks.get(), i));            if (encoding != kCFStringEncodingInvalidId)                m_responseContentDispositionEncodingFallbackArray.append(CFStringConvertEncodingToIANACharSetName(encoding));        }    }#if ENABLE(CACHE_PARTITIONING)    RetainPtr<CFStringRef> cachePartition(AdoptCF, static_cast<CFStringRef>(_CFURLRequestCopyProtocolPropertyForKey(m_cfRequest.get(), wkCachePartitionKey())));    if (cachePartition)        m_cachePartition = cachePartition.get();#endif}

static void getXMLKeysAndValues(CFAllocatorRef alloc, CFTypeRef context, void *xmlDomain, void **buf[], CFIndex *numKeyValuePairs) {    _CFXMLPreferencesDomain *domain = (_CFXMLPreferencesDomain *)xmlDomain;    CFIndex count;    __CFLock(&domain->_lock);    if (!domain->_domainDict) {        _loadXMLDomainIfStale((CFURLRef )context, domain);    }    count = CFDictionaryGetCount(domain->_domainDict);    if (buf) {        void **values;        if (count <= *numKeyValuePairs) {            values = *buf + count;            CFDictionaryGetKeysAndValues(domain->_domainDict, (const void **)*buf, (const void **)values);        } else if (alloc != kCFAllocatorNull) {	    *buf = (void**) CFAllocatorReallocate(alloc, (*buf ? *buf : NULL), count * 2 * sizeof(void *), 0);            if (*buf) {                values = *buf + count;                CFDictionaryGetKeysAndValues(domain->_domainDict, (const void **)*buf, (const void **)values);            }        }    }    *numKeyValuePairs = count;    __CFUnlock(&domain->_lock);}

static inline void setHeaderFields(CFMutableURLRequestRef request, const HTTPHeaderMap& requestHeaders) {    // Remove existing headers first, as some of them may no longer be present in the map.    RetainPtr<CFDictionaryRef> oldHeaderFields = adoptCF(CFURLRequestCopyAllHTTPHeaderFields(request));    CFIndex oldHeaderFieldCount = CFDictionaryGetCount(oldHeaderFields.get());    if (oldHeaderFieldCount) {        Vector<CFStringRef> oldHeaderFieldNames(oldHeaderFieldCount);        CFDictionaryGetKeysAndValues(oldHeaderFields.get(), reinterpret_cast<const void**>(&oldHeaderFieldNames[0]), 0);        for (CFIndex i = 0; i < oldHeaderFieldCount; ++i)            CFURLRequestSetHTTPHeaderFieldValue(request, oldHeaderFieldNames[i], 0);    }    for (const auto& header : requestHeaders)        CFURLRequestSetHTTPHeaderFieldValue(request, header.key.createCFString().get(), header.value.createCFString().get());}

static inline void setHeaderFields(CFMutableURLRequestRef request, const HTTPHeaderMap& requestHeaders) {    // Remove existing headers first, as some of them may no longer be present in the map.    RetainPtr<CFDictionaryRef> oldHeaderFields(AdoptCF, CFURLRequestCopyAllHTTPHeaderFields(request));    CFIndex oldHeaderFieldCount = CFDictionaryGetCount(oldHeaderFields.get());    if (oldHeaderFieldCount) {        Vector<CFStringRef> oldHeaderFieldNames(oldHeaderFieldCount);        CFDictionaryGetKeysAndValues(oldHeaderFields.get(), reinterpret_cast<const void**>(&oldHeaderFieldNames[0]), 0);        for (CFIndex i = 0; i < oldHeaderFieldCount; ++i)            CFURLRequestSetHTTPHeaderFieldValue(request, oldHeaderFieldNames[i], 0);    }    for (HTTPHeaderMap::const_iterator it = requestHeaders.begin(), end = requestHeaders.end(); it != end; ++it)        CFURLRequestSetHTTPHeaderFieldValue(request, it->key.string().createCFString().get(), it->value.createCFString().get());}

static VALUErsym_all_symbols(VALUE klass, SEL sel){    VALUE ary = rb_ary_new();    const long count = CFDictionaryGetCount(id_str);    if (count >= 0) {	const void **values = (const void **)malloc(sizeof(void *) * count);	CFDictionaryGetKeysAndValues(id_str, NULL, values);	for (long i = 0; i < count; i++) {	    rb_ary_push(ary, (VALUE)values[i]);	}	free(values);    }    return ary;}

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;}

//// Returns a malloced array of CSSM_RETURN values, with the length in numStatusCodes,// for the certificate specified by chain index in the given SecTrustRef.//// To match legacy behavior, the array actually allocates one element more than the// value of numStatusCodes; if the certificate is revoked, the additional element// at the end contains the CrlReason value.//// Caller must free the returned pointer.//static CSSM_RETURN *copyCssmStatusCodes(SecTrustRef trust,	unsigned int index, unsigned int *numStatusCodes){	if (!trust || !numStatusCodes) {		return NULL;	}	*numStatusCodes = 0;	CFArrayRef details = SecTrustCopyFilteredDetails(trust);	CFIndex chainLength = (details) ? CFArrayGetCount(details) : 0;	if (!(index < chainLength)) {		CFReleaseSafe(details);		return NULL;	}	CFDictionaryRef detail = (CFDictionaryRef)CFArrayGetValueAtIndex(details, index);	CFIndex ix, detailCount = CFDictionaryGetCount(detail);	*numStatusCodes = (unsigned int)detailCount;	// Allocate one more entry than we need; this is used to store a CrlReason	// at the end of the array.	CSSM_RETURN *statusCodes = (CSSM_RETURN*)malloc((detailCount+1) * sizeof(CSSM_RETURN));	statusCodes[*numStatusCodes] = 0;	const unsigned int resultmaplen = sizeof(cssmresultmap) / sizeof(resultmap_entry_t);	const void *keys[detailCount];	CFDictionaryGetKeysAndValues(detail, &keys[0], NULL);	for (ix = 0; ix < detailCount; ix++) {		CFStringRef key = (CFStringRef)keys[ix];		CSSM_RETURN statusCode = CSSM_OK;		for (unsigned int mapix = 0; mapix < resultmaplen; mapix++) {			CFStringRef str = (CFStringRef) cssmresultmap[mapix].checkstr;			if (CFStringCompare(str, key, 0) == kCFCompareEqualTo) {				statusCode = (CSSM_RETURN) cssmresultmap[mapix].resultcode;				break;			}		}		if (statusCode == CSSMERR_TP_CERT_REVOKED) {			SInt32 reason;			CFNumberRef number = (CFNumberRef)CFDictionaryGetValue(detail, key);			if (number && CFNumberGetValue(number, kCFNumberSInt32Type, &reason)) {				statusCodes[*numStatusCodes] = (CSSM_RETURN)reason;			}		}		statusCodes[ix] = statusCode;	}	CFReleaseSafe(details);	return statusCodes;}

static void __CFMessagePortDeallocate(CFTypeRef cf) {    CFMessagePortRef ms = (CFMessagePortRef)cf;    __CFMessagePortSetIsDeallocing(ms);    CFMessagePortInvalidate(ms);    // Delay cleanup of _replies until here so that invalidation during    // SendRequest does not cause _replies to disappear out from under that function.    if (NULL != ms->_replies) {	CFRelease(ms->_replies);    }    if (NULL != ms->_name) {	CFRelease(ms->_name);    }    if (NULL != ms->_port) {	if (__CFMessagePortExtraMachRef(ms)) {	    mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(ms->_port), MACH_PORT_RIGHT_SEND, -1);	    mach_port_mod_refs(mach_task_self(), CFMachPortGetPort(ms->_port), MACH_PORT_RIGHT_RECEIVE, -1);	}	CFMachPortInvalidate(ms->_port);	CFRelease(ms->_port);    }    // A remote message port for a local message port in the same process will get the    // same mach port, and the remote port will keep the mach port from being torn down,    // thus keeping the remote port from getting any sort of death notification and    // auto-invalidating; so we manually implement the 'auto-invalidation' here by    // tickling each remote port to check its state after any message port is destroyed,    // but most importantly after local message ports are destroyed.    __CFLock(&__CFAllMessagePortsLock);    CFMessagePortRef *remotePorts = NULL;    CFIndex cnt = 0;    if (NULL != __CFAllRemoteMessagePorts) {	cnt = CFDictionaryGetCount(__CFAllRemoteMessagePorts);	remotePorts = CFAllocatorAllocate(kCFAllocatorSystemDefault, cnt * sizeof(CFMessagePortRef), __kCFAllocatorGCScannedMemory);	CFDictionaryGetKeysAndValues(__CFAllRemoteMessagePorts, NULL, (const void **)remotePorts);	for (CFIndex idx = 0; idx < cnt; idx++) {	    CFRetain(remotePorts[idx]);	}    }    __CFUnlock(&__CFAllMessagePortsLock);    if (remotePorts) {	for (CFIndex idx = 0; idx < cnt; idx++) {	    // as a side-effect, this will auto-invalidate the CFMessagePort if the CFMachPort is invalid	    CFMessagePortIsValid(remotePorts[idx]);	    CFRelease(remotePorts[idx]);	}	CFAllocatorDeallocate(kCFAllocatorSystemDefault, remotePorts);    }}

void ResourceResponse::platformLazyInit(){    if (m_isUpToDate)        return;    m_isUpToDate = true;    if (m_isNull) {        ASSERT(!m_cfResponse.get());        return;    }    // FIXME: We may need to do MIME type sniffing here (unless that is done in CFURLResponseGetMIMEType).    m_url = CFURLResponseGetURL(m_cfResponse.get());    m_mimeType = CFURLResponseGetMIMEType(m_cfResponse.get());    m_expectedContentLength = CFURLResponseGetExpectedContentLength(m_cfResponse.get());    m_textEncodingName = CFURLResponseGetTextEncodingName(m_cfResponse.get());    m_lastModifiedDate = toTimeT(CFURLResponseGetLastModifiedDate(m_cfResponse.get()));    RetainPtr<CFStringRef> suggestedFilename(AdoptCF, CFURLResponseCopySuggestedFilename(m_cfResponse.get()));    m_suggestedFilename = suggestedFilename.get();    CFHTTPMessageRef httpResponse = CFURLResponseGetHTTPResponse(m_cfResponse.get());    if (httpResponse) {        m_httpStatusCode = CFHTTPMessageGetResponseStatusCode(httpResponse);        RetainPtr<CFStringRef> statusLine(AdoptCF, CFHTTPMessageCopyResponseStatusLine(httpResponse));        String statusText(statusLine.get());        int spacePos = statusText.find(' ');        // Remove the status code from the status text.        spacePos = statusText.find(' ', spacePos + 1);        statusText = statusText.substring(spacePos + 1);              m_httpStatusText = statusText;        RetainPtr<CFDictionaryRef> headers(AdoptCF, CFHTTPMessageCopyAllHeaderFields(httpResponse));        CFIndex headerCount = CFDictionaryGetCount(headers.get());        Vector<const void*, 128> keys(headerCount);        Vector<const void*, 128> values(headerCount);        CFDictionaryGetKeysAndValues(headers.get(), keys.data(), values.data());        for (int i = 0; i < headerCount; ++i)            m_httpHeaderFields.set((CFStringRef)keys[i], (CFStringRef)values[i]);    } else        m_httpStatusCode = 0;}

/*! Creates a CFArray object containing CFString objects with names of *  all of the targets in the discovery record. *  @param discoveryRec the discovery record. *  @return an array of strings with names of the targets in the record. */CFArrayRef iSCSIDiscoveryRecCreateArrayOfTargets(iSCSIDiscoveryRecRef discoveryRec){    // Validate input    if(!discoveryRec)        return NULL;        // Get all keys, which correspond to the targets    const CFIndex count = CFDictionaryGetCount(discoveryRec);    const void * keys[count];    CFDictionaryGetKeysAndValues(discoveryRec,keys,NULL);        CFArrayRef targets = CFArrayCreate(kCFAllocatorDefault,                                       keys,                                       count,                                       &kCFTypeArrayCallBacks);    return targets;}

void ResourceResponse::platformLazyInit(){    if (m_isUpToDate)        return;    m_isUpToDate = true;    if (m_isNull) {        ASSERT(!m_cfResponse.get());        return;    }    // FIXME: We may need to do MIME type sniffing here (unless that is done in CFURLResponseGetMIMEType).    m_url = CFURLResponseGetURL(m_cfResponse.get());    m_mimeType = CFURLResponseGetMIMEType(m_cfResponse.get());    m_expectedContentLength = CFURLResponseGetExpectedContentLength(m_cfResponse.get());    m_textEncodingName = CFURLResponseGetTextEncodingName(m_cfResponse.get());    // Workaround for <rdar://problem/8757088>, can be removed once that is fixed.    unsigned textEncodingNameLength = m_textEncodingName.length();    if (textEncodingNameLength >= 2 && m_textEncodingName[0U] == '"' && m_textEncodingName[textEncodingNameLength - 1] == '"')        m_textEncodingName = m_textEncodingName.substring(1, textEncodingNameLength - 2);    m_lastModifiedDate = toTimeT(CFURLResponseGetLastModifiedDate(m_cfResponse.get()));    RetainPtr<CFStringRef> suggestedFilename(AdoptCF, CFURLResponseCopySuggestedFilename(m_cfResponse.get()));    m_suggestedFilename = suggestedFilename.get();    CFHTTPMessageRef httpResponse = CFURLResponseGetHTTPResponse(m_cfResponse.get());    if (httpResponse) {        m_httpStatusCode = CFHTTPMessageGetResponseStatusCode(httpResponse);        RetainPtr<CFStringRef> statusLine(AdoptCF, CFHTTPMessageCopyResponseStatusLine(httpResponse));        m_httpStatusText = extractReasonPhraseFromHTTPStatusLine(statusLine.get());        RetainPtr<CFDictionaryRef> headers(AdoptCF, CFHTTPMessageCopyAllHeaderFields(httpResponse));        CFIndex headerCount = CFDictionaryGetCount(headers.get());        Vector<const void*, 128> keys(headerCount);        Vector<const void*, 128> values(headerCount);        CFDictionaryGetKeysAndValues(headers.get(), keys.data(), values.data());        for (int i = 0; i < headerCount; ++i)            m_httpHeaderFields.set((CFStringRef)keys[i], (CFStringRef)values[i]);    } else        m_httpStatusCode = 0;}

/* * Function: EAPOLClientConfigurationCopyProfiles * * Purpose: *   Get the list of defined profiles.   If there are no profiles defined, *   returns NULL. * * Returns: *   NULL if no profiles are defined, non-NULL non-empty array of profiles *   otherwise. */CFArrayRef /* of EAPOLClientProfileRef */EAPOLClientConfigurationCopyProfiles(EAPOLClientConfigurationRef cfg){    CFAllocatorRef		allocator = CFGetAllocator(cfg);    int				count;    CFArrayRef			profiles;    const void * *		values;    count = CFDictionaryGetCount(cfg->profiles);    if (count == 0) {	return (NULL);    }    values = (const void * *)malloc(sizeof(*values) * count);    CFDictionaryGetKeysAndValues(cfg->profiles, NULL, values);    profiles = CFArrayCreate(allocator, values, count, &kCFTypeArrayCallBacks);    free(values);    return (profiles);}

void printKextMatchProperty(    OSKextRef theKext,    CFStringRef propKey,    char lineEnd){    CFDictionaryRef personalitiesDict = NULL;    CFStringRef * names = NULL;    CFDictionaryRef * personalities = NULL;    CFIndex numPersonalities;    CFIndex i;    personalitiesDict = OSKextGetValueForInfoDictionaryKey(theKext,        CFSTR(kIOKitPersonalitiesKey));    if (!personalitiesDict) {        goto finish;    }    numPersonalities = CFDictionaryGetCount(personalitiesDict);    if (!numPersonalities) {        goto finish;    }    names = malloc(numPersonalities * sizeof(CFStringRef));    personalities = malloc(numPersonalities * sizeof(CFDictionaryRef));    if (!names || !personalities) {        goto finish;    }    CFDictionaryGetKeysAndValues(personalitiesDict, (const void **)names,        (const void **)personalities);    for (i = 0; i < numPersonalities; i++) {        CFTypeRef value = CFDictionaryGetValue(personalities[i], propKey);        if (value) {            printProperty(names[i], propKey, value, lineEnd);        }    }finish:    if (names)             free(names);    if (personalities)     free(personalities);    return;}

static CFArrayRefservice_order_copy_all(CFDictionaryRef services, CFArrayRef service_order){	const void *		keys_q[N_QUICK];	const void **		keys	= keys_q;	CFIndex			i;	CFIndex			n_order;	CFIndex			n_services;	CFMutableArrayRef	order;	// ensure that we process all services in order	n_services = isA_CFDictionary(services) ? CFDictionaryGetCount(services) : 0;	if (n_services == 0) {		// if no services		return NULL;	}	// ensure that we process all services in order	n_order = isA_CFArray(service_order) ? CFArrayGetCount(service_order) : 0;	if (n_order > 0) {		order = CFArrayCreateMutableCopy(NULL, 0, service_order);	} else {		order = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);	}	if (n_services > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {		keys = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);	}	CFDictionaryGetKeysAndValues(services, keys, NULL);	for (i = 0; i < n_services; i++) {		CFStringRef	serviceID	= (CFStringRef)keys[i];		if (!CFArrayContainsValue(order, CFRangeMake(0, n_order), serviceID)) {			CFArrayAppendValue(order, serviceID);			n_order++;		}	}	if (keys != keys_q) {		CFAllocatorDeallocate(NULL, keys);	}	return order;}

extern pascal void CFQPropertyListDeepApplyFunction(CFPropertyListRef propList, 													CFQPropertyListDeepApplierFunction func,													void *context)	// See comment in header.{	assert(propList != NULL);	assert(func     != NULL);		// Call "func" for this node.		func(propList, context);		// If this node is a dictionary or an array, call func for 	// each element.		if ( CFGetTypeID(propList) == CFDictionaryGetTypeID() ) {		CFIndex count;		CFIndex index;				count = CFDictionaryGetCount( (CFDictionaryRef) propList);		if (count > 0) {			const void **keys;			keys = (const void **) malloc( count * sizeof(const void *));			if (keys != NULL) {				CFDictionaryGetKeysAndValues( (CFDictionaryRef) propList, keys, NULL);								for (index = 0; index < count; index++) {					CFQPropertyListDeepApplyFunction(CFDictionaryGetValue( (CFDictionaryRef) propList, keys[index]), func, context);				}				free(keys);			}		}	} else if ( CFGetTypeID(propList) == CFArrayGetTypeID() ) {		CFIndex count;		long    index;				count = CFArrayGetCount( (CFArrayRef) propList);		for (index = 0; index < count; index++) {			CFQPropertyListDeepApplyFunction(CFArrayGetValueAtIndex( (CFArrayRef) propList, index), func, context);		}	}}

void CFPreferencesSetMultiple(CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFStringRef appName, CFStringRef user, CFStringRef host) {    CFPreferencesDomainRef domain;    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__);    if (keysToSet) __CFGenericValidateType(keysToSet, CFDictionaryGetTypeID());    if (keysToRemove) __CFGenericValidateType(keysToRemove, CFArrayGetTypeID());    __CFGenericValidateType(appName, CFStringGetTypeID());    __CFGenericValidateType(user, CFStringGetTypeID());    __CFGenericValidateType(host, CFStringGetTypeID());    CFTypeRef *keys = NULL;    CFTypeRef *values;    CFIndex numOfKeysToSet = 0;        domain = _CFPreferencesStandardDomain(appName, user, host);    if (!domain) return;    CFAllocatorRef alloc = CFGetAllocator(domain);        if (keysToSet && (count = CFDictionaryGetCount(keysToSet))) {        numOfKeysToSet = count;        keys = (CFTypeRef *)CFAllocatorAllocate(alloc, 2*count*sizeof(CFTypeRef), 0);        if (keys) {            values = &(keys[count]);            CFDictionaryGetKeysAndValues(keysToSet, keys, values);            for (idx = 0; idx < count; idx ++) {                _CFPreferencesDomainSet(domain, (CFStringRef)keys[idx], values[idx]);            }        }    }    if (keysToRemove && (count = CFArrayGetCount(keysToRemove))) {        for (idx = 0; idx < count; idx ++) {            CFStringRef removedKey = (CFStringRef)CFArrayGetValueAtIndex(keysToRemove, idx);            _CFPreferencesDomainSet(domain, removedKey, NULL);        }    }    _CFApplicationPreferencesDomainHasChanged(domain);        if(keys) CFAllocatorDeallocate(alloc, keys);}

void ResourceRequest::doUpdateResourceRequest(){    if (!m_cfRequest) {        *this = ResourceRequest();        return;    }    m_url = CFURLRequestGetURL(m_cfRequest.get());    m_cachePolicy = (ResourceRequestCachePolicy)CFURLRequestGetCachePolicy(m_cfRequest.get());    m_timeoutInterval = CFURLRequestGetTimeoutInterval(m_cfRequest.get());    m_firstPartyForCookies = CFURLRequestGetMainDocumentURL(m_cfRequest.get());    if (CFStringRef method = CFURLRequestCopyHTTPRequestMethod(m_cfRequest.get())) {        m_httpMethod = method;        CFRelease(method);    }    m_allowCookies = CFURLRequestShouldHandleHTTPCookies(m_cfRequest.get());    m_httpHeaderFields.clear();    if (CFDictionaryRef headers = CFURLRequestCopyAllHTTPHeaderFields(m_cfRequest.get())) {        CFIndex headerCount = CFDictionaryGetCount(headers);        Vector<const void*, 128> keys(headerCount);        Vector<const void*, 128> values(headerCount);        CFDictionaryGetKeysAndValues(headers, keys.data(), values.data());        for (int i = 0; i < headerCount; ++i)            m_httpHeaderFields.set((CFStringRef)keys[i], (CFStringRef)values[i]);        CFRelease(headers);    }    m_responseContentDispositionEncodingFallbackArray.clear();    RetainPtr<CFArrayRef> encodingFallbacks(AdoptCF, copyContentDispositionEncodingFallbackArray(m_cfRequest.get()));    if (encodingFallbacks) {        CFIndex count = CFArrayGetCount(encodingFallbacks.get());        for (CFIndex i = 0; i < count; ++i) {            CFStringEncoding encoding = reinterpret_cast<CFIndex>(CFArrayGetValueAtIndex(encodingFallbacks.get(), i));            if (encoding != kCFStringEncodingInvalidId)                m_responseContentDispositionEncodingFallbackArray.append(CFStringConvertEncodingToIANACharSetName(encoding));        }    }    m_httpBody = httpBodyFromRequest(m_cfRequest.get());}

void SFB::Audio::AttachedPicture::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);}

STATIC CFDictionaryRefexport_profiles(EAPOLClientConfigurationRef cfg){    int				count;    CFMutableDictionaryRef	dict;    int				i;    const void * *		values;    count = CFDictionaryGetCount(cfg->profiles);    dict = CFDictionaryCreateMutable(NULL, count,				     &kCFTypeDictionaryKeyCallBacks,				     &kCFTypeDictionaryValueCallBacks);    if (count == 0) {	/* return empty dict */	goto done;    }    values = (const void * *)malloc(sizeof(*values) * count);    CFDictionaryGetKeysAndValues(cfg->profiles, NULL, values);    for (i = 0; i < count; i++) {	EAPOLClientProfileRef	profile = (EAPOLClientProfileRef)values[i];	CFDictionaryRef		profile_dict;	CFStringRef		profileID;	profile_dict 	    = EAPOLClientProfileCreateDictAndProfileID(profile, &profileID);	if (profile_dict == NULL) {	    /* error, return NULL */	    my_CFRelease(&dict);	    break;	}	CFDictionarySetValue(dict, profileID, profile_dict);	CFRelease(profile_dict);	CFRelease(profileID);    }    free(values); done:    return (dict);}

VALUE rbcf_dict_convert_to_ruby(CFDictionaryRef dict_ref) {        CFIndex count = CFDictionaryGetCount(dict_ref);    CFIndex i;        CFTypeRef *keys = (CFTypeRef *)malloc(count * sizeof(CFTypeRef));    CFTypeRef *values = (CFTypeRef *)malloc(count * sizeof(CFTypeRef));    CFDictionaryGetKeysAndValues(dict_ref, (const void **)keys, (const void **)values);        VALUE hash = rb_hash_new();        for(i=0; i < count; ++i){        rb_hash_aset(hash, rbcf_string_convert_to_ruby(keys[i]), rbcf_plist_convert_to_ruby(values[i]));    }        free(keys);    free(values);    OBJ_TAINT(hash);        return hash;}

QMap<QString, QVariant> q_toVariantMap (const CFMutableDictionaryRef &dict){    Q_ASSERT(dict);    QMap<QString, QVariant> result;    const int count = CFDictionaryGetCount(dict);    QVarLengthArray<void *> keys(count);    QVarLengthArray<void *> values(count);    CFDictionaryGetKeysAndValues(dict,            const_cast<const void **>(keys.data()),            const_cast<const void **>(values.data()));    for (int i = 0; i < count; ++i) {        const QString key = q_toString((CFStringRef)keys[i]);        const QVariant value = q_toVariant((CFTypeRef)values[i]);        result[key] = value;    }    return result;}

//_____________________________________________________________________________//bool	AUScope::RestoreElementNames (CFDictionaryRef& inNameDict){	static char string[32];	//first we have to see if we have enough elements and if not create them	bool didAddElements = false;	unsigned int maxElNum = 0;		int dictSize = CFDictionaryGetCount(inNameDict);	CFStringRef * keys = (CFStringRef*)CA_malloc (dictSize * sizeof (CFStringRef));	CFDictionaryGetKeysAndValues (inNameDict, reinterpret_cast<const void**>(keys), NULL);	for (int i = 0; i < dictSize; i++)	{		unsigned int intKey;		CFStringGetCString (keys[i], string, 32, kCFStringEncodingASCII);		sscanf (string, "%u", &intKey);		if (UInt32(intKey) > maxElNum)			maxElNum = intKey;	}		if (maxElNum >= GetNumberOfElements()) {		SetNumberOfElements (maxElNum+1);		didAddElements = true;	}				// OK, now we have the number of elements that we need - lets restate their names	for (int i = 0; i < dictSize; i++)	{		CFStringRef elName = reinterpret_cast<CFStringRef>(CFDictionaryGetValue (inNameDict,  keys[i]));		int intKey;		CFStringGetCString (keys[i], string, 32, kCFStringEncodingASCII);		sscanf (string, "%d", &intKey);		GetElement (intKey)->SetName (elName);	}	free (keys);		return didAddElements;}