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