bool getRawCookies(const Document*, const KURL& url, Vector<Cookie>& rawCookies) { rawCookies.clear(); CFHTTPCookieStorageRef cookieStorage = currentCookieStorage(); if (!cookieStorage) return false; RetainPtr<CFURLRef> urlCF(AdoptCF, url.createCFURL()); bool sendSecureCookies = url.protocolIs("https"); RetainPtr<CFArrayRef> cookiesCF(AdoptCF, CFHTTPCookieStorageCopyCookiesForURL(cookieStorage, urlCF.get(), sendSecureCookies)); CFIndex count = CFArrayGetCount(cookiesCF.get()); rawCookies.reserveCapacity(count); for (CFIndex i = 0; i < count; i++) { CFHTTPCookieRef cookie = (CFHTTPCookieRef)CFArrayGetValueAtIndex(cookiesCF.get(), i); String name = CFHTTPCookieGetName(cookie); String value = CFHTTPCookieGetValue(cookie); String domain = CFHTTPCookieGetDomain(cookie); String path = CFHTTPCookieGetPath(cookie); double expires = (CFDateGetAbsoluteTime(CFHTTPCookieGetExpiratonDate(cookie)) + kCFAbsoluteTimeIntervalSince1970) * 1000; bool httpOnly = CFHTTPCookieIsHTTPOnly(cookie); bool secure = CFHTTPCookieIsSecure(cookie); bool session = false; // FIXME: Need API for if a cookie is a session cookie. rawCookies.uncheckedAppend(Cookie(name, value, domain, path, expires, httpOnly, secure, session)); } return true; }
static VALUE convert2rb_type(CFTypeRef ref) { VALUE result = Qnil; double double_result; int int_result; long long_result; int i; if (ref) { if (CFGetTypeID(ref) == CFStringGetTypeID()) { result = cfstring2rbstr(ref); } else if (CFGetTypeID(ref) == CFDateGetTypeID()) { // 978307200.0 == (January 1, 2001 00:00 GMT) - (January 1, 1970 00:00 UTC) // CFAbsoluteTime => January 1, 2001 00:00 GMT // ruby Time => January 1, 1970 00:00 UTC double_result = (double) CFDateGetAbsoluteTime(ref) + 978307200; result = rb_funcall(rb_cTime, rb_intern("at"), 1, rb_float_new(double_result)); } else if (CFGetTypeID(ref) == CFArrayGetTypeID()) { result = rb_ary_new(); for (i = 0; i < CFArrayGetCount(ref); i++) { rb_ary_push(result, convert2rb_type(CFArrayGetValueAtIndex(ref, i))); } } else if (CFGetTypeID(ref) == CFNumberGetTypeID()) { if (CFNumberIsFloatType(ref)) { CFNumberGetValue(ref, CFNumberGetType(ref), &double_result); result = rb_float_new(double_result); } else { CFNumberGetValue(ref, CFNumberGetType(ref), &long_result); result = LONG2NUM(long_result); } } } return result; }
// Assumes the domain has already been locked static void _loadXMLDomainIfStale(CFURLRef url, _CFXMLPreferencesDomain *domain) { CFAllocatorRef alloc = __CFPreferencesAllocator(); int idx; if (domain->_domainDict) { CFDateRef modDate; CFAbsoluteTime modTime; CFURLRef testURL = url; if (CFDictionaryGetCount(domain->_domainDict) == 0) { // domain never existed; check the parent directory, not the child testURL = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR(".."), kCFURLPOSIXPathStyle, true, url); } modDate = (CFDateRef )CFURLCreatePropertyFromResource(alloc, testURL, kCFURLFileLastModificationTime, NULL); modTime = modDate ? CFDateGetAbsoluteTime(modDate) : 0.0; // free before possible return. we can test non-NULL of modDate but don't depend on contents after this. if (testURL != url) CFRelease(testURL); if (modDate) CFRelease(modDate); if (modDate != NULL && modTime < domain->_lastReadTime) { // We're up-to-date return; } } // We're out-of-date; destroy domainDict and reload if (domain->_domainDict) { CFRelease(domain->_domainDict); domain->_domainDict = NULL; } // We no longer lock on read; instead, we assume parse failures are because someone else is writing the file, and just try to parse again. If we fail 3 times in a row, we assume the file is corrupted. REW, 7/13/99 for (idx = 0; idx < 3; idx ++) { CFDataRef data; if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &data, NULL, NULL, NULL) || !data) { // Either a file system error (so we can't read the file), or an empty (or perhaps non-existant) file domain->_domainDict = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); break; } else { CFTypeRef pList = CFPropertyListCreateFromXMLData(alloc, data, kCFPropertyListImmutable, NULL); CFRelease(data); if (pList && CFGetTypeID(pList) == CFDictionaryGetTypeID()) { domain->_domainDict = CFDictionaryCreateMutableCopy(alloc, 0, (CFDictionaryRef)pList); CFRelease(pList); break; } else if (pList) { CFRelease(pList); } // Assume the file is being written; sleep for a short time (to allow the write to complete) then re-read __CFMilliSleep(150); } } if (!domain->_domainDict) { // Failed to ever load domain->_domainDict = CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); } domain->_lastReadTime = CFAbsoluteTimeGetCurrent(); }
SV* _org_warhound_mdi_Date2SV(CFTypeRef attrItem) { /* 978307200 is the number of seconds between 01 Jan 1970 GMT (the * Unix/Perl epoch) and 01 Jan 2001 GMT (the Core Foundation epoch) */ double perltime = 978307200; perltime += CFDateGetAbsoluteTime(attrItem); return newSVnv(perltime); }
void CFDateToCssmDate(CFDateRef date, char *outCssmDate) { CFTimeZoneRef timeZone = CFTimeZoneCreateWithTimeIntervalFromGMT(NULL, 0); CFGregorianDate gd = CFAbsoluteTimeGetGregorianDate(CFDateGetAbsoluteTime(date), timeZone); sprintf(outCssmDate, "%04d%02d%02d%02d%02d%02dZ", (int)gd.year, gd.month, gd.day, gd.hour, gd.minute, (unsigned int)gd.second); CFRelease(timeZone); }
static void schedulePowerEvent(PowerEventBehavior *behave) { static CFRunLoopTimerContext tmr_context = {0,0,0,0,0}; CFAbsoluteTime fire_time = 0.0; CFDictionaryRef upcoming = NULL; CFDateRef temp_date = NULL; if(behave->timer) { CFRunLoopTimerInvalidate(behave->timer); CFRelease(behave->timer); behave->timer = 0; } // find upcoming time upcoming = copyEarliestUpcoming(behave); if(!upcoming) { // No scheduled events if (behave->noScheduledEventCallout) { (*behave->noScheduledEventCallout)(NULL); } return; } /* * Perform any necessary actions at schedulePowerEvent time */ if ( behave->scheduleNextCallout ) { (*behave->scheduleNextCallout)(upcoming); } if (behave->currentEvent) { CFRelease(behave->currentEvent); } behave->currentEvent = (CFDictionaryRef)upcoming; tmr_context.info = (void *)behave; temp_date = _getScheduledEventDate(upcoming); if(!temp_date) goto exit; fire_time = CFDateGetAbsoluteTime(temp_date); behave->timer = CFRunLoopTimerCreate(0, fire_time, 0.0, 0, 0, handleTimerExpiration, &tmr_context); if(behave->timer) { CFRunLoopAddTimer( CFRunLoopGetCurrent(), behave->timer, kCFRunLoopDefaultMode); } exit: return; }
static void printObj(CFPropertyListRef obj, struct printContext* c) { CFTypeID typeID = CFGetTypeID(obj); if (typeID == _CFKeyedArchiverUIDGetTypeID()) { unsigned uid = _CFKeyedArchiverUIDGetValue(obj); CFPropertyListRef refObj = CFArrayGetValueAtIndex(c->objs, uid); if (CFEqual(refObj, CFSTR("$null"))) printf("nil"); else if (c->refCount[uid] > 1 && isComplexObj(refObj)) printf("{CF$UID = %u;}", uid); else printObj(refObj, c); } else if (typeID == CFArrayGetTypeID()) { printf("(\n"); ++ c->tabs; CFArrayApplyFunction(obj, CFRangeMake(0, CFArrayGetCount(obj)), (CFArrayApplierFunction)&printObjAsArrayEntry, c); -- c->tabs; for (unsigned i = 0; i < c->tabs; ++ i) printf("\t"); printf(")"); } else if (typeID == CFDictionaryGetTypeID()) { CFStringRef className = CFDictionaryGetValue(obj, CFSTR("$classname")); if (className != NULL) printObjAsClassName(className); else { printf("{\n"); ++ c->tabs; CFIndex dictCount = CFDictionaryGetCount(obj); struct dictionarySorterContext sc; sc.keys = malloc(sizeof(CFStringRef)*dictCount); sc.values = malloc(sizeof(CFPropertyListRef)*dictCount); unsigned* mapping = malloc(sizeof(unsigned)*dictCount); for (unsigned i = 0; i < dictCount; ++ i) mapping[i] = i; CFDictionaryGetKeysAndValues(obj, (const void**)sc.keys, sc.values); qsort_r(mapping, dictCount, sizeof(unsigned), &sc, (int(*)(void*,const void*,const void*))&dictionaryComparer); for (unsigned i = 0; i < dictCount; ++ i) printObjAsDictionaryEntry(sc.keys[mapping[i]], sc.values[mapping[i]], c); free(mapping); free(sc.keys); free(sc.values); -- c->tabs; for (unsigned i = 0; i < c->tabs; ++ i) printf("\t"); printf("}"); } } else if (typeID == CFDataGetTypeID()) printObjAsData(obj); else if (typeID == CFNumberGetTypeID()) printObjAsNumber(obj); else if (typeID == CFStringGetTypeID()) printObjAsString(obj); else if (typeID == CFBooleanGetTypeID()) printf(CFBooleanGetValue(obj) ? "true" : "false"); else if (typeID == CFDateGetTypeID()) printf("/*date*/ %0.09g", CFDateGetAbsoluteTime(obj)); }
/** * Get the value of a #PLIST_DATE node. * This function does nothing if node is not of type #PLIST_DATE * * @param node the node * @param sec a pointer to an int32_t variable. Represents the number of seconds since 01/01/2001. * @param usec a pointer to an int32_t variable. Represents the number of microseconds */ void plist_get_date_val(plist_t node, int32_t * sec, int32_t * usec) { assert(CFGetTypeID(node) == CFDateGetTypeID()); CFAbsoluteTime abstime = CFDateGetAbsoluteTime((CFDateRef) node); abstime += 978307200.0; *sec = (int32_t) abstime; abstime = fabs(abstime); *usec = (int32_t) ((abstime - floor(abstime)) * 1000000); }
__private_extern__ CFTimeInterval getEarliestRequestAutoWake(void) { CFDictionaryRef one_event = NULL; CFDateRef event_date = NULL; CFTimeInterval absTime = 0.0; if (!(one_event = copyEarliestUpcoming(&wakeBehavior))) { return 0.0; } if (!(event_date = _getScheduledEventDate(one_event))) { return 0.0; } absTime = CFDateGetAbsoluteTime(event_date); CFRelease(one_event); return absTime; }
void extractQuarantineProperty(const std::string &table_key_name, CFTypeRef property, const std::string &path, QueryData &results) { std::string value; if (CFGetTypeID(property) == CFStringGetTypeID()) { value = stringFromCFString((CFStringRef)property); } else if (CFGetTypeID(property) == CFDateGetTypeID()) { auto unix_time = CFDateGetAbsoluteTime((CFDateRef)property) + kCFAbsoluteTimeIntervalSince1970; value = INTEGER(std::llround(unix_time)); } else if (CFGetTypeID(property) == CFURLGetTypeID()) { value = stringFromCFString(CFURLGetString((CFURLRef)property)); } setRow(results, path, table_key_name, value); }
void genOSXPrefValues(const CFTypeRef& value, const Row& base, QueryData& results, size_t depth) { if (value == nullptr) { return; } // Since we recurse when parsing Arrays/Dicts, monitor stack limits. if (++depth > kPreferenceDepthLimit) { TLOG << "The macOS preference: " << base.at("domain") << " exceeded subkey depth limit: " << kPreferenceDepthLimit; return; } // Emit a string representation for each preference type. Row r = base; if (CFGetTypeID(value) == CFNumberGetTypeID()) { r["value"] = stringFromCFNumber(static_cast<CFDataRef>(value)); } else if (CFGetTypeID(value) == CFStringGetTypeID()) { r["value"] = stringFromCFString(static_cast<CFStringRef>(value)); } else if (CFGetTypeID(value) == CFDateGetTypeID()) { auto unix_time = CFDateGetAbsoluteTime(static_cast<CFDateRef>(value)) + kCFAbsoluteTimeIntervalSince1970; r["value"] = boost::lexical_cast<std::string>(std::llround(unix_time)); } else if (CFGetTypeID(value) == CFBooleanGetTypeID()) { r["value"] = (CFBooleanGetValue(static_cast<CFBooleanRef>(value)) == TRUE) ? "true" : "false"; } else if (CFGetTypeID(value) == CFDataGetTypeID()) { // Do not include data preferences. } else if (CFGetTypeID(value) == CFArrayGetTypeID()) { genOSXListPref(static_cast<CFArrayRef>(value), base, results, depth); return; } else if (CFGetTypeID(value) == CFDictionaryGetTypeID()) { // Generate a row for each hash key. TRowResults trow(base, results, depth); CFDictionaryApplyFunction( static_cast<CFDictionaryRef>(value), &genOSXHashPref, &trow); return; } results.push_back(std::move(r)); }
static void cf_hash_to_rb_hash(const void *raw_key, const void * raw_value, void *ctx){ CFTypeRef value = (CFTypeRef)raw_value; CFStringRef key = (CFStringRef)raw_key; VALUE rubyValue = Qnil; VALUE hash = (VALUE)ctx; if(CFStringGetTypeID() == CFGetTypeID(value)){ rubyValue = cfstring_to_rb_string((CFStringRef)value); } else if(CFDataGetTypeID() == CFGetTypeID(value)){ CFDataRef data = (CFDataRef)value; rubyValue = rb_enc_str_new((const char*)CFDataGetBytePtr(data),CFDataGetLength(data), rb_ascii8bit_encoding()); } else if(CFBooleanGetTypeID() == CFGetTypeID(value)){ Boolean booleanValue = CFBooleanGetValue(value); rubyValue = booleanValue ? Qtrue : Qfalse; } else if(CFNumberGetTypeID() == CFGetTypeID(value)){ if(CFNumberIsFloatType(value)) { double doubleValue; CFNumberGetValue(value, kCFNumberDoubleType, &doubleValue); rubyValue = rb_float_new(doubleValue); }else{ long long longValue; CFNumberGetValue(value, kCFNumberLongLongType, &longValue); rubyValue = LL2NUM(longValue); } } else if (CFDateGetTypeID() == CFGetTypeID(value)){ CFDateRef date = (CFDateRef) value; CFAbsoluteTime abs_time = CFDateGetAbsoluteTime(date); double secondsSinceUnixEpoch = abs_time + kCFAbsoluteTimeIntervalSince1970; time_t seconds = (time_t)secondsSinceUnixEpoch; long usec = (secondsSinceUnixEpoch - seconds) * 1000000; rubyValue = rb_time_new((time_t)secondsSinceUnixEpoch, usec); } if(!NIL_P(rubyValue)){ rb_hash_aset(hash, cfstring_to_rb_string(key), rubyValue); } }
void printCFDate( CFDateRef dateRef) { CFAbsoluteTime absTime = CFDateGetAbsoluteTime(dateRef); if(absTime == 0.0) { printf("<<Malformed CFDateeRef>>\n"); return; } CFGregorianDate gregDate = CFAbsoluteTimeGetGregorianDate(absTime, NULL); const char *month = "Unknown"; if((gregDate.month > 12) || (gregDate.month <= 0)) { printf("Huh? GregDate.month > 11. These amps only GO to 11.\n"); } else { month = months[gregDate.month - 1]; } printf("%s %d, %ld %02d:%02d", month, gregDate.day, gregDate.year, gregDate.hour, gregDate.minute); }
bool ReceiptsDb::getInstalledPackageInfo(const char* identifier, ReceiptsDb::InstalledPackageInfo& info) { std::string path; CFDataRef data; CFDateRef date; CFDictionaryRef plist; std::unique_ptr<Reader> fileReader; std::unique_ptr<UInt8[]> fileData; path = getReceiptsPath(identifier, ".plist"); if (::access(path.c_str(), F_OK) != 0) return false; fileReader.reset(new FileReader(path)); fileData.reset(new UInt8[fileReader->length()]); if (fileReader->read(fileData.get(), fileReader->length(), 0) != fileReader->length()) throw std::runtime_error("Short read in getInstalledPackageInfo()"); data = CFDataCreate(nullptr, fileData.get(), fileReader->length()); fileData.reset(nullptr); plist = (CFDictionaryRef) CFPropertyListCreateWithData(nullptr, data, kCFPropertyListImmutable, nullptr, nullptr); CFRelease(data); if (plist == nullptr) throw std::runtime_error("Failed to parse plist in getInstalledPackageInfo()"); info.identifier = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("PackageIdentifier"))); info.version = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("PackageVersion"))); info.prefixPath = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("InstallPrefixPath"))); info.installProcessName = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("InstallProcessName"))); info.packageFileName = cfstring2stdstring((CFStringRef) CFDictionaryGetValue(plist, CFSTR("PackageFileName"))); date = (CFDateRef) CFDictionaryGetValue(plist, CFSTR("InstallDate")); info.installDate = CFDateGetAbsoluteTime(date); CFRelease(plist); return true; }
/* AUDIT[securityd](done): args_in (ok) is a caller provided dictionary, only its cf type has been checked. */ OSStatus SecTrustServerEvaluateAsync(CFDictionaryRef args_in, SecPathBuilderCompleted completed, const void *userData) { OSStatus status = paramErr; CFArrayRef certificates = NULL, anchors = NULL, policies = NULL; /* Proccess incoming arguments. */ CFArrayRef certificatesData = (CFArrayRef)CFDictionaryGetValue(args_in, kSecTrustCertificatesKey); require_quiet(certificatesData && CFGetTypeID(certificatesData) == CFArrayGetTypeID(), errOut); certificates = SecCertificateDataArrayCopyArray(certificatesData); require_quiet(certificates && CFGetTypeID(certificates) == CFArrayGetTypeID() && CFArrayGetCount(certificates) > 0, errOut); CFArrayRef anchorsData = (CFArrayRef)CFDictionaryGetValue(args_in, kSecTrustAnchorsKey); if (anchorsData) { require_quiet(CFGetTypeID(anchorsData) == CFArrayGetTypeID(), errOut); anchors = SecCertificateDataArrayCopyArray(anchorsData); } bool anchorsOnly = CFDictionaryContainsKey(args_in, kSecTrustAnchorsOnlyKey); CFArrayRef serializedPolicies = (CFArrayRef)CFDictionaryGetValue(args_in, kSecTrustPoliciesKey); if (serializedPolicies) { require_quiet(CFGetTypeID(serializedPolicies) == CFArrayGetTypeID(), errOut); policies = SecPolicyArrayDeserialize(serializedPolicies); } CFDateRef verifyDate = (CFDateRef)CFDictionaryGetValue(args_in, kSecTrustVerifyDateKey); require_quiet(verifyDate && CFGetTypeID(verifyDate) == CFDateGetTypeID(), errOut); CFAbsoluteTime verifyTime = CFDateGetAbsoluteTime(verifyDate); /* Call the actual evaluator function. */ SecPathBuilderRef builder = SecPathBuilderCreate(certificates, anchors, anchorsOnly, policies, verifyTime, completed, userData); status = SecPathBuilderStep(builder) ? errSecWaitForCallback : noErr; errOut: CFReleaseSafe(policies); CFReleaseSafe(anchors); CFReleaseSafe(certificates); return status; }
void CFCalendarSetGregorianStartDate(CFCalendarRef calendar, CFDateRef date) { CF_OBJC_FUNCDISPATCHV(CFCalendarGetTypeID(), void, calendar, _setGregorianStartDate:date); __CFGenericValidateType(calendar, CFCalendarGetTypeID()); if (date) __CFGenericValidateType(date, CFDateGetTypeID()); if (!calendar->_cal) __CFCalendarSetupCal(calendar); if (!calendar->_cal) return; if (!date) { UErrorCode status = U_ZERO_ERROR; UCalendar *cal = __CFCalendarCreateUCalendar(calendar->_identifier, calendar->_localeID, calendar->_tz); UDate udate = cal ? ucal_getGregorianChange(cal, &status) : 0; if (cal && U_SUCCESS(status)) { status = U_ZERO_ERROR; if (calendar->_cal) ucal_setGregorianChange(calendar->_cal, udate, &status); } if (cal) ucal_close(cal); } else { CFAbsoluteTime at = CFDateGetAbsoluteTime(date); UDate udate = (at + kCFAbsoluteTimeIntervalSince1970) * 1000.0; UErrorCode status = U_ZERO_ERROR; if (calendar->_cal) ucal_setGregorianChange(calendar->_cal, udate, &status); } }
static QVariant q_toVariant(const CFTypeRef &obj) { const CFTypeID typeId = CFGetTypeID(obj); if (typeId == CFStringGetTypeID()) return QVariant(q_toString(static_cast<const CFStringRef>(obj))); if (typeId == CFNumberGetTypeID()) { const CFNumberRef num = static_cast<const CFNumberRef>(obj); const CFNumberType type = CFNumberGetType(num); switch (type) { case kCFNumberSInt8Type: return qVariantFromValue(convertCFNumber<char>(num, type)); case kCFNumberSInt16Type: return qVariantFromValue(convertCFNumber<qint16>(num, type)); case kCFNumberSInt32Type: return qVariantFromValue(convertCFNumber<qint32>(num, type)); case kCFNumberSInt64Type: return qVariantFromValue(convertCFNumber<qint64>(num, type)); case kCFNumberCharType: return qVariantFromValue(convertCFNumber<uchar>(num, type)); case kCFNumberShortType: return qVariantFromValue(convertCFNumber<short>(num, type)); case kCFNumberIntType: return qVariantFromValue(convertCFNumber<int>(num, type)); case kCFNumberLongType: return qVariantFromValue(convertCFNumber<long>(num, type)); case kCFNumberLongLongType: return qVariantFromValue(convertCFNumber<long long>(num, type)); case kCFNumberFloatType: return qVariantFromValue(convertCFNumber<float>(num, type)); case kCFNumberDoubleType: return qVariantFromValue(convertCFNumber<double>(num, type)); default: if (CFNumberIsFloatType(num)) return qVariantFromValue(convertCFNumber<double>(num, kCFNumberDoubleType)); return qVariantFromValue(convertCFNumber<quint64>(num, kCFNumberLongLongType)); } } if (typeId == CFDateGetTypeID()) { QDateTime dt; dt.setTime_t(uint(kCFAbsoluteTimeIntervalSince1970)); return dt.addSecs(int(CFDateGetAbsoluteTime(static_cast<const CFDateRef>(obj)))); } if (typeId == CFDataGetTypeID()) { const CFDataRef cfdata = static_cast<const CFDataRef>(obj); return QByteArray(reinterpret_cast<const char *>(CFDataGetBytePtr(cfdata)), CFDataGetLength(cfdata)); } if (typeId == CFBooleanGetTypeID()) return QVariant(bool(CFBooleanGetValue(static_cast<const CFBooleanRef>(obj)))); if (typeId == CFArrayGetTypeID()) { const CFArrayRef cfarray = static_cast<const CFArrayRef>(obj); QList<QVariant> list; CFIndex size = CFArrayGetCount(cfarray); bool metNonString = false; for (CFIndex i = 0; i < size; ++i) { QVariant value = q_toVariant(CFArrayGetValueAtIndex(cfarray, i)); if (value.type() != QVariant::String) metNonString = true; list << value; } if (metNonString) return list; else return QVariant(list).toStringList(); } if (typeId == CFDictionaryGetTypeID()) { const CFDictionaryRef cfdict = static_cast<const CFDictionaryRef>(obj); const CFTypeID arrayTypeId = CFArrayGetTypeID(); int size = int(CFDictionaryGetCount(cfdict)); QVarLengthArray<CFPropertyListRef> keys(size); QVarLengthArray<CFPropertyListRef> values(size); CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data()); QMultiMap<QString, QVariant> map; for (int i = 0; i < size; ++i) { QString key = q_toString(static_cast<const CFStringRef>(keys[i])); if (CFGetTypeID(values[i]) == arrayTypeId) { const CFArrayRef cfarray = static_cast<const CFArrayRef>(values[i]); CFIndex arraySize = CFArrayGetCount(cfarray); for (CFIndex j = arraySize - 1; j >= 0; --j) map.insert(key, q_toVariant(CFArrayGetValueAtIndex(cfarray, j))); } else { map.insert(key, q_toVariant(values[i])); } } return map; } return QVariant(); }
uint8_t* der_encode_date(CFDateRef date, CFErrorRef *error, const uint8_t *der, uint8_t *der_end) { return der_encode_generalizedtime(CFDateGetAbsoluteTime(date), error, der, der_end); }
size_t der_sizeof_date(CFDateRef date, CFErrorRef *error) { return der_sizeof_generalizedtime(CFDateGetAbsoluteTime(date), error); }
/* * Function: DHCPLeaseCreateWithDictionary * Purpose: * Instantiate a new DHCPLease structure corresponding to the given * dictionary. Validates that required properties are present, * returns NULL if those checks fail. */ static DHCPLeaseRef DHCPLeaseCreateWithDictionary(CFDictionaryRef dict, bool is_wifi) { CFDataRef hwaddr_data; dhcp_lease_time_t lease_time; DHCPLeaseRef lease_p; CFDataRef pkt_data; CFRange pkt_data_range; struct in_addr * router_p; CFStringRef ssid = NULL; CFDateRef start_date; dhcp_lease_time_t t1_time; dhcp_lease_time_t t2_time; /* get the lease start time */ start_date = CFDictionaryGetValue(dict, kLeaseStartDate); if (isA_CFDate(start_date) == NULL) { goto failed; } /* get the packet data */ pkt_data = CFDictionaryGetValue(dict, kPacketData); if (isA_CFData(pkt_data) == NULL) { goto failed; } /* if Wi-Fi, get the SSID */ if (is_wifi) { ssid = CFDictionaryGetValue(dict, kSSID); if (isA_CFString(ssid) == NULL) { goto failed; } } pkt_data_range.location = 0; pkt_data_range.length = CFDataGetLength(pkt_data); if (pkt_data_range.length < sizeof(struct dhcp)) { goto failed; } lease_p = (DHCPLeaseRef) malloc(offsetof(DHCPLease, pkt) + pkt_data_range.length); bzero(lease_p, offsetof(DHCPLease, pkt)); /* copy the packet data */ CFDataGetBytes(pkt_data, pkt_data_range, lease_p->pkt); lease_p->pkt_length = (int)pkt_data_range.length; /* get the lease information and router IP address */ lease_p->lease_start = (absolute_time_t)CFDateGetAbsoluteTime(start_date); { /* parse/retrieve options */ dhcpol_t options; (void)dhcpol_parse_packet(&options, (void *)lease_p->pkt, (int)pkt_data_range.length, NULL); dhcp_get_lease_from_options(&options, &lease_time, &t1_time, &t2_time); router_p = dhcp_get_router_from_options(&options, lease_p->our_ip); dhcpol_free(&options); } lease_p->lease_length = lease_time; /* get the IP address */ /* ALIGN: lease_p->pkt is aligned, cast ok. */ lease_p->our_ip = ((struct dhcp *)(void *)lease_p->pkt)->dp_yiaddr; /* get the router information */ if (router_p != NULL) { CFRange hwaddr_range; lease_p->router_ip = *router_p; /* get the router hardware address */ hwaddr_data = CFDictionaryGetValue(dict, kRouterHardwareAddress); hwaddr_range.length = 0; if (isA_CFData(hwaddr_data) != NULL) { hwaddr_range.length = CFDataGetLength(hwaddr_data); } if (hwaddr_range.length > 0) { hwaddr_range.location = 0; if (hwaddr_range.length > sizeof(lease_p->router_hwaddr)) { hwaddr_range.length = sizeof(lease_p->router_hwaddr); } lease_p->router_hwaddr_length = (int)hwaddr_range.length; CFDataGetBytes(hwaddr_data, hwaddr_range, lease_p->router_hwaddr); } } if (ssid != NULL) { CFRetain(ssid); lease_p->ssid = ssid; } return (lease_p); failed: return (NULL); }
// // Contemplate the object-to-be-signed and set up the Signer state accordingly. // void SecCodeSigner::Signer::prepare(SecCSFlags flags) { // get the Info.plist out of the rep for some creative defaulting CFRef<CFDictionaryRef> infoDict; if (CFRef<CFDataRef> infoData = rep->component(cdInfoSlot)) infoDict.take(makeCFDictionaryFrom(infoData)); // work out the canonical identifier identifier = state.mIdentifier; if (identifier.empty()) { identifier = rep->recommendedIdentifier(state); if (identifier.find('.') == string::npos) identifier = state.mIdentifierPrefix + identifier; if (identifier.find('.') == string::npos && state.isAdhoc()) identifier = identifier + "-" + uniqueName(); secdebug("signer", "using default identifier=%s", identifier.c_str()); } else secdebug("signer", "using explicit identifier=%s", identifier.c_str()); // work out the CodeDirectory flags word if (state.mCdFlagsGiven) { cdFlags = state.mCdFlags; secdebug("signer", "using explicit cdFlags=0x%x", cdFlags); } else { cdFlags = 0; if (infoDict) if (CFTypeRef csflags = CFDictionaryGetValue(infoDict, CFSTR("CSFlags"))) { if (CFGetTypeID(csflags) == CFNumberGetTypeID()) { cdFlags = cfNumber<uint32_t>(CFNumberRef(csflags)); secdebug("signer", "using numeric cdFlags=0x%x from Info.plist", cdFlags); } else if (CFGetTypeID(csflags) == CFStringGetTypeID()) { cdFlags = cdTextFlags(cfString(CFStringRef(csflags))); secdebug("signer", "using text cdFlags=0x%x from Info.plist", cdFlags); } else MacOSError::throwMe(errSecCSBadDictionaryFormat); } } if (state.mSigner == SecIdentityRef(kCFNull)) // ad-hoc signing requested... cdFlags |= kSecCodeSignatureAdhoc; // ... so note that // prepare the resource directory, if any string rpath = rep->resourcesRootPath(); if (!rpath.empty()) { // explicitly given resource rules always win CFCopyRef<CFDictionaryRef> resourceRules = state.mResourceRules; // embedded resource rules come next if (!resourceRules && infoDict) if (CFTypeRef spec = CFDictionaryGetValue(infoDict, _kCFBundleResourceSpecificationKey)) { if (CFGetTypeID(spec) == CFStringGetTypeID()) if (CFRef<CFDataRef> data = cfLoadFile(rpath + "/" + cfString(CFStringRef(spec)))) if (CFDictionaryRef dict = makeCFDictionaryFrom(data)) resourceRules.take(dict); if (!resourceRules) // embedded rules present but unacceptable MacOSError::throwMe(errSecCSResourceRulesInvalid); } // finally, ask the DiskRep for its default if (!resourceRules) resourceRules.take(rep->defaultResourceRules(state)); // build the resource directory ResourceBuilder resources(rpath, cfget<CFDictionaryRef>(resourceRules, "rules"), digestAlgorithm()); rep->adjustResources(resources); // DiskRep-specific adjustments CFRef<CFDictionaryRef> rdir = resources.build(); resourceDirectory.take(CFPropertyListCreateXMLData(NULL, rdir)); } // screen and set the signing time CFAbsoluteTime now = CFAbsoluteTimeGetCurrent(); if (state.mSigningTime == CFDateRef(kCFNull)) { signingTime = 0; // no time at all } else if (!state.mSigningTime) { signingTime = now; // default } else { CFAbsoluteTime time = CFDateGetAbsoluteTime(state.mSigningTime); if (time > now) // not allowed to post-date a signature MacOSError::throwMe(errSecCSBadDictionaryFormat); signingTime = time; } pagesize = state.mPageSize ? cfNumber<size_t>(state.mPageSize) : rep->pageSize(state); // Timestamping setup CFRef<SecIdentityRef> mTSAuth; // identity for client-side authentication to the Timestamp server }
// // Here is where backward compatibility gets ugly. CSSM_TP_APPLE_EVIDENCE_INFO does not exist // in the unified SecTrust world. Unfortunately, some clients are still calling legacy APIs // (e.g. SecTrustGetResult) and grubbing through the info for StatusBits and StatusCodes. // SecTrustGetEvidenceInfo builds the legacy evidence info structure as needed, and returns // a pointer to it. The evidence data is allocated here and set in the _legacy_* fields // of the TSecTrust; the trust object subsequently owns it. The returned pointer is expected // to be valid for the lifetime of the SecTrustRef, or until the trust parameters are changed, // which would force re-evaluation. // static CSSM_TP_APPLE_EVIDENCE_INFO * SecTrustGetEvidenceInfo(SecTrustRef trust) { TSecTrust *secTrust = (TSecTrust *)trust; if (!secTrust) { return NULL; } if (secTrust->_trustResult != kSecTrustResultInvalid && secTrust->_legacy_info_array) { // we've already got valid evidence info, return it now. return (CSSM_TP_APPLE_EVIDENCE_INFO *)secTrust->_legacy_info_array; } // Getting the count implicitly evaluates the chain if necessary. CFIndex idx, count = SecTrustGetCertificateCount(trust); CFArrayRef inputCertArray = SecTrustCopyInputCertificates(trust); CFArrayRef inputAnchorArray = SecTrustCopyInputAnchors(trust); CFIndex inputCertIdx, inputCertCount = (inputCertArray) ? CFArrayGetCount(inputCertArray) : 0; CFIndex inputAnchorIdx, inputAnchorCount = (inputAnchorArray) ? CFArrayGetCount(inputAnchorArray) : 0; CSSM_TP_APPLE_EVIDENCE_INFO *infoArray = (CSSM_TP_APPLE_EVIDENCE_INFO *)calloc(count, sizeof(CSSM_TP_APPLE_EVIDENCE_INFO)); CSSM_RETURN *statusArray = NULL; unsigned int numStatusCodes = 0; // Set status codes for each certificate in the constructed chain for (idx=0; idx < count; idx++) { SecCertificateRef cert = SecTrustGetCertificateAtIndex(trust, idx); if (!cert) { continue; } CSSM_TP_APPLE_EVIDENCE_INFO *evInfo = &infoArray[idx]; /* first the booleans (StatusBits flags) */ CFAbsoluteTime now = CFAbsoluteTimeGetCurrent(); if (secTrust->_verifyDate) { now = CFDateGetAbsoluteTime(secTrust->_verifyDate); } CFAbsoluteTime na = SecCertificateNotValidAfter(cert); if (na < now) { evInfo->StatusBits |= CSSM_CERT_STATUS_EXPIRED; } CFAbsoluteTime nb = SecCertificateNotValidBefore(cert); if (nb > now) { evInfo->StatusBits |= CSSM_CERT_STATUS_NOT_VALID_YET; } for (inputAnchorIdx=0; inputAnchorIdx < inputAnchorCount; inputAnchorIdx++) { SecCertificateRef inputAnchor = (SecCertificateRef) CFArrayGetValueAtIndex(inputAnchorArray, inputAnchorIdx); if (inputAnchor && CFEqual(inputAnchor, cert)) { evInfo->StatusBits |= CSSM_CERT_STATUS_IS_IN_ANCHORS; break; } } for (inputCertIdx=0; inputCertIdx < inputCertCount; inputCertIdx++) { SecCertificateRef inputCert = (SecCertificateRef) CFArrayGetValueAtIndex(inputCertArray, inputCertIdx); if (inputCert && CFEqual(inputCert, cert)) { evInfo->StatusBits |= CSSM_CERT_STATUS_IS_IN_INPUT_CERTS; break; } } /* See if there are trust settings for this certificate. */ CFStringRef hashStr = SecTrustSettingsCertHashStrFromCert(cert); bool foundMatch = false; bool foundAny = false; CSSM_RETURN *errors = NULL; uint32 errorCount = 0; OSStatus status = 0; SecTrustSettingsDomain foundDomain = kSecTrustSettingsDomainUser; SecTrustSettingsResult foundResult = kSecTrustSettingsResultInvalid; bool isSelfSigned = false; if ((count - 1) == idx) { // Only the last cert in the chain needs to be considered Boolean selfSigned; status = SecCertificateIsSelfSigned(cert, &selfSigned); isSelfSigned = (status) ? false : ((selfSigned) ? true : false); if (isSelfSigned) { evInfo->StatusBits |= CSSM_CERT_STATUS_IS_ROOT; } } // STU: rdar://25554967 // %%% need to get policyOID, policyString, and keyUsage here! status = SecTrustSettingsEvaluateCert( hashStr, /* certHashStr */ NULL, /* policyOID (optional) */ NULL, /* policyString (optional) */ 0, /* policyStringLen */ 0, /* keyUsage */ isSelfSigned, /* isRootCert */ &foundDomain, /* foundDomain */ &errors, /* allowedErrors -- MUST FREE */ &errorCount, /* numAllowedErrors */ &foundResult, /* resultType */ &foundMatch, /* foundMatchingEntry */ &foundAny); /* foundAnyEntry */ if (status == errSecSuccess) { if (foundMatch) { switch (foundResult) { case kSecTrustSettingsResultTrustRoot: case kSecTrustSettingsResultTrustAsRoot: /* these two can be disambiguated by IS_ROOT */ evInfo->StatusBits |= CSSM_CERT_STATUS_TRUST_SETTINGS_TRUST; break; case kSecTrustSettingsResultDeny: evInfo->StatusBits |= CSSM_CERT_STATUS_TRUST_SETTINGS_DENY; break; case kSecTrustSettingsResultUnspecified: case kSecTrustSettingsResultInvalid: default: break; } } } if (errors) { free(errors); } if (hashStr) { CFRelease(hashStr); } unsigned int numCodes=0; CSSM_RETURN *statusCodes = copyCssmStatusCodes(trust, (unsigned int)idx, &numCodes); if (statusCodes) { // Realloc space for these status codes at end of our status codes block. // Two important things to note: // 1. the actual length is numCodes+1 because copyCssmStatusCodes // allocates one more element at the end for the CrlReason value. // 2. realloc may cause the pointer to move, which means we will // need to fix up the StatusCodes fields after we're done with this loop. unsigned int totalStatusCodes = numStatusCodes + numCodes + 1; statusArray = (CSSM_RETURN *)realloc(statusArray, totalStatusCodes * sizeof(CSSM_RETURN)); evInfo->StatusCodes = &statusArray[numStatusCodes]; evInfo->NumStatusCodes = numCodes; // Copy the new codes (plus one) into place for (unsigned int cpix = 0; cpix <= numCodes; cpix++) { evInfo->StatusCodes[cpix] = statusCodes[cpix]; } numStatusCodes = totalStatusCodes; free(statusCodes); } if(evInfo->StatusBits & (CSSM_CERT_STATUS_TRUST_SETTINGS_TRUST | CSSM_CERT_STATUS_TRUST_SETTINGS_DENY | CSSM_CERT_STATUS_TRUST_SETTINGS_IGNORED_ERROR)) { /* Something noteworthy happened involving TrustSettings */ uint32 whichDomain = 0; switch(foundDomain) { case kSecTrustSettingsDomainUser: whichDomain = CSSM_CERT_STATUS_TRUST_SETTINGS_FOUND_USER; break; case kSecTrustSettingsDomainAdmin: whichDomain = CSSM_CERT_STATUS_TRUST_SETTINGS_FOUND_ADMIN; break; case kSecTrustSettingsDomainSystem: whichDomain = CSSM_CERT_STATUS_TRUST_SETTINGS_FOUND_SYSTEM; break; } evInfo->StatusBits |= whichDomain; } /* index into raw cert group or AnchorCerts depending on IS_IN_ANCHORS */ //evInfo->Index = certInfo->index(); /* nonzero if cert came from a DLDB */ //evInfo->DlDbHandle = certInfo->dlDbHandle(); //evInfo->UniqueRecord = certInfo->uniqueRecord(); } // Now that all the status codes have been allocated in a contiguous block, // refresh the StatusCodes pointer in each array element. numStatusCodes = 0; for (idx=0; idx < count; idx++) { CSSM_TP_APPLE_EVIDENCE_INFO *evInfo = &infoArray[idx]; evInfo->StatusCodes = &statusArray[numStatusCodes]; numStatusCodes += evInfo->NumStatusCodes + 1; } secTrust->_legacy_info_array = infoArray; secTrust->_legacy_status_array = statusArray; if (inputCertArray) { CFRelease(inputCertArray); } if (inputAnchorArray) { CFRelease(inputAnchorArray); } return (CSSM_TP_APPLE_EVIDENCE_INFO *)secTrust->_legacy_info_array; }
static QVariant qtValue(CFPropertyListRef cfvalue) { if (!cfvalue) return QVariant(); CFTypeID typeId = CFGetTypeID(cfvalue); /* Sorted grossly from most to least frequent type. */ if (typeId == CFStringGetTypeID()) { return QSettingsPrivate::stringToVariant(QCFString::toQString(static_cast<CFStringRef>(cfvalue))); } else if (typeId == CFNumberGetTypeID()) { CFNumberRef cfnumber = static_cast<CFNumberRef>(cfvalue); if (CFNumberIsFloatType(cfnumber)) { double d; CFNumberGetValue(cfnumber, kCFNumberDoubleType, &d); return d; } else { int i; qint64 ll; if (CFNumberGetValue(cfnumber, kCFNumberIntType, &i)) return i; CFNumberGetValue(cfnumber, kCFNumberLongLongType, &ll); return ll; } } else if (typeId == CFArrayGetTypeID()) { CFArrayRef cfarray = static_cast<CFArrayRef>(cfvalue); QList<QVariant> list; CFIndex size = CFArrayGetCount(cfarray); bool metNonString = false; for (CFIndex i = 0; i < size; ++i) { QVariant value = qtValue(CFArrayGetValueAtIndex(cfarray, i)); if (value.type() != QVariant::String) metNonString = true; list << value; } if (metNonString) return list; else return QVariant(list).toStringList(); } else if (typeId == CFBooleanGetTypeID()) { return (bool)CFBooleanGetValue(static_cast<CFBooleanRef>(cfvalue)); } else if (typeId == CFDataGetTypeID()) { CFDataRef cfdata = static_cast<CFDataRef>(cfvalue); return QByteArray(reinterpret_cast<const char *>(CFDataGetBytePtr(cfdata)), CFDataGetLength(cfdata)); } else if (typeId == CFDictionaryGetTypeID()) { CFDictionaryRef cfdict = static_cast<CFDictionaryRef>(cfvalue); CFTypeID arrayTypeId = CFArrayGetTypeID(); int size = (int)CFDictionaryGetCount(cfdict); QVarLengthArray<CFPropertyListRef> keys(size); QVarLengthArray<CFPropertyListRef> values(size); CFDictionaryGetKeysAndValues(cfdict, keys.data(), values.data()); QMultiMap<QString, QVariant> map; for (int i = 0; i < size; ++i) { QString key = QCFString::toQString(static_cast<CFStringRef>(keys[i])); if (CFGetTypeID(values[i]) == arrayTypeId) { CFArrayRef cfarray = static_cast<CFArrayRef>(values[i]); CFIndex arraySize = CFArrayGetCount(cfarray); for (CFIndex j = arraySize - 1; j >= 0; --j) map.insert(key, qtValue(CFArrayGetValueAtIndex(cfarray, j))); } else { map.insert(key, qtValue(values[i])); } } return map; } else if (typeId == CFDateGetTypeID()) { QDateTime dt; dt.setTime_t((uint)kCFAbsoluteTimeIntervalSince1970); return dt.addSecs((int)CFDateGetAbsoluteTime(static_cast<CFDateRef>(cfvalue))); } return QVariant(); }
inline SQLite3Status SQLite3StatementBindDate(SQLite3StatementRef statement, CFIndex index, CFDateRef value) { if (value) return SQLite3StatementBindAbsoluteTime(statement, index, CFDateGetAbsoluteTime(value)); else return SQLite3StatementBindNULL(statement, index); }
CFStringRef _SCCopyDescription(CFTypeRef cf, CFDictionaryRef formatOptions) { #ifdef ENABLE_SC_FORMATTING CFMutableDictionaryRef nFormatOptions; CFStringRef prefix1; CFStringRef prefix2; CFTypeID type = CFGetTypeID(cf); if (!formatOptions || !CFDictionaryGetValueIfPresent(formatOptions, CFSTR("PREFIX1"), (const void **)&prefix1)) { prefix1 = CFSTR(""); } if (type == CFStringGetTypeID()) { return CFStringCreateWithFormat(NULL, formatOptions, CFSTR("%@%@"), prefix1, cf); } if (type == CFBooleanGetTypeID()) { return CFStringCreateWithFormat(NULL, formatOptions, CFSTR("%@%s"), prefix1, CFBooleanGetValue(cf) ? "TRUE" : "FALSE"); } if (type == CFDataGetTypeID()) { const uint8_t *data; CFIndex dataLen; CFIndex i; CFMutableStringRef str; str = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(str, formatOptions, CFSTR("%@<data> 0x"), prefix1); data = CFDataGetBytePtr(cf); dataLen = CFDataGetLength(cf); for (i = 0; i < dataLen; i++) { CFStringAppendFormat(str, NULL, CFSTR("%02x"), data[i]); } return str; } if (type == CFNumberGetTypeID()) { return CFStringCreateWithFormat(NULL, formatOptions, CFSTR("%@%@"), prefix1, cf); } if (type == CFDateGetTypeID()) { CFCalendarRef calendar; CFStringRef str; CFTimeZoneRef tz; int MM, DD, YYYY, hh, mm, ss; calendar = CFCalendarCreateWithIdentifier(NULL, kCFGregorianCalendar); tz = CFTimeZoneCopySystem(); CFCalendarSetTimeZone(calendar, tz); CFRelease(tz); CFCalendarDecomposeAbsoluteTime(calendar, CFDateGetAbsoluteTime(cf), "MdyHms", &MM, &DD, &YYYY, &hh, &mm, &ss); CFRelease(calendar); str = CFStringCreateWithFormat(NULL, formatOptions, CFSTR("%@%02d/%02d/%04d %02d:%02d:%02d"), prefix1, MM, DD, YYYY, hh, mm, ss); return str; } if ((formatOptions == NULL) || !CFDictionaryGetValueIfPresent(formatOptions, CFSTR("PREFIX2"), (const void **)&prefix2)) { prefix2 = prefix1; } if (formatOptions != NULL) { nFormatOptions = CFDictionaryCreateMutableCopy(NULL, 0, formatOptions); } else { nFormatOptions = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); } assert(nFormatOptions != NULL); #define N_QUICK 32 if (type == CFArrayGetTypeID()) { const void * elements_q[N_QUICK]; const void ** elements = elements_q; CFIndex i; CFIndex nElements; CFMutableStringRef str; str = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(str, formatOptions, CFSTR("%@<array> {"), prefix1); nElements = CFArrayGetCount(cf); if (nElements > 0) { if (nElements > (CFIndex)(sizeof(elements_q)/sizeof(CFTypeRef))) elements = CFAllocatorAllocate(NULL, nElements * sizeof(CFTypeRef), 0); CFArrayGetValues(cf, CFRangeMake(0, nElements), elements); for (i = 0; i < nElements; i++) { CFMutableStringRef nPrefix1; CFMutableStringRef nPrefix2; CFStringRef nStr; CFStringRef vStr; nStr = CFStringCreateWithFormat(NULL, NULL, CFSTR("%ld"), i); nPrefix1 = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(nPrefix1, formatOptions, CFSTR("%@ %@ : "), prefix2, nStr); nPrefix2 = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(nPrefix2, formatOptions, CFSTR("%@ "), prefix2); CFDictionarySetValue(nFormatOptions, CFSTR("PREFIX1"), nPrefix1); CFDictionarySetValue(nFormatOptions, CFSTR("PREFIX2"), nPrefix2); CFRelease(nPrefix1); CFRelease(nPrefix2); CFRelease(nStr); vStr = _SCCopyDescription((CFTypeRef)elements[i], nFormatOptions); CFStringAppendFormat(str, formatOptions, CFSTR("\n%@"), vStr); CFRelease(vStr); } if (elements != elements_q) CFAllocatorDeallocate(NULL, elements); } CFStringAppendFormat(str, formatOptions, CFSTR("\n%@}"), prefix2); CFRelease(nFormatOptions); return str; } if (type == CFDictionaryGetTypeID()) { const void * keys_q[N_QUICK]; const void ** keys = keys_q; CFIndex i; CFIndex nElements; CFMutableStringRef nPrefix1; CFMutableStringRef nPrefix2; CFMutableStringRef str; str = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(str, formatOptions, CFSTR("%@<dictionary> {"), prefix1); nElements = CFDictionaryGetCount(cf); if (nElements > 0) { CFComparatorFunction compFunc = NULL; CFMutableArrayRef sortedKeys; if (nElements > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) { keys = CFAllocatorAllocate(NULL, nElements * sizeof(CFTypeRef), 0); } CFDictionaryGetKeysAndValues(cf, keys, NULL); sortedKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); for (i = 0; i < nElements; i++) { CFArrayAppendValue(sortedKeys, (CFStringRef)keys[i]); } if (isA_CFString(keys[0])) { compFunc = (CFComparatorFunction)CFStringCompare; } else if (isA_CFNumber(keys[0])) { compFunc = (CFComparatorFunction)CFNumberCompare; } else if (isA_CFDate(keys[0])) { compFunc = (CFComparatorFunction)CFDateCompare; } if (compFunc != NULL) { CFArraySortValues(sortedKeys, CFRangeMake(0, nElements), compFunc, NULL); } for (i = 0; i < nElements; i++) { CFStringRef key; CFStringRef kStr; CFTypeRef val; CFStringRef vStr; key = CFArrayGetValueAtIndex(sortedKeys, i); kStr = _SCCopyDescription((CFTypeRef)key, NULL); nPrefix1 = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(nPrefix1, formatOptions, CFSTR("%@ %@ : "), prefix2, kStr); nPrefix2 = CFStringCreateMutable(NULL, 0); CFStringAppendFormat(nPrefix2, formatOptions, CFSTR("%@ "), prefix2); CFDictionarySetValue(nFormatOptions, CFSTR("PREFIX1"), nPrefix1); CFDictionarySetValue(nFormatOptions, CFSTR("PREFIX2"), nPrefix2); CFRelease(nPrefix1); CFRelease(nPrefix2); CFRelease(kStr); val = CFDictionaryGetValue(cf, key); vStr = _SCCopyDescription((CFTypeRef)val, nFormatOptions); CFStringAppendFormat(str, formatOptions, CFSTR("\n%@"), vStr); CFRelease(vStr); } CFRelease(sortedKeys); if (keys != keys_q) { CFAllocatorDeallocate(NULL, keys); } } CFStringAppendFormat(str, formatOptions, CFSTR("\n%@}"), prefix2); CFRelease(nFormatOptions); return str; } CFRelease(nFormatOptions); #endif /* ENABLE_SC_FORMATTING */ return CFStringCreateWithFormat(NULL, formatOptions, CFSTR("%@%@"), prefix1, cf); }
static void printPlist(CFArrayRef plist, CFIndex indent, CFIndex maxWidth) { CFIndex count = CFArrayGetCount(plist); CFIndex ix; for (ix = 0; ix < count ; ++ix) { CFDictionaryRef prop = (CFDictionaryRef)CFArrayGetValueAtIndex(plist, ix); CFStringRef pType = (CFStringRef)CFDictionaryGetValue(prop, kSecPropertyKeyType); CFStringRef label = (CFStringRef)CFDictionaryGetValue(prop, kSecPropertyKeyLabel); CFStringRef llabel = (CFStringRef)CFDictionaryGetValue(prop, kSecPropertyKeyLocalizedLabel); CFTypeRef value = (CFTypeRef)CFDictionaryGetValue(prop, kSecPropertyKeyValue); bool isSection = CFEqual(pType, kSecPropertyTypeSection); CFMutableStringRef line = CFStringCreateMutable(NULL, 0); CFIndex jx = 0; for (jx = 0; jx < indent; ++jx) { CFStringAppend(line, CFSTR(" ")); } if (llabel) { CFStringAppend(line, llabel); if (!isSection) { for (jx = CFStringGetLength(llabel) + indent * 4; jx < maxWidth; ++jx) { CFStringAppend(line, CFSTR(" ")); } CFStringAppend(line, CFSTR(" : ")); } } if (CFEqual(pType, kSecPropertyTypeWarning)) { CFStringAppend(line, CFSTR("*WARNING* ")); CFStringAppend(line, (CFStringRef)value); } else if (CFEqual(pType, kSecPropertyTypeError)) { CFStringAppend(line, CFSTR("*ERROR* ")); CFStringAppend(line, (CFStringRef)value); } else if (CFEqual(pType, kSecPropertyTypeSuccess)) { CFStringAppend(line, CFSTR("*OK* ")); CFStringAppend(line, (CFStringRef)value); } else if (CFEqual(pType, kSecPropertyTypeTitle)) { CFStringAppend(line, CFSTR("*")); CFStringAppend(line, (CFStringRef)value); CFStringAppend(line, CFSTR("*")); } else if (CFEqual(pType, kSecPropertyTypeSection)) { } else if (CFEqual(pType, kSecPropertyTypeData)) { CFDataRef data = (CFDataRef)value; CFIndex length = CFDataGetLength(data); if (length > 20) CFStringAppendFormat(line, NULL, CFSTR("[%d bytes] "), length); const UInt8 *bytes = CFDataGetBytePtr(data); for (jx = 0; jx < length; ++jx) { if (jx == 0) CFStringAppendFormat(line, NULL, CFSTR("%02X"), bytes[jx]); else if (jx < 15 || length <= 20) CFStringAppendFormat(line, NULL, CFSTR(" %02X"), bytes[jx]); else { CFStringAppend(line, CFSTR(" ...")); break; } } } else if (CFEqual(pType, kSecPropertyTypeString)) { CFStringAppend(line, (CFStringRef)value); } else if (CFEqual(pType, kSecPropertyTypeDate)) { CFDateRef date = (CFDateRef)value; CFLocaleRef lc = CFLocaleCopyCurrent(); CFDateFormatterRef df = CFDateFormatterCreate(NULL, lc, kCFDateFormatterMediumStyle, kCFDateFormatterLongStyle); CFStringRef ds; if (df) { CFTimeZoneRef tz = CFTimeZoneCreateWithTimeIntervalFromGMT(NULL, 0.0); CFDateFormatterSetProperty(df, kCFDateFormatterTimeZone, tz); CFRelease(tz); ds = CFDateFormatterCreateStringWithDate(NULL, df, date); CFRelease(df); } else { ds = CFStringCreateWithFormat(NULL, NULL, CFSTR("%g"), CFDateGetAbsoluteTime(date)); } CFStringAppend(line, ds); CFRelease(ds); CFRelease(lc); } else if (CFEqual(pType, kSecPropertyTypeURL)) { CFURLRef url = (CFURLRef)value; CFStringAppend(line, CFSTR("<")); CFStringAppend(line, CFURLGetString(url)); CFStringAppend(line, CFSTR(">")); } else { CFStringAppendFormat(line, NULL, CFSTR("*unknown type %@* = %@"), pType, value); } if (!isSection || label) print_line(line); CFRelease(line); if (isSection) { printPlist((CFArrayRef)value, indent + 1, maxWidth); } } }
// // Uniform conversions with CFDateRef // CssmUniformDate::CssmUniformDate(CFDateRef ref) { mTime = CFDateGetAbsoluteTime(ref); }
void encode(ArgumentEncoder* encoder, CFDateRef date) { encoder->encodeDouble(CFDateGetAbsoluteTime(date)); }