CFArrayRef SCVLANInterfaceCopyAvailablePhysicalInterfaces() { CFMutableArrayRef available; CFArrayRef bond_interfaces = NULL; CFArrayRef bridge_interfaces = NULL; CFMutableSetRef excluded = NULL; CFArrayRef interfaces; SCPreferencesRef prefs; available = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); prefs = SCPreferencesCreate(NULL, CFSTR("SCVLANInterfaceCopyAvailablePhysicalInterfaces"), NULL); if (prefs != NULL) { #if !TARGET_OS_IPHONE bond_interfaces = SCBondInterfaceCopyAll(prefs); if (bond_interfaces != NULL) { excluded = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); __SCBondInterfaceListCollectMembers(bond_interfaces, excluded); } #endif // !TARGET_OS_IPHONE bridge_interfaces = SCBridgeInterfaceCopyAll(prefs); if (bridge_interfaces != NULL) { if (excluded == NULL) { excluded = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); } __SCBridgeInterfaceListCollectMembers(bridge_interfaces, excluded); } CFRelease(prefs); } // add real interfaces that aren't part of a bond or bridge interfaces = __SCNetworkInterfaceCopyAll_IONetworkInterface(); if (interfaces != NULL) { addAvailableInterfaces(available, interfaces, excluded); CFRelease(interfaces); } // add bond interfaces if (bond_interfaces != NULL) { addAvailableInterfaces(available, bond_interfaces, NULL); CFRelease(bond_interfaces); } // add bridge interfaces if (bridge_interfaces != NULL) { addAvailableInterfaces(available, bridge_interfaces, NULL); CFRelease(bridge_interfaces); } if (excluded != NULL) { CFRelease(excluded); } return available; }
static int dc_readdir(const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi) { int path_len = strlen(path); bool ends_with_slash = path[path_len-1] == '/'; lseek(fd, ch.imagesOffset, SEEK_SET); CFMutableSetRef heard_of = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); for(int i = 0; i < ch.imagesCount; i++) { struct dyld_cache_image_info ii; assert(pread(fd, &ii, sizeof(ii), ch.imagesOffset + i*sizeof(ii)) == sizeof(ii)); char stuff[256]; pread(fd, &stuff, sizeof(stuff), ii.pathFileOffset); if(!memcmp(stuff, path, path_len) && (ends_with_slash || stuff[path_len] == '/')) { char *ent = strdup(stuff + path_len + (ends_with_slash?0:1)); char *slash = strchr(ent, '/'); if(slash) *slash = 0; CFStringRef ents = CFStringCreateWithCString(NULL, ent, kCFStringEncodingASCII); if(!CFSetContainsValue(heard_of, ents)) { CFSetAddValue(heard_of, ents); filler(buf, ent, NULL, 0); } CFRelease(ents); } } CFRelease(heard_of); return 0; }
int main(int argc, const char * argv[]) { CFMutableSetRef favorites; // Create a set object to keep track of our favorite titles favorites = CFSetCreateMutable( NULL, kNumberOfDVDs, &FavoriteSetCallBacks ); // Add A Monster in Paris and A Bug's Life to the set of favorites CFSetAddValue( favorites, testArray[0].title ); CFSetAddValue( favorites, testArray[3].title ); // List the DVDs and determine which ones are favorites printf( "Fav Title\n" ); unsigned int i; for ( i=0; i<kNumberOfDVDs; i++ ) { char fav = ' '; // print a space if NOT a favorite // Determine if this DVD title is one of our favorites by asking // the set if the title of this DVD is in the collection if ( CFSetContainsValue( favorites, testArray[i].title ) ) fav = '*'; printf( " %c %s\n", fav, testArray[i].title ); } return 0; }
static CFSetRef /* of SCNetworkInterfaceRef's */ copyExcludedInterfaces(SCPreferencesRef prefs) { CFMutableSetRef excluded; CFArrayRef interfaces; excluded = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); #if !TARGET_OS_IPHONE // exclude Bond [member] interfaces interfaces = SCBondInterfaceCopyAll(prefs); if (interfaces != NULL) { __SCBondInterfaceListCollectMembers(interfaces, excluded); CFRelease(interfaces); } #endif // !TARGET_OS_IPHONE // exclude Bridge [member] interfaces interfaces = SCBridgeInterfaceCopyAll(prefs); if (interfaces != NULL) { __SCBridgeInterfaceListCollectMembers(interfaces, excluded); CFRelease(interfaces); } return excluded; }
CFMutableSetRef CFSetCreateMutableCopy (CFAllocatorRef allocator, CFIndex capacity, CFSetRef set) { if (CF_IS_OBJC (_kCFSetTypeID, set)) { CFMutableSetRef result; const CFIndex count = CFSetGetCount (set); void **values = (void **) CFAllocatorAllocate (allocator, sizeof (void *) * count, 0); CFIndex i; CFSetGetValues (set, (const void **) values); result = CFSetCreateMutable (allocator, count, &kCFTypeSetCallBacks); for (i = 0; i < count; i++) GSHashTableAddValue ((GSHashTableRef) result, values[i], values[i]); CFAllocatorDeallocate (allocator, (void *) values); return result; } return (CFMutableSetRef) GSHashTableCreateMutableCopy (allocator, (GSHashTableRef) set, capacity); }
bool viewcmd(char *itemName, CFErrorRef *err) { char *cmd, *viewname; SOSViewActionCode ac = kSOSCCViewQuery; CFStringRef viewspec; viewname = strchr(itemName, ':'); if(viewname == NULL) return false; *viewname = 0; viewname++; cmd = itemName; if(strcmp(cmd, "enable") == 0) { ac = kSOSCCViewEnable; } else if(strcmp(cmd, "disable") == 0) { ac = kSOSCCViewDisable; } else if(strcmp(cmd, "query") == 0) { ac = kSOSCCViewQuery; } else { return false; } if(strchr(viewname, ',') == NULL) { // original single value version viewspec = convertStringToView(viewname); if(!viewspec) return false; SOSViewResultCode rc = SOSCCView(viewspec, ac, err); CFStringRef resultString = convertViewReturnCodeToString(rc); printmsg(CFSTR("View Result: %@ : %@\n"), resultString, viewspec); return true; } if(ac == kSOSCCViewQuery) return false; // new multi-view version char *viewlist = strdup(viewname); char *token; char *tofree = viewlist; CFMutableSetRef viewSet = CFSetCreateMutable(NULL, 0, &kCFCopyStringSetCallBacks); while ((token = strsep(&viewlist, ",")) != NULL) { CFStringRef resultString = convertStringToView(token); CFSetAddValue(viewSet, resultString); } printmsg(CFSTR("viewSet provided is %@\n"), viewSet); free(tofree); bool retcode; if(ac == kSOSCCViewEnable) retcode = SOSCCViewSet(viewSet, NULL); else retcode = SOSCCViewSet(NULL, viewSet); fprintf(outFile, "SOSCCViewSet returned %s\n", (retcode)? "true": "false"); return true; }
const void *Collector::rootObjectClasses() { CFMutableSetRef classes = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); #if USE_CONSERVATIVE_GC for (int i = 0; i < ProtectedValues::_tableSize; i++) { ValueImp *val = ProtectedValues::_table[i].key; if (val) { const char *mangled_name = typeid(*val).name(); int status; char *demangled_name = __cxxabiv1::__cxa_demangle (mangled_name, NULL, NULL, &status); CFStringRef className = CFStringCreateWithCString(NULL, demangled_name, kCFStringEncodingASCII); free(demangled_name); CFSetAddValue(classes, className); CFRelease(className); } } #else for (int block = 0; block < heap.usedBlocks; block++) { CollectorBlock *curBlock = heap.blocks[block]; for (int cell = 0; cell < CELLS_PER_BLOCK; cell++) { ValueImp *imp = (ValueImp *)(curBlock->cells + cell); if (((CollectorCell *)imp)->u.freeCell.zeroIfFree != 0 && ((imp->_flags & ValueImp::VI_GCALLOWED) == 0 || imp->refcount != 0)) { const char *mangled_name = typeid(*imp).name(); int status; char *demangled_name = __cxxabiv1::__cxa_demangle (mangled_name, NULL, NULL, &status); CFStringRef className = CFStringCreateWithCString(NULL, demangled_name, kCFStringEncodingASCII); free(demangled_name); CFSetAddValue(classes, className); CFRelease(className); } } } for (int cell = 0; cell < heap.usedOversizeCells; cell++) { ValueImp *imp = (ValueImp *)heap.oversizeCells[cell]; if ((imp->_flags & ValueImp::VI_GCALLOWED) == 0 || imp->refcount != 0) { const char *mangled_name = typeid(*imp).name(); int status; char *demangled_name = __cxxabiv1::__cxa_demangle (mangled_name, NULL, NULL, &status); CFStringRef className = CFStringCreateWithCString(NULL, demangled_name, kCFStringEncodingASCII); free(demangled_name); CFSetAddValue(classes, className); CFRelease(className); } } #endif return classes; }
static VALUE set_alloc(VALUE klass) { CFMutableSetRef set; set = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); if (klass != 0 && klass != rb_cNSSet && klass != rb_cNSMutableSet) *(Class *)set = (Class)klass; CFMakeCollectable(set); return (VALUE)set; }
__private_extern__ int __SCDynamicStoreOpen(SCDynamicStoreRef *store, CFStringRef name) { /* * allocate and initialize a new session */ *store = (SCDynamicStoreRef)__SCDynamicStoreCreatePrivate(NULL, name, NULL, NULL); /* * If necessary, initialize the store and session data dictionaries */ if (storeData == NULL) { sessionData = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); storeData = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); patternData = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); changedKeys = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); deferredRemovals = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); removedSessionKeys = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); } return kSCStatusOK; }
static CFMutableSetRef _cfmp_records(void) { static CFMutableSetRef oRecords; static dispatch_once_t oGuard; dispatch_once(&oGuard, ^{ CFSetCallBacks const cb = { .version = 0, .retain = _cfmp_deallocation_record_retain, .release = _cfmp_deallocation_record_release, .copyDescription = _cfmp_copy_description, .equal = _cfmp_equal, .hash = _cfmp_hash }; oRecords = CFSetCreateMutable(NULL, 16, &cb); }); return oRecords; };
__private_extern__ void ExternalMedia_prime(void) { gExternalMediaSet = CFSetCreateMutable(0, 0, &kCFTypeSetCallBacks); if (!gExternalMediaSet) return; gDASession = DASessionCreate(0); DARegisterDiskAppearedCallback(gDASession, kDADiskDescriptionMatchVolumeMountable, _DiskAppeared, NULL); DARegisterDiskDisappearedCallback(gDASession, kDADiskDescriptionMatchVolumeMountable, _DiskDisappeared, NULL); DASessionScheduleWithRunLoop(gDASession, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode); }
CFErrorRef pick_sign_alg(CFStringRef digest, int digest_length, const CSSM_KEY *ckey, struct digest_mapping **picked) { static dispatch_once_t once = 0; static CFMutableSetRef algos = NULL; dispatch_once(&once, ^{ struct digest_mapping digest_mappings_stack[] = { {CSSM_ALGID_RSA, kSecDigestSHA1, 0, CSSM_ALGID_SHA1WithRSA, CSSM_ALGID_SHA1}, {CSSM_ALGID_RSA, kSecDigestSHA1, 160, CSSM_ALGID_SHA1WithRSA, CSSM_ALGID_SHA1}, {CSSM_ALGID_RSA, kSecDigestMD2, 0, CSSM_ALGID_MD2WithRSA, CSSM_ALGID_MD2}, {CSSM_ALGID_RSA, kSecDigestMD2, 128, CSSM_ALGID_MD2WithRSA, CSSM_ALGID_MD2}, {CSSM_ALGID_RSA, kSecDigestMD5, 0, CSSM_ALGID_MD5WithRSA, CSSM_ALGID_MD5}, {CSSM_ALGID_RSA, kSecDigestMD5, 128, CSSM_ALGID_MD5WithRSA, CSSM_ALGID_MD5}, {CSSM_ALGID_RSA, kSecDigestSHA2, 0, CSSM_ALGID_SHA512WithRSA, CSSM_ALGID_SHA512}, {CSSM_ALGID_RSA, kSecDigestSHA2, 512, CSSM_ALGID_SHA512WithRSA, CSSM_ALGID_SHA512}, {CSSM_ALGID_RSA, kSecDigestSHA2, 384, CSSM_ALGID_SHA384WithRSA, CSSM_ALGID_SHA384}, {CSSM_ALGID_RSA, kSecDigestSHA2, 256, CSSM_ALGID_SHA256WithRSA, CSSM_ALGID_SHA256}, {CSSM_ALGID_RSA, kSecDigestSHA2, 224, CSSM_ALGID_SHA224WithRSA, CSSM_ALGID_SHA224}, {CSSM_ALGID_ECDSA, kSecDigestSHA1, 0, CSSM_ALGID_SHA1WithECDSA, CSSM_ALGID_SHA1}, {CSSM_ALGID_ECDSA, kSecDigestSHA1, 160, CSSM_ALGID_SHA1WithECDSA, CSSM_ALGID_SHA1}, {CSSM_ALGID_ECDSA, kSecDigestSHA2, 0, CSSM_ALGID_SHA512WithECDSA, CSSM_ALGID_SHA512}, {CSSM_ALGID_ECDSA, kSecDigestSHA2, 512, CSSM_ALGID_SHA512WithECDSA, CSSM_ALGID_SHA512}, {CSSM_ALGID_ECDSA, kSecDigestSHA2, 384, CSSM_ALGID_SHA384WithECDSA, CSSM_ALGID_SHA384}, {CSSM_ALGID_ECDSA, kSecDigestSHA2, 256, CSSM_ALGID_SHA256WithECDSA, CSSM_ALGID_SHA256}, {CSSM_ALGID_ECDSA, kSecDigestSHA2, 224, CSSM_ALGID_SHA224WithECDSA, CSSM_ALGID_SHA224}, {CSSM_ALGID_DSA, kSecDigestSHA1, 0, CSSM_ALGID_SHA1WithDSA, CSSM_ALGID_SHA1}, {CSSM_ALGID_DSA, kSecDigestSHA1, 160, CSSM_ALGID_SHA1WithDSA, CSSM_ALGID_SHA1}, }; CFIndex mapping_count = sizeof(digest_mappings_stack)/sizeof(digest_mappings_stack[0]); void *digest_mappings = malloc(sizeof(digest_mappings_stack)); memcpy(digest_mappings, digest_mappings_stack, sizeof(digest_mappings_stack)); CFSetCallBacks dmcb = { .version = 0, .retain = NULL, .release = NULL, .copyDescription = NULL, .equal = (CFSetEqualCallBack)digest_mapping_equal, .hash = (CFSetHashCallBack)digest_mapping_hash }; algos = CFSetCreateMutable(NULL, mapping_count, &dmcb); int i; for(i = 0; i < mapping_count; i++) { CFSetAddValue(algos, i + (struct digest_mapping *)digest_mappings); } });
static SecCertificateSourceRef SecMemoryCertificateSourceCreate( CFArrayRef certificates) { SecMemoryCertificateSourceRef result = (SecMemoryCertificateSourceRef) malloc(sizeof(*result)); result->base.copyParents = SecMemoryCertificateSourceCopyParents; result->base.contains = SecMemoryCertificateSourceContains; CFIndex count = CFArrayGetCount(certificates); result->certificates = CFSetCreateMutable(kCFAllocatorDefault, count, &kCFTypeSetCallBacks); result->subjects = CFDictionaryCreateMutable(kCFAllocatorDefault, count, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFRange range = { 0, count }; CFArrayApplyFunction(certificates, range, SecMemoryCertificateSourceApplierFunction, result); return (SecCertificateSourceRef)result; }
CFMutableSetRef CFSetCreateMutableCopy(CFAllocatorRef allocator, CFIndex capacity, CFSetRef set) { CFMutableSetRef result; const CFSetCallBacks *cb; CFIndex idx, numValues = CFSetGetCount(set); const void **list, *buffer[256]; CFAssert3(0 == capacity || numValues <= capacity, __kCFLogAssertion, "%s(): for fixed-mutable sets, capacity (%d) must be greater than or equal to initial number of values (%d)", __PRETTY_FUNCTION__, capacity, numValues); list = (numValues <= 256) ? buffer : CFAllocatorAllocate(allocator, numValues * sizeof(void *), 0); if (list != buffer && __CFOASafe) __CFSetLastAllocationEventName(list, "CFSet (temp)"); CFSetGetValues(set, list); cb = CF_IS_OBJC(__kCFSetTypeID, set) ? &kCFTypeSetCallBacks : __CFSetGetCallBacks(set); result = CFSetCreateMutable(allocator, capacity, cb); if (0 == capacity) _CFSetSetCapacity(result, numValues); for (idx = 0; idx < numValues; idx++) { CFSetAddValue(result, list[idx]); } if (list != buffer) CFAllocatorDeallocate(allocator, list); return result; }
/* [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | CombiningChar | Extender [5] Name ::= (Letter | '_' | ':') (NameChar)* [7] Nmtoken ::= (NameChar)+ [84] Letter ::= BaseChar | Ideographic We don't do this quite right; we rely on the Unicode charsets to do this analysis. While the productions in the XML spec are based on the Unicode character sets, the definitions differ slightly to avoid those areas where the Unicode standard is still being resolved. At any rate, I'd lay money that using the Unicode charsets, we will be more correct than the vast majority of parsers out there. Letter == kCFUniCharLetterCharacterSet Digit == kCFUniCharDecimalDigitCharacterSet CombiningChar == kCFUniCharNonBaseCharacterSet Extender - complex, and not represented by a uniform character set. */ CF_PRIVATE Boolean _inputStreamScanXMLName(_CFXMLInputStream *stream, Boolean isNMToken, CFStringRef *str) { UniChar ch; Boolean success = true; stream->parserMark = dropMark(stream); if (!isNMToken) { // Only difference between an NMToken and a Name is Names have a stricter condition on the first character if (!getCharacter(stream, &ch, false)) { success = false; } else if (!CFUniCharIsMemberOf(ch, kCFUniCharLetterCharacterSet) && ch != '_' && ch != ':') { success = false; } else { getCharacter(stream, &ch, true); } } if (success) { while (getCharacter(stream, &ch, true)) { if (!CFUniCharIsMemberOf(ch, kCFUniCharLetterCharacterSet) && !CFUniCharIsMemberOf(ch, kCFUniCharDecimalDigitCharacterSet) && ch != '.' && ch != '-' && ch != '_' && ch != ':' && !CFUniCharIsMemberOf(ch, kCFUniCharNonBaseCharacterSet)) { _inputStreamReturnCharacter(stream, ch); break; } } if (NULL == stream->currentChar || stream->currentChar == stream->parserMark) { success = false; // Must have processed at least one character } } if (success) { if (str) { if (!stream->nameSet) { stream->nameSet = CFSetCreateMutable(stream->allocator, 0, &kCFTypeSetCallBacks); stream->tempString = CFStringCreateMutableWithExternalCharactersNoCopy(stream->allocator, NULL, 0, 0, kCFAllocatorNull); } CFStringSetExternalCharactersNoCopy(stream->tempString, stream->parserMark, stream->currentChar-stream->parserMark, stream->currentChar-stream->parserMark); if (!CFSetGetValueIfPresent(stream->nameSet, stream->tempString, (const void **)str)) { *str = (CFStringRef)CFStringCreateCopy(stream->allocator, stream->tempString); CFSetAddValue(stream->nameSet, *str); CFRelease(*str); } } } else { restoreToMark(stream, stream->parserMark); } stream->parserMark = NULL; return success; }
__private_extern__ int __SCDynamicStoreNotifySignal(SCDynamicStoreRef store, pid_t pid, int sig) { SCDynamicStorePrivateRef storePrivate = (SCDynamicStorePrivateRef)store; CFStringRef sessionKey; CFDictionaryRef info; if (storePrivate->notifyStatus != NotifierNotRegistered) { /* sorry, you can only have one notification registered at once */ return kSCStatusNotifierActive; } if (pid == getpid()) { /* sorry, you can't request that configd be signalled */ return kSCStatusInvalidArgument; } if ((sig <= 0) || (sig > NSIG)) { /* sorry, you must specify a valid signal */ return kSCStatusInvalidArgument; } /* push out a notification if any changes are pending */ sessionKey = CFStringCreateWithFormat(NULL, NULL, CFSTR("%d"), storePrivate->server); info = CFDictionaryGetValue(sessionData, sessionKey); CFRelease(sessionKey); if (info && CFDictionaryContainsKey(info, kSCDChangedKeys)) { CFNumberRef sessionNum; if (needsNotification == NULL) needsNotification = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); sessionNum = CFNumberCreate(NULL, kCFNumberIntType, &storePrivate->server); CFSetAddValue(needsNotification, sessionNum); CFRelease(sessionNum); } return kSCStatusOK; }
QString QFontDatabase::resolveFontFamilyAlias(const QString &family) { QCFString expectedFamily = QCFString(family); QCFType<CFMutableDictionaryRef> attributes = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, expectedFamily); QCFType<CTFontDescriptorRef> descriptor = CTFontDescriptorCreateWithAttributes(attributes); QCFType<CFMutableSetRef> mandatoryAttributes = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); CFSetAddValue(mandatoryAttributes, kCTFontFamilyNameAttribute); QCFType<CTFontRef> font = CTFontCreateWithFontDescriptor(descriptor, 0.0, NULL); QCFType<CTFontDescriptorRef> matched = CTFontDescriptorCreateMatchingFontDescriptor(descriptor, mandatoryAttributes); if (!matched) return family; QCFString familyName = (CFStringRef) CTFontDescriptorCopyLocalizedAttribute(matched, kCTFontFamilyNameAttribute, NULL); return familyName; }
// FIXME: Make these thread-safe / re-entrant. extern void GPDuplexClient_AddObserver(GPDuplexClientRef client, void* observer, GPDuplexClientCallback callback, SInt32 type) { if (client != NULL) { CFNumberRef typeNumber = CFNumberCreate(NULL, kCFNumberSInt32Type, &type); CFMutableSetRef observerSet = (CFMutableSetRef)CFDictionaryGetValue(client->observers, typeNumber); Boolean needRelease = false; if (observerSet == NULL) { needRelease = true; observerSet = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); } CFDataRef observerData = GPDuplexClientCreateObserver(observer, callback); CFSetAddValue(observerSet, observerData); CFRelease(observerData); CFDictionarySetValue(client->observers, typeNumber, observerSet); if (needRelease) CFRelease(observerSet); CFRelease(typeNumber); } }
static void* formCreate(CFReadStreamRef stream, void* context) { FormData* formData = static_cast<FormData*>(context); CFSetCallBacks runLoopAndModeCallBacks = { 0, pairRetain, pairRelease, NULL, pairEqual, pairHash }; FormStreamFields* newInfo = new FormStreamFields; newInfo->scheduledRunLoopPairs = CFSetCreateMutable(0, 0, &runLoopAndModeCallBacks); newInfo->currentStream = NULL; newInfo->currentData = 0; newInfo->formStream = stream; // Don't retain. That would create a reference cycle. // Append in reverse order since we remove elements from the end. size_t size = formData->elements().size(); newInfo->remainingElements.reserveCapacity(size); for (size_t i = 0; i < size; ++i) newInfo->remainingElements.append(formData->elements()[size - i - 1]); getStreamFormDatas().set(stream, adoptRef(formData)); return newInfo; }
static void __security_debug_init(void) { const char *cur_scope = gDebugScope = getenv("DEBUGSCOPE"); if (cur_scope) { if (!strcmp(cur_scope, "all")) { scopeSet = NULL; negate = true; } else if (!strcmp(cur_scope, "none")) { scopeSet = NULL; negate = false; } else { scopeSet = CFSetCreateMutable(kCFAllocatorDefault, 0, &kCFTypeSetCallBacks); if (cur_scope[0] == '-') { negate = true; cur_scope++; } else { negate = false; } const char *sep; while ((sep = strchr(cur_scope, ','))) { CFStringRef scopeName = copyScopeName(cur_scope, sep - cur_scope); CFSetAddValue(scopeSet, scopeName); CFRelease(scopeName); cur_scope = sep + 1; } CFStringRef scopeName = copyScopeName(cur_scope, strlen(cur_scope)); CFSetAddValue(scopeSet, scopeName); CFRelease(scopeName); } } else { scopeSet = NULL; negate = false; } }
CFArrayRef CFLocaleCopyAvailableLocaleIdentifiers(void) { int32_t locale, localeCount = uloc_countAvailable(); CFMutableSetRef working = CFSetCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeSetCallBacks); for (locale = 0; locale < localeCount; ++locale) { const char *localeID = uloc_getAvailable(locale); CFStringRef string1 = CFStringCreateWithCString(kCFAllocatorSystemDefault, localeID, kCFStringEncodingASCII); CFStringRef string2 = CFLocaleCreateCanonicalLocaleIdentifierFromString(kCFAllocatorSystemDefault, string1); CFSetAddValue(working, string1); // do not include canonicalized version as IntlFormats cannot cope with that in its popup CFRelease(string1); CFRelease(string2); } CFIndex cnt = CFSetGetCount(working); #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX || (DEPLOYMENT_TARGET_WINDOWS && __GNUC__) STACK_BUFFER_DECL(const void *, buffer, cnt); #else const void* buffer[BUFFER_SIZE]; #endif CFSetGetValues(working, buffer); CFArrayRef result = CFArrayCreate(kCFAllocatorSystemDefault, buffer, cnt, &kCFTypeArrayCallBacks); CFRelease(working); return result; }
static void SecPathBuilderInit(SecPathBuilderRef builder, CFArrayRef certificates, CFArrayRef anchors, bool anchorsOnly, CFArrayRef policies, CFAbsoluteTime verifyTime, SecPathBuilderCompleted completed, const void *context) { secdebug("alloc", "%p", builder); CFAllocatorRef allocator = kCFAllocatorDefault; builder->nextParentSource = 1; builder->considerPartials = false; builder->canAccessNetwork = true; builder->anchorSources = CFArrayCreateMutable(allocator, 0, NULL); builder->parentSources = CFArrayCreateMutable(allocator, 0, NULL); builder->allPaths = CFSetCreateMutable(allocator, 0, &kCFTypeSetCallBacks); builder->partialPaths = CFArrayCreateMutable(allocator, 0, NULL); builder->rejectedPaths = CFArrayCreateMutable(allocator, 0, NULL); builder->candidatePaths = CFArrayCreateMutable(allocator, 0, NULL); builder->partialIX = 0; /* Init the policy verification context. */ SecPVCInit(&builder->path, builder, policies, verifyTime); builder->bestPath = NULL; builder->bestPathIsEV = false; builder->rejectScore = 0; /* Let's create all the certificate sources we might want to use. */ builder->certificateSource = SecMemoryCertificateSourceCreate(certificates); if (anchors) builder->anchorSource = SecMemoryCertificateSourceCreate(anchors); else builder->anchorSource = NULL; /* We always search certificateSource for parents since it includes the leaf itself and it might be self signed. */ CFArrayAppendValue(builder->parentSources, builder->certificateSource); if (builder->anchorSource) { CFArrayAppendValue(builder->anchorSources, builder->anchorSource); } CFArrayAppendValue(builder->parentSources, &kSecItemCertificateSource); if (anchorsOnly) { /* Add the system and user anchor certificate db to the search list if we don't explicitly trust them. */ CFArrayAppendValue(builder->parentSources, &kSecSystemAnchorSource); CFArrayAppendValue(builder->parentSources, &kSecUserAnchorSource); } else { /* Only add the system and user anchor certificate db to the anchorSources if we are supposed to trust them. */ CFArrayAppendValue(builder->anchorSources, &kSecSystemAnchorSource); CFArrayAppendValue(builder->anchorSources, &kSecUserAnchorSource); } CFArrayAppendValue(builder->parentSources, &kSecCAIssuerSource); /* Now let's get the leaf cert and turn it into a path. */ SecCertificateRef leaf = (SecCertificateRef)CFArrayGetValueAtIndex(certificates, 0); SecCertificatePathRef path = SecCertificatePathCreate(NULL, leaf); CFSetAddValue(builder->allPaths, path); CFArrayAppendValue(builder->partialPaths, path); if (SecPathBuilderIsAnchor(builder, leaf)) { SecCertificatePathSetIsAnchored(path); CFArrayAppendValue(builder->candidatePaths, path); } SecPathBuilderLeafCertificateChecks(builder, path); CFRelease(path); builder->activations = 0; builder->state = SecPathBuilderGetNext; builder->completed = completed; builder->context = context; }
CFArrayRef /* of SCNetworkInterfaceRef's */ SCNetworkSetCopyAvailableInterfaces(SCNetworkSetRef set) { CFMutableArrayRef available; CFMutableSetRef excluded = NULL; int i; CFArrayRef interfaces; CFIndex n_interfaces; CFIndex n_exclusions = 0; SCPreferencesRef prefs; SCNetworkSetPrivateRef setPrivate; setPrivate = (SCNetworkSetPrivateRef)set; prefs = setPrivate->prefs; interfaces = _SCNetworkInterfaceCopyAllWithPreferences(prefs); n_interfaces = CFArrayGetCount(interfaces); if (n_interfaces == 0) { return interfaces; } if (prefs != NULL) { CFArrayRef bridges = NULL; excluded = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); #if !TARGET_OS_IPHONE CFArrayRef bonds = NULL; bonds = SCBondInterfaceCopyAll(prefs); if (bonds != NULL) { __SCBondInterfaceListCollectMembers(bonds, excluded); CFRelease(bonds); } #endif /* !TARGET_OS_IPHONE */ bridges = SCBridgeInterfaceCopyAll(prefs); if (bridges != NULL) { __SCBridgeInterfaceListCollectMembers(bridges, excluded); CFRelease(bridges); } n_exclusions = CFSetGetCount(excluded); } if (n_exclusions == 0) { if (excluded != NULL) { CFRelease(excluded); } return interfaces; } available = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); for (i = 0; i < n_interfaces; i++) { SCNetworkInterfaceRef interface; interface = CFArrayGetValueAtIndex(interfaces, i); if (CFSetContainsValue(excluded, interface)) { // if excluded continue; } CFArrayAppendValue(available, interface); } CFRelease(interfaces); CFRelease(excluded); return available; }
CFArrayRef /* of SCNetworkInterfaceRef's */ SCBondInterfaceCopyAvailableMemberInterfaces(SCPreferencesRef prefs) { CFMutableArrayRef available; CFMutableSetRef excluded; CFArrayRef interfaces; available = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); excluded = CFSetCreateMutable (NULL, 0, &kCFTypeSetCallBacks); // exclude Bond [member] interfaces interfaces = SCBondInterfaceCopyAll(prefs); if (interfaces != NULL) { __SCBondInterfaceListCollectMembers(interfaces, excluded); CFRelease(interfaces); } // exclude Bridge [member] interfaces interfaces = SCBridgeInterfaceCopyAll(prefs); if (interfaces != NULL) { __SCBridgeInterfaceListCollectMembers(interfaces, excluded); CFRelease(interfaces); } // exclude VLAN [physical] interfaces interfaces = SCVLANInterfaceCopyAll(prefs); if (interfaces != NULL) { CFIndex i; CFIndex n; n = CFArrayGetCount(interfaces); for (i = 0; i < n; i++) { SCVLANInterfaceRef vlanInterface; SCNetworkInterfaceRef physical; // exclude the physical interface of this VLAN vlanInterface = CFArrayGetValueAtIndex(interfaces, i); physical = SCVLANInterfaceGetPhysicalInterface(vlanInterface); CFSetAddValue(excluded, physical); } CFRelease(interfaces); } // identify available interfaces interfaces = __SCNetworkInterfaceCopyAll_IONetworkInterface(); if (interfaces != NULL) { CFIndex i; CFIndex n; n = CFArrayGetCount(interfaces); for (i = 0; i < n; i++) { SCNetworkInterfaceRef interface; SCNetworkInterfacePrivateRef interfacePrivate; interface = CFArrayGetValueAtIndex(interfaces, i); interfacePrivate = (SCNetworkInterfacePrivateRef)interface; if (!interfacePrivate->supportsBond) { // if this interface is not available continue; } if (CFSetContainsValue(excluded, interface)) { // if excluded continue; } CFArrayAppendValue(available, interface); } CFRelease(interfaces); } CFRelease(excluded); return available; }
CF_PRIVATE CFTypeRef __CFCreateOldStylePropertyListOrStringsFile(CFAllocatorRef allocator, CFDataRef xmlData, CFStringRef originalString, CFStringEncoding guessedEncoding, CFOptionFlags option, CFErrorRef *outError,CFPropertyListFormat *format) { // Convert the string to UTF16 for parsing old-style if (originalString) { // Ensure that originalString is not collected while we are using it CFRetain(originalString); } else { originalString = CFStringCreateWithBytes(kCFAllocatorSystemDefault, CFDataGetBytePtr(xmlData), CFDataGetLength(xmlData), guessedEncoding, NO); if (!originalString) { // Couldn't convert if (outError) *outError = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Conversion of string failed.")); return NULL; } } UInt32 length; Boolean createdBuffer = false; length = CFStringGetLength(originalString); if (!length) { if (outError) *outError = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Conversion of string failed. The string is empty.")); return NULL; } UniChar *buf = (UniChar *)CFStringGetCharactersPtr(originalString); if (!buf) { buf = (UniChar *)CFAllocatorAllocate(allocator, length * sizeof(UniChar), 0); if (!buf) { CRSetCrashLogMessage("CFPropertyList ran out of memory while attempting to allocate temporary storage."); return NULL; } CFStringGetCharacters(originalString, CFRangeMake(0, length), buf); createdBuffer = true; } _CFStringsFileParseInfo stringsPInfo; stringsPInfo.begin = buf; stringsPInfo.end = buf+length; stringsPInfo.curr = buf; stringsPInfo.allocator = allocator; stringsPInfo.mutabilityOption = option; stringsPInfo.stringSet = CFSetCreateMutable(allocator, 0, &kCFTypeSetCallBacks); stringsPInfo.error = NULL; const UniChar *begin = stringsPInfo.curr; CFTypeRef result = NULL; Boolean foundChar = advanceToNonSpace(&stringsPInfo); if (!foundChar) { // A file consisting only of whitespace (or empty) is now defined to be an empty dictionary result = CFDictionaryCreateMutable(allocator, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); } else { result = parsePlistObject(&stringsPInfo, true); if (result) { foundChar = advanceToNonSpace(&stringsPInfo); if (foundChar) { if (CFGetTypeID(result) != CFStringGetTypeID()) { if (result) CFRelease(result); result = NULL; if (stringsPInfo.error) CFRelease(stringsPInfo.error); stringsPInfo.error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Junk after plist at line %d"), lineNumberStrings(&stringsPInfo)); } else { // Reset info and keep parsing if (result) CFRelease(result); if (stringsPInfo.error) CFRelease(stringsPInfo.error); stringsPInfo.error = NULL; // Check for a strings file (looks like a dictionary without the opening/closing curly braces) stringsPInfo.curr = begin; result = parsePlistDictContent(&stringsPInfo); } } } } if (!result) { // Must return some kind of error if requested if (outError) { if (stringsPInfo.error) { // Transfer ownership *outError = stringsPInfo.error; } else { *outError = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unknown error parsing property list around line %d"), lineNumberStrings(&stringsPInfo)); } } else if (stringsPInfo.error) { // Caller doesn't want it, so we need to free it CFRelease(stringsPInfo.error); } } if (result && format) *format = kCFPropertyListOpenStepFormat; if (createdBuffer) CFAllocatorDeallocate(allocator, buf); CFRelease(stringsPInfo.stringSet); CFRelease(originalString); return result; }
static void __DAStageDispatch( void * info ) { static Boolean fresh = FALSE; CFIndex count; CFIndex index; Boolean quiet = TRUE; count = CFArrayGetCount( gDADiskList ); for ( index = 0; index < count; index++ ) { DADiskRef disk; disk = ( void * ) CFArrayGetValueAtIndex( gDADiskList, index ); if ( DADiskGetState( disk, kDADiskStateCommandActive ) == FALSE ) { if ( DADiskGetState( disk, kDADiskStateStagedProbe ) == FALSE ) { if ( fresh ) { DAFileSystemListRefresh( ); DAMountMapListRefresh1( ); DAMountMapListRefresh2( ); fresh = FALSE; } __DAStageProbe( disk ); } else if ( DADiskGetState( disk, kDADiskStateStagedPeek ) == FALSE ) { __DAStagePeek( disk ); } ///w:start else if ( DADiskGetState( disk, kDADiskStateRequireRepair ) == FALSE ) { if ( DADiskGetState( disk, kDADiskStateStagedApprove ) == FALSE ) { __DAStageMountApproval( disk ); } else if ( DADiskGetState( disk, kDADiskStateStagedAuthorize ) == FALSE ) { __DAStageMountAuthorization( disk ); } else if ( DADiskGetState( disk, kDADiskStateStagedMount ) == FALSE ) { __DAStageMount( disk ); } else if ( DADiskGetState( disk, kDADiskStateStagedAppear ) == FALSE ) { __DAStageAppeared( disk ); } else { ///w:start if ( gDAConsoleUserList == NULL ) { if ( DADiskGetDescription( disk, kDADiskDescriptionMediaTypeKey ) ) { if ( DAUnitGetState( disk, kDAUnitStateStagedUnreadable ) == FALSE ) { if ( _DAUnitIsUnreadable( disk ) ) { DADiskEject( disk, kDADiskEjectOptionDefault, NULL ); } DAUnitSetState( disk, kDAUnitStateStagedUnreadable, TRUE ); } } } ///w:stop continue; } } ///w:stop else if ( DADiskGetState( disk, kDADiskStateStagedAppear ) == FALSE ) { /* * We stall the "appeared" stage if the conditions are not right. */ if ( DADiskGetState( disk, kDADiskStateRequireRepair ) ) { CFIndex subcount; CFIndex subindex; subcount = CFArrayGetCount( gDADiskList ); for ( subindex = 0; subindex < subcount; subindex++ ) { DADiskRef subdisk; subdisk = ( void * ) CFArrayGetValueAtIndex( gDADiskList, subindex ); if ( DADiskGetBSDUnit( disk ) == DADiskGetBSDUnit( subdisk ) ) { if ( DADiskGetState( subdisk, kDADiskStateStagedProbe ) == FALSE ) { break; } if ( DADiskGetState( subdisk, kDADiskStateStagedAppear ) == FALSE ) { if ( DADiskGetState( subdisk, kDADiskStateRequireRepair ) == FALSE ) { break; } } } } if ( subindex == subcount ) { __DAStageAppeared( disk ); } } else { __DAStageAppeared( disk ); } } else if ( DADiskGetState( disk, kDADiskStateStagedApprove ) == FALSE ) { __DAStageMountApproval( disk ); } else if ( DADiskGetState( disk, kDADiskStateStagedAuthorize ) == FALSE ) { __DAStageMountAuthorization( disk ); } else if ( DADiskGetState( disk, kDADiskStateStagedMount ) == FALSE ) { if ( gDAExit ) { continue; } __DAStageMount( disk ); } else { continue; } } quiet = FALSE; } count = CFArrayGetCount( gDARequestList ); if ( count ) { CFMutableSetRef dependencies; dependencies = CFSetCreateMutable( kCFAllocatorDefault, 0, &kCFTypeSetCallBacks ); if ( dependencies ) { for ( index = 0; index < count; index++ ) { DARequestRef request; request = ( void * ) CFArrayGetValueAtIndex( gDARequestList, index ); if ( request ) { DADiskRef disk; Boolean dispatch = TRUE; disk = DARequestGetDisk( request ); /* * Determine whether the request has undispatched dependencies. */ if ( disk ) { CFArrayRef link; link = DARequestGetLink( request ); if ( link ) { CFIndex subcount; CFIndex subindex; subcount = CFArrayGetCount( link ); for ( subindex = 0; subindex < subcount; subindex++ ) { DARequestRef subrequest; subrequest = ( void * ) CFArrayGetValueAtIndex( link, subindex ); if ( CFSetContainsValue( dependencies, DARequestGetDisk( subrequest ) ) ) { break; } } if ( subindex < subcount ) { dispatch = FALSE; } } if ( CFSetContainsValue( dependencies, disk ) ) { dispatch = FALSE; } } else { if ( index ) { break; } } if ( dispatch ) { /* * Prepare to dispatch the request. */ if ( DARequestGetKind( request ) == _kDADiskMount ) { if ( fresh ) { DAFileSystemListRefresh( ); DAMountMapListRefresh1( ); DAMountMapListRefresh2( ); fresh = FALSE; } } /* * Dispatch the request. */ dispatch = DARequestDispatch( request ); } if ( dispatch ) { CFArrayRemoveValueAtIndex( gDARequestList, index ); count--; index--; } else { /* * Add the request to the undispatched dependencies. */ if ( disk ) { CFArrayRef link; link = DARequestGetLink( request ); if ( link ) { CFIndex subcount; CFIndex subindex; subcount = CFArrayGetCount( link ); for ( subindex = 0; subindex < subcount; subindex++ ) { DARequestRef subrequest; subrequest = ( void * ) CFArrayGetValueAtIndex( link, subindex ); CFSetSetValue( dependencies, DARequestGetDisk( subrequest ) ); } } CFSetSetValue( dependencies, disk ); } } } } CFRelease( dependencies ); } quiet = FALSE; } if ( quiet ) { fresh = TRUE; gDAIdle = TRUE; DAIdleCallback( ); ___vproc_transaction_end( ); if ( gDAConsoleUser ) { /* * Determine whether a unit is unreadable or a volume is unrepairable. */ count = CFArrayGetCount( gDADiskList ); for ( index = 0; index < count; index++ ) { DADiskRef disk; disk = ( void * ) CFArrayGetValueAtIndex( gDADiskList, index ); /* * Determine whether a unit is unreadable. */ if ( DADiskGetDescription( disk, kDADiskDescriptionMediaWholeKey ) == kCFBooleanTrue ) { if ( DAUnitGetState( disk, kDAUnitStateStagedUnreadable ) == FALSE ) { if ( _DAUnitIsUnreadable( disk ) ) { DADialogShowDeviceUnreadable( disk ); } DAUnitSetState( disk, kDAUnitStateStagedUnreadable, TRUE ); } } /* * Determine whether a volume is unrepairable. */ if ( DADiskGetDescription( disk, kDADiskDescriptionVolumePathKey ) ) { if ( DADiskGetState( disk, kDADiskStateStagedUnrepairable ) == FALSE ) { if ( DADiskGetState( disk, kDADiskStateRequireRepair ) ) { if ( DADiskGetOption( disk, kDADiskOptionMountAutomatic ) ) { if ( DADiskGetClaim( disk ) == NULL ) { DADialogShowDeviceUnrepairable( disk ); } } } DADiskSetState( disk, kDADiskStateStagedUnrepairable, TRUE ); } } } } } }
int main (int argc, const char* argv[]) { if (argc == 1) { printf("Usage: LocalizationStatusHelper <bundle-path>\n"); } else { if (chdir(argv[1]) == -1) { printf("Cannot change directory to %s", argv[1]); perror(""); return 0; } DIR* dir = opendir("."); if (dir == NULL) { printf("Cannot open %s for reading", argv[1]); perror(""); return 0; } struct languagesAndKeys sk; sk.languages = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); sk.keys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); CFMutableSetRef unionKeys = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); struct dirent* dp; // Scan for the directory. while ((dp = readdir(dir)) != NULL) { if (dp->d_type == DT_DIR) { CFStringRef dirName = CFStringCreateWithCString(NULL, dp->d_name, kCFStringEncodingUTF8); // Check if it's an lproj. if (CFStringHasSuffix(dirName, CFSTR(".lproj"))) { CFMutableSetRef langKeys = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); // Scan for strings files. chdir(dp->d_name); DIR* subdir = opendir("."); if (subdir != NULL) { struct dirent* dp2; while ((dp2 = readdir(subdir)) != NULL) { // Ignore linked strings files. if (dp2->d_type == DT_REG) { CFStringRef stringsName = CFStringCreateWithCString(NULL, dp2->d_name, kCFStringEncodingUTF8); // Ignore non-strings files. if (CFStringHasSuffix(stringsName, CFSTR(".strings"))) { // Convert to CFURLRef stringsURL = CFURLCreateWithFileSystemPath(NULL, stringsName, kCFURLPOSIXPathStyle, false); CFReadStreamRef stringsStream = CFReadStreamCreateWithFile(NULL, stringsURL); CFRelease(stringsURL); CFReadStreamOpen(stringsStream); CFPropertyListRef strings = CFPropertyListCreateFromStream(NULL, stringsStream, 0, kCFPropertyListImmutable, NULL, NULL); CFReadStreamClose(stringsStream); CFRelease(stringsStream); CFDictionaryApplyFunction(strings, (CFDictionaryApplierFunction)&addKeysToSet, langKeys); CFDictionaryApplyFunction(strings, (CFDictionaryApplierFunction)&addKeysToSet, unionKeys); CFRelease(strings); } CFRelease(stringsName); } } closedir(subdir); } chdir(".."); CFStringRef langCode = CFStringCreateWithSubstring(NULL, dirName, CFRangeMake(0, CFStringGetLength(dirName)-6)); CFArrayAppendValue(sk.languages, langCode); CFArrayAppendValue(sk.keys, langKeys); CFRelease(langKeys); CFRelease(langCode); } CFRelease(dirName); } } closedir(dir); sk.count = CFArrayGetCount(sk.languages); printf("|| *Key* ||"); CFArrayApplyFunction(sk.languages, CFRangeMake(0, sk.count), (CFArrayApplierFunction)&printHeader, NULL); printf("\n"); CFSetApplyFunction(unionKeys, (CFSetApplierFunction)&printSupportedLanguages, &sk); CFRelease(sk.keys); CFRelease(sk.languages); CFRelease(unionKeys); } return 0; }
void init_identifier_dict() { identifier_set = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks); }