bool SetXiphCommentFromMetadata(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 void nc_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 VALUE rsym_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 CFArrayRef service_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 CFDictionaryRef export_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; }