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