/*
* Parse file extension and attempt to map it to format and type. Returns true
* on success.
*/
bool impExpImportParseFileExten(
CFStringRef fstr,
SecExternalFormat *inputFormat, // RETURNED
SecExternalItemType *itemType) // RETURNED
{
if(fstr == NULL) {
/* nothing to work with */
return false;
}
if(CFStringHasSuffix(fstr, CFSTR(".cer")) ||
CFStringHasSuffix(fstr, CFSTR(".crt"))) {
*inputFormat = kSecFormatX509Cert;
*itemType = kSecItemTypeCertificate;
SecImpInferDbg("Inferring kSecFormatX509Cert from file name");
return true;
}
if(CFStringHasSuffix(fstr, CFSTR(".p12")) ||
CFStringHasSuffix(fstr, CFSTR(".pfx"))) {
*inputFormat = kSecFormatPKCS12;
*itemType = kSecItemTypeAggregate;
SecImpInferDbg("Inferring kSecFormatPKCS12 from file name");
return true;
}
/* Get extension, look for key indicators as substrings */
CFURLRef url = CFURLCreateWithString(NULL, fstr, NULL);
if(url == NULL) {
SecImpInferDbg("impExpImportParseFileExten: error creating URL");
return false;
}
CFStringRef exten = CFURLCopyPathExtension(url);
CFRelease(url);
if(exten == NULL) {
/* no extension, app probably passed in only an extension */
exten = fstr;
CFRetain(exten);
}
bool ortn = false;
CFRange cfr;
cfr = CFStringFind(exten, CFSTR("p7"), kCFCompareCaseInsensitive);
if(cfr.length != 0) {
*inputFormat = kSecFormatPKCS7;
*itemType = kSecItemTypeAggregate;
SecImpInferDbg("Inferring kSecFormatPKCS7 from file name");
ortn = true;
}
if(!ortn) {
cfr = CFStringFind(exten, CFSTR("p8"), kCFCompareCaseInsensitive);
if(cfr.length != 0) {
*inputFormat = kSecFormatWrappedPKCS8;
*itemType = kSecItemTypePrivateKey;
SecImpInferDbg("Inferring kSecFormatPKCS8 from file name");
ortn = true;
}
}
CFRelease(exten);
return ortn;
}
// This function is not used at this time, but it gives an example of how we might
// filter files for display in the open dialog, depending on the file name extension.
// We might use this function in the filter callback to Navigation Services.
Boolean CNavOpenDialog::SupportFileIdentifiedByDotExtension( CFStringRef fileName )
{
static const CFStringRef kFilenameExtensions[] =
{ CFSTR(".rtf"), CFSTR(".htm"), CFSTR(".html"), CFSTR(".txt"), CFSTR(".text"),
CFSTR(".sh"), CFSTR(".conf"), CFSTR(".ucs"), CFSTR(".utxt"), CFSTR(".utext"),
CFSTR(".uni"), CFSTR(".unicode"), CFSTR(".plist"), CFSTR(".php"), CFSTR(".c"),
CFSTR(".config"), CFSTR(".h"), CFSTR(".cp"), CFSTR(".cpp"), CFSTR(".perl"),
CFSTR(".py"), CFSTR(".hpp"), CFSTR(".tpp"), CFSTR(".i"), CFSTR(".rc"), CFSTR(".make"),
CFSTR(".apaci"), CFSTR(".r"),CFSTR(".rsrc"), CFSTR(".pp"), CFSTR(".p"), CFSTR(".script"),
CFSTR(".as"), CFSTR(".xml"), CFSTR(".xsl")//may want to weed out extensions that are a superset for example ".htm" is in ".html"
};
static const UInt16 kFilenameExtensionCount = sizeof( kFilenameExtensions ) / sizeof( CFStringRef );
Boolean returnSupport = false;
// check all supported filetypes
for ( int i = 0; i < kFilenameExtensionCount; i++ )
{
if ( CFStringHasSuffix(fileName, kFilenameExtensions[i]) )
{
returnSupport = true;
break; // we support it so don't bother comparing against the remaining extensions
}
}
return returnSupport;
}
static void _CFBundleInitializeMainBundleInfoDictionaryAlreadyLocked(CFStringRef executablePath) {
CFBundleGetInfoDictionary(_mainBundle);
if (!_mainBundle->_infoDict || CFDictionaryGetCount(_mainBundle->_infoDict) == 0) {
// if type 3 bundle and no Info.plist, treat as unbundled, since this gives too many false positives
if (_mainBundle->_version == 3) _mainBundle->_version = 4;
if (_mainBundle->_version == 0) {
// if type 0 bundle and no Info.plist and not main executable for bundle, treat as unbundled, since this gives too many false positives
CFStringRef executableName = _CFBundleCopyExecutableName(_mainBundle, NULL, NULL);
if (!executableName || !executablePath || !CFStringHasSuffix(executablePath, executableName)) _mainBundle->_version = 4;
if (executableName) CFRelease(executableName);
}
#if defined(BINARY_SUPPORT_DYLD)
// We can fall into this case when the executable is sandboxed enough that it can't read its own executable file. We can still attempt to get the info dictionary from the main executable though. _CFBundleCreateInfoDictFromMainExecutable will correctly handle a case where the section does not exist.
if (_mainBundle->_binaryType == __CFBundleDYLDExecutableBinary || _mainBundle->_binaryType == __CFBundleUnreadableBinary) {
if (_mainBundle->_infoDict) CFRelease(_mainBundle->_infoDict);
_mainBundle->_infoDict = (CFDictionaryRef)_CFBundleCreateInfoDictFromMainExecutable();
}
#endif /* BINARY_SUPPORT_DYLD */
} else {
#if defined(BINARY_SUPPORT_DYLD)
if (_mainBundle->_binaryType == __CFBundleDYLDExecutableBinary) {
// if dyld and not main executable for bundle, prefer info dictionary from executable
CFStringRef executableName = _CFBundleCopyExecutableName(_mainBundle, NULL, NULL);
if (!executableName || !executablePath || !CFStringHasSuffix(executablePath, executableName)) {
CFDictionaryRef infoDictFromExecutable = (CFDictionaryRef)_CFBundleCreateInfoDictFromMainExecutable();
if (infoDictFromExecutable && CFDictionaryGetCount(infoDictFromExecutable) > 0) {
if (_mainBundle->_infoDict) CFRelease(_mainBundle->_infoDict);
_mainBundle->_infoDict = infoDictFromExecutable;
} else if (infoDictFromExecutable) {
CFRelease(infoDictFromExecutable);
}
}
if (executableName) CFRelease(executableName);
}
#endif /* BINARY_SUPPORT_DYLD */
}
if (!_mainBundle->_infoDict) _mainBundle->_infoDict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
if (!_mainBundle->_executablePath && executablePath) _mainBundle->_executablePath = (CFStringRef)CFRetain(executablePath);
CFStringRef bundleID = (CFStringRef)CFDictionaryGetValue(_mainBundle->_infoDict, kCFBundleIdentifierKey);
if (bundleID) {
if (!CFStringGetCString(bundleID, __CFBundleMainID__, sizeof(__CFBundleMainID__) - 2, kCFStringEncodingUTF8)) {
__CFBundleMainID__[0] = '\0';
}
}
}
uint8_t AMAuthInstallCryptoGetKeyIdType(CFStringRef key) {
Boolean has_suffix, has_prefix = CFStringHasPrefix(key, @"ap.");
uint8_t flag = 1;
if (has_prefix == false) {
has_prefix = CFStringHasPrefix(key, @"bb.");
}
has_suffix = CFStringHasSuffix(key, @".private");
if (has_suffix == true) {
flag = (flag | 0x8);
}
else {
flag = (flag | 0x4);
if (CFStringHasSuffix(key, @".public")) {
flag = 1;
}
}
return flag;
}
static CFURLRef FindJnlpURLInFile(char* fileName) {
XMLNode* doc = NULL;
CFURLRef returnValue = NULL;
char* jnlbuffer = NULL;
/* Parse XML document. */
if (!ReadFileToBuffer(fileName, &jnlbuffer)) {
return NULL;
}
doc = ParseXMLDocument(jnlbuffer);
if (doc != NULL) {
XMLNode* node = NULL;
char *codebase = NULL;
char *href = NULL;
CFStringRef baseURLString = NULL;
CFStringRef hrefString = NULL;
CFMutableStringRef fullURL = NULL;
node = FindXMLChild(doc, "jnlp");
require(node != NULL, bail);
codebase = FindXMLAttribute(node->_attributes, "codebase");
require(codebase != NULL, bail);
href = FindXMLAttribute(node->_attributes, "href");
require(href != NULL, bail);
baseURLString = CFStringCreateWithCString(NULL, codebase, kCFStringEncodingUTF8);
require(baseURLString != NULL, bail);
fullURL = CFStringCreateMutableCopy(NULL, 0, baseURLString);
hrefString = CFStringCreateWithCString(NULL, href, kCFStringEncodingUTF8);
require(hrefString != NULL, bail);
// a relative JNLP path needs a URL that starts at the specificed codebase
if (!CFStringHasSuffix(fullURL, CFSTR("/")))
CFStringAppend(fullURL, CFSTR("/"));
CFStringAppend(fullURL, hrefString);
returnValue = CFURLCreateWithString(NULL, fullURL, NULL);
bail:
if (baseURLString != NULL) CFRelease(baseURLString);
if (hrefString != NULL) CFRelease(hrefString);
if (fullURL != NULL) CFRelease(fullURL);
FreeXMLDocument(doc);
}
free(jnlbuffer);
return returnValue;
}
static void _CFAppendXMLEpilog(CFMutableStringRef str, CFXMLTreeRef tree) {
CFXMLNodeTypeCode typeID = CFXMLNodeGetTypeCode(CFXMLTreeGetNode(tree));
if (typeID == kCFXMLNodeTypeElement) {
if (((CFXMLElementInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree)))->isEmpty) return;
CFStringAppendFormat(str, NULL, CFSTR("</%@>"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
} else if (typeID == kCFXMLNodeTypeDocumentType) {
CFIndex len = CFStringGetLength(str);
if (CFStringHasSuffix(str, CFSTR(" ["))) {
// There were no in-line DTD elements
CFStringDelete(str, CFRangeMake(len-2, 2));
} else {
CFStringAppendCString(str, "]", kCFStringEncodingASCII);
}
CFStringAppendCString(str, ">", kCFStringEncodingASCII);
}
}
/* Create a URI suitable for use in an http GET request, will return NULL if
the length would exceed 255 bytes. */
static CFURLRef createGetURL(CFURLRef responder, CFDataRef request) {
CFURLRef getURL = NULL;
CFMutableDataRef base64Request = NULL;
CFStringRef base64RequestString = NULL;
CFStringRef peRequest = NULL;
CFIndex base64Len;
base64Len = SecBase64Encode(NULL, CFDataGetLength(request), NULL, 0);
/* Don't bother doing all the work below if we know the end result will
exceed 255 bytes (minus one for the '/' separator makes 254). */
if (base64Len + CFURLGetBytes(responder, NULL, 0) > 254)
return NULL;
require(base64Request = CFDataCreateMutable(kCFAllocatorDefault,
base64Len), errOut);
CFDataSetLength(base64Request, base64Len);
SecBase64Encode(CFDataGetBytePtr(request), CFDataGetLength(request),
(char *)CFDataGetMutableBytePtr(base64Request), base64Len);
require(base64RequestString = CFStringCreateWithBytes(kCFAllocatorDefault,
CFDataGetBytePtr(base64Request), base64Len, kCFStringEncodingUTF8,
false), errOut);
require(peRequest = CFURLCreateStringByAddingPercentEscapes(
kCFAllocatorDefault, base64RequestString, NULL, CFSTR("+/="),
kCFStringEncodingUTF8), errOut);
#if 1
CFStringRef urlString = CFURLGetString(responder);
CFStringRef fullURL;
if (CFStringHasSuffix(urlString, CFSTR("/"))) {
fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%@%@"), urlString, peRequest);
} else {
fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%@/%@"), urlString, peRequest);
}
getURL = CFURLCreateWithString(kCFAllocatorDefault, fullURL, NULL);
CFRelease(fullURL);
#else
getURL = CFURLCreateWithString(kCFAllocatorDefault, peRequest, responder);
#endif
errOut:
CFReleaseSafe(base64Request);
CFReleaseSafe(base64RequestString);
CFReleaseSafe(peRequest);
return getURL;
}
Notificator::Notificator(const QString &programName, QSystemTrayIcon *trayicon, QWidget *parent):
QObject(parent),
parent(parent),
programName(programName),
mode(None),
trayIcon(trayicon)
#ifdef USE_DBUS
,interface(0)
#endif
{
if(trayicon && trayicon->supportsMessages())
{
mode = QSystemTray;
}
#ifdef USE_DBUS
interface = new QDBusInterface("org.freedesktop.Notifications",
"/org/freedesktop/Notifications", "org.freedesktop.Notifications");
if(interface->isValid())
{
mode = Freedesktop;
}
#endif
#ifdef Q_OS_MAC
printf("notification::begin\n");
// check if users OS has support for NSUserNotification
if( MacNotificationHandler::instance()->hasUserNotificationCenterSupport()) {
printf("notification::has\n");
mode = UserNotificationCenter;
} else {
printf("notification::no\n");
// Check if Growl is installed (based on Qt's tray icon implementation)
CFURLRef cfurl;
OSStatus status = LSGetApplicationForInfo(kLSUnknownType, kLSUnknownCreator, CFSTR("growlTicket"), kLSRolesAll, 0, &cfurl);
if (status != kLSApplicationNotFoundErr) {
CFBundleRef bundle = CFBundleCreate(0, cfurl);
if (CFStringCompare(CFBundleGetIdentifier(bundle), CFSTR("com.Growl.GrowlHelperApp"), kCFCompareCaseInsensitive | kCFCompareBackwards) == kCFCompareEqualTo) {
if (CFStringHasSuffix(CFURLGetString(cfurl), CFSTR("/Growl.app/")))
mode = Growl13;
else
mode = Growl12;
}
CFRelease(cfurl);
CFRelease(bundle);
}
}
#endif
}
CFBundleRef mac_loadExeBundle(const char *name)
{
CFBundleRef baseBundle = CFBundleGetBundleWithIdentifier(CFSTR("org.demi3d.Demi"));
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFStringRef nameRef = CFStringCreateWithCString(NULL, name, kCFStringEncodingASCII);
CFURLRef bundleURL = 0; //URL of bundle to load
CFBundleRef bundle = 0; //bundle to load
//cut off .bundle if present
if (CFStringHasSuffix(nameRef, CFSTR(".bundle")))
{
CFStringRef nameTempRef = nameRef;
int end = CFStringGetLength(nameTempRef) - CFStringGetLength(CFSTR(".bundle"));
nameRef = CFStringCreateWithSubstring(NULL, nameTempRef, CFRangeMake(0, end));
CFRelease(nameTempRef);
}
//assume relative to Resources/ directory of Main bundle
bundleURL = CFBundleCopyResourceURL(mainBundle, nameRef, CFSTR("bundle"), NULL);
if (bundleURL)
{
bundle = CFBundleCreate(NULL, bundleURL);
CFRelease(bundleURL);
}
//otherwise, try Resources/ directory of Ogre Framework bundle
if (!bundle)
{
bundleURL = CFBundleCopyResourceURL(baseBundle, nameRef, CFSTR("bundle"), NULL);
if (bundleURL)
{
bundle = CFBundleCreate(NULL, bundleURL);
CFRelease(bundleURL);
}
}
CFRelease(nameRef);
if (bundle)
{
if (CFBundleLoadExecutable(bundle))
return bundle;
else
CFRelease(bundle);
}
return 0;
}
void transfer_callback(CFDictionaryRef dict, int arg) {
int percent;
CFStringRef status = CFDictionaryGetValue(dict, CFSTR("Status"));
CFNumberGetValue(CFDictionaryGetValue(dict, CFSTR("PercentComplete")), kCFNumberSInt32Type, &percent);
if (CFEqual(status, CFSTR("CopyingFile"))) {
CFStringRef path = CFDictionaryGetValue(dict, CFSTR("Path"));
if ((last_path == NULL || !CFEqual(path, last_path)) && !CFStringHasSuffix(path, CFSTR(".ipa"))) {
printf("[%3d%%] Copying %s to device\n", percent / 2, CFStringGetCStringPtr(path, kCFStringEncodingMacRoman));
}
if (last_path != NULL) {
CFRelease(last_path);
}
last_path = CFStringCreateCopy(NULL, path);
}
}
CFStringRef _CFErrorCreateDebugDescription(CFErrorRef err) {
CFStringRef desc = CFErrorCopyDescription(err);
CFStringRef debugDesc = _CFErrorCopyUserInfoKey(err, kCFErrorDebugDescriptionKey);
CFDictionaryRef userInfo = _CFErrorGetUserInfo(err);
CFMutableStringRef result = CFStringCreateMutable(kCFAllocatorSystemDefault, 0);
CFStringAppendFormat(result, NULL, CFSTR("Error Domain=%@ Code=%d"), CFErrorGetDomain(err), (long)CFErrorGetCode(err));
CFStringAppendFormat(result, NULL, CFSTR(" \"%@\""), desc);
if (debugDesc && CFStringGetLength(debugDesc) > 0) CFStringAppendFormat(result, NULL, CFSTR(" (%@)"), debugDesc);
if (userInfo) {
CFStringAppendFormat(result, NULL, CFSTR(" UserInfo=%p {"), userInfo);
CFDictionaryApplyFunction(userInfo, userInfoKeyValueShow, (void *)result);
CFIndex commaLength = (CFStringHasSuffix(result, CFSTR(", "))) ? 2 : 0;
CFStringReplace(result, CFRangeMake(CFStringGetLength(result)-commaLength, commaLength), CFSTR("}"));
}
if (debugDesc) CFRelease(debugDesc);
if (desc) CFRelease(desc);
return result;
}
Image JUCE_API getIconFromApplication (const String& applicationPath, const int size)
{
Image hostIcon;
if (CFStringRef pathCFString = CFStringCreateWithCString (kCFAllocatorDefault, applicationPath.toRawUTF8(), kCFStringEncodingUTF8))
{
if (CFURLRef url = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, pathCFString, kCFURLPOSIXPathStyle, 1))
{
if (CFBundleRef appBundle = CFBundleCreate (kCFAllocatorDefault, url))
{
if (CFTypeRef infoValue = CFBundleGetValueForInfoDictionaryKey (appBundle, CFSTR("CFBundleIconFile")))
{
if (CFGetTypeID (infoValue) == CFStringGetTypeID())
{
CFStringRef iconFilename = reinterpret_cast<CFStringRef> (infoValue);
CFStringRef resourceURLSuffix = CFStringHasSuffix (iconFilename, CFSTR(".icns")) ? nullptr : CFSTR("icns");
if (CFURLRef iconURL = CFBundleCopyResourceURL (appBundle, iconFilename, resourceURLSuffix, nullptr))
{
if (CFStringRef iconPath = CFURLCopyFileSystemPath (iconURL, kCFURLPOSIXPathStyle))
{
File icnsFile (CFStringGetCStringPtr (iconPath, CFStringGetSystemEncoding()));
hostIcon = getIconFromIcnsFile (icnsFile, size);
CFRelease (iconPath);
}
CFRelease (iconURL);
}
}
}
CFRelease (appBundle);
}
CFRelease (url);
}
CFRelease (pathCFString);
}
return hostIcon;
}
static CFStringRef _copyStringFromTable(CFBundleRef bundle, CFStringRef tableName, CFStringRef key, CFStringRef localizationName) {
// Check the cache first. If it's not there, populate the cache and check again.
__CFLock(&bundle->_lock);
// Only consult the cache when a specific localization has not been requested. We only cache results for the preferred language as determined by normal bundle lookup rules.
if (!localizationName && bundle->_stringTable) {
CFDictionaryRef stringTable = (CFDictionaryRef)CFDictionaryGetValue(bundle->_stringTable, tableName);
if (stringTable) {
CFStringRef result = CFDictionaryGetValue(stringTable, key);
if (result) {
CFRetain(result);
}
__CFUnlock(&bundle->_lock);
return result;
}
}
// Not in the local cache, so load the table. Unlock so we don't hold the lock across file system access.
__CFUnlock(&bundle->_lock);
CFDictionaryRef stringsTable = NULL;
CFURLRef stringsTableURL = NULL;
CFURLRef stringsDictTableURL = NULL;
// Find the resource URL.
if (localizationName) {
stringsTableURL = CFBundleCopyResourceURLForLocalization(bundle, tableName, _CFBundleStringTableType, NULL, localizationName);
stringsDictTableURL = CFBundleCopyResourceURLForLocalization(bundle, tableName, _CFBundleStringDictTableType, NULL, localizationName);
} else {
stringsTableURL = CFBundleCopyResourceURL(bundle, tableName, _CFBundleStringTableType, NULL);
stringsDictTableURL = CFBundleCopyResourceURL(bundle, tableName, _CFBundleStringDictTableType, NULL);
}
// Next, look on disk for the regular strings file.
if (!stringsTable && stringsTableURL) {
CFDataRef tableData = _CFDataCreateFromURL(stringsTableURL, NULL);
if (tableData) {
CFErrorRef error = NULL;
stringsTable = (CFDictionaryRef)CFPropertyListCreateWithData(CFGetAllocator(bundle), tableData, kCFPropertyListImmutable, NULL, &error);
CFRelease(tableData);
if (stringsTable && CFDictionaryGetTypeID() != CFGetTypeID(stringsTable)) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .strings file: %@ / %@: Top-level object was not a dictionary", bundle, tableName);
CFRelease(stringsTable);
stringsTable = NULL;
} else if (!stringsTable && error) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .strings file: %@ / %@: %@", bundle, tableName, error);
CFRelease(error);
error = NULL;
}
}
}
// Check for a .stringsdict file.
if (stringsDictTableURL) {
CFDataRef tableData = _CFDataCreateFromURL(stringsDictTableURL, NULL);
if (tableData) {
CFErrorRef error = NULL;
CFDictionaryRef stringsDictTable = (CFDictionaryRef)CFPropertyListCreateWithData(CFGetAllocator(bundle), tableData, kCFPropertyListImmutable, NULL, &error);
CFRelease(tableData);
if (!stringsDictTable && error) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .stringsdict file: %@ / %@: %@", bundle, tableName, error);
CFRelease(error);
error = NULL;
} else if (stringsDictTable && CFDictionaryGetTypeID() != CFGetTypeID(stringsDictTable)) {
os_log_error(_CFBundleLocalizedStringLogger(), "Unable to load .stringsdict file: %@ / %@: Top-level object was not a dictionary", bundle, tableName);
CFRelease(stringsDictTable);
stringsDictTable = NULL;
} else if (stringsDictTable) {
// Post-process the strings table.
CFMutableDictionaryRef mutableStringsDictTable;
if (stringsTable) {
// Any strings that are in the stringsTable that are not in the stringsDict must be added to the stringsDict.
// However, any entry in the stringsDictTable must override the content from stringsTable.
// Start by copying the stringsTable.
mutableStringsDictTable = CFDictionaryCreateMutableCopy(NULL, 0, stringsTable);
// Replace any stringsTable entries with entries from stringsDictTable. This will override any entries from the original stringsTable if they existed.
CFDictionaryApplyFunction(stringsDictTable, __CFStringsDictMergeApplyFunction, mutableStringsDictTable);
} else {
// Start with a copy of the stringsDictTable on its own.
mutableStringsDictTable = CFDictionaryCreateMutableCopy(NULL, 0, stringsDictTable);
}
CFRelease(stringsDictTable);
if (stringsTable) CFRelease(stringsTable);
// The new strings table is the result of all the transforms above.
stringsTable = mutableStringsDictTable;
}
}
}
if (stringsTableURL) CFRelease(stringsTableURL);
if (stringsDictTableURL) CFRelease(stringsDictTableURL);
// Last resort: create an empty table
if (!stringsTable) {
os_log_debug(_CFBundleLocalizedStringLogger(), "Hit last resort and creating empty strings table");
stringsTable = CFDictionaryCreate(CFGetAllocator(bundle), NULL, NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
}
// Insert the result into our local cache
if ((!CFStringHasSuffix(tableName, CFSTR(".nocache")) || !_CFExecutableLinkedOnOrAfter(CFSystemVersionLeopard)) && localizationName == NULL) {
// Take lock again, because this we will unlock after getting the value out of the table.
__CFLock(&bundle->_lock);
if (!bundle->_stringTable) bundle->_stringTable = CFDictionaryCreateMutable(CFGetAllocator(bundle), 0, &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
// If another thread beat us to setting this tableName, then we'll just replace it here.
CFDictionarySetValue(bundle->_stringTable, tableName, stringsTable);
} else {
// Take lock again, because this we will unlock after getting the value out of the table.
__CFLock(&bundle->_lock);
}
// Finally, fetch the result from the table
CFStringRef result = CFDictionaryGetValue(stringsTable, key);
if (result) {
CFRetain(result);
}
__CFUnlock(&bundle->_lock);
CFRelease(stringsTable);
return result;
}
__private_extern__ CFArrayRef _CFPreferencesCreateDomainList(CFStringRef userName, CFStringRef hostName) {
CFAllocatorRef prefAlloc = __CFPreferencesAllocator();
CFArrayRef domains;
CFMutableArrayRef marray;
CFStringRef *cachedDomainKeys;
CFPreferencesDomainRef *cachedDomains;
SInt32 idx, cnt;
CFStringRef suffix;
UInt32 suffixLen;
CFURLRef prefDir = _preferencesDirectoryForUserHost(userName, hostName);
if (!prefDir) {
return NULL;
}
if (hostName == kCFPreferencesAnyHost) {
suffix = CFStringCreateWithCString(prefAlloc, ".plist", kCFStringEncodingASCII);
} else if (hostName == kCFPreferencesCurrentHost) {
CFStringRef hostID = _CFPreferencesGetByHostIdentifierString();
suffix = CFStringCreateWithFormat(prefAlloc, NULL, CFSTR(".%@.plist"), hostID);
} else {
suffix = CFStringCreateWithFormat(prefAlloc, NULL, CFSTR(".%@.plist"), hostName); // sketchy - this allows someone to create a domain list for an arbitrary hostname.
}
suffixLen = CFStringGetLength(suffix);
domains = (CFArrayRef)CFURLCreatePropertyFromResource(prefAlloc, prefDir, kCFURLFileDirectoryContents, NULL);
CFRelease(prefDir);
if (domains){
marray = CFArrayCreateMutableCopy(prefAlloc, 0, domains);
CFRelease(domains);
} else {
marray = CFArrayCreateMutable(prefAlloc, 0, & kCFTypeArrayCallBacks);
}
for (idx = CFArrayGetCount(marray)-1; idx >= 0; idx --) {
CFURLRef url = (CFURLRef)CFArrayGetValueAtIndex(marray, idx);
CFStringRef string = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
if (!CFStringHasSuffix(string, suffix)) {
CFArrayRemoveValueAtIndex(marray, idx);
} else {
CFStringRef dom = CFStringCreateWithSubstring(prefAlloc, string, CFRangeMake(0, CFStringGetLength(string) - suffixLen));
if (CFEqual(dom, CFSTR(".GlobalPreferences"))) {
CFArraySetValueAtIndex(marray, idx, kCFPreferencesAnyApplication);
} else {
CFArraySetValueAtIndex(marray, idx, dom);
}
CFRelease(dom);
}
CFRelease(string);
}
CFRelease(suffix);
// Now add any domains added in the cache; delete any that have been deleted in the cache
__CFSpinLock(&domainCacheLock);
if (!domainCache) {
__CFSpinUnlock(&domainCacheLock);
return marray;
}
cnt = CFDictionaryGetCount(domainCache);
cachedDomainKeys = (CFStringRef *)CFAllocatorAllocate(prefAlloc, 2 * cnt * sizeof(CFStringRef), 0);
cachedDomains = (CFPreferencesDomainRef *)(cachedDomainKeys + cnt);
CFDictionaryGetKeysAndValues(domainCache, (const void **)cachedDomainKeys, (const void **)cachedDomains);
__CFSpinUnlock(&domainCacheLock);
suffix = _CFPreferencesCachePrefixForUserHost(userName, hostName);
suffixLen = CFStringGetLength(suffix);
for (idx = 0; idx < cnt; idx ++) {
CFStringRef domainKey = cachedDomainKeys[idx];
CFPreferencesDomainRef domain = cachedDomains[idx];
CFStringRef domainName;
CFIndex keyCount = 0;
if (!CFStringHasPrefix(domainKey, suffix)) continue;
domainName = CFStringCreateWithSubstring(prefAlloc, domainKey, CFRangeMake(suffixLen, CFStringGetLength(domainKey) - suffixLen));
if (CFEqual(domainName, CFSTR("*"))) {
CFRelease(domainName);
domainName = (CFStringRef)CFRetain(kCFPreferencesAnyApplication);
} else if (CFEqual(domainName, kCFPreferencesCurrentApplication)) {
CFRelease(domainName);
domainName = (CFStringRef)CFRetain(_CFProcessNameString());
}
CFDictionaryRef d = _CFPreferencesDomainDeepCopyDictionary(domain);
keyCount = d ? CFDictionaryGetCount(d) : 0;
if (keyCount) CFRelease(d);
if (keyCount == 0) {
// Domain was deleted
SInt32 firstIndexOfValue = CFArrayGetFirstIndexOfValue(marray, CFRangeMake(0, CFArrayGetCount(marray)), domainName);
if (0 <= firstIndexOfValue) {
CFArrayRemoveValueAtIndex(marray, firstIndexOfValue);
}
} else if (!CFArrayContainsValue(marray, CFRangeMake(0, CFArrayGetCount(marray)), domainName)) {
CFArrayAppendValue(marray, domainName);
}
CFRelease(domainName);
}
CFRelease(suffix);
CFAllocatorDeallocate(prefAlloc, cachedDomainKeys);
return marray;
}
static CFComparisonResult
compareDomain(const void *val1, const void *val2, void *context)
{
CFDictionaryRef proxy1 = (CFDictionaryRef)val1;
CFDictionaryRef proxy2 = (CFDictionaryRef)val2;
CFStringRef domain1;
CFStringRef domain2;
CFArrayRef labels1 = NULL;
CFArrayRef labels2 = NULL;
CFIndex n1;
CFIndex n2;
CFComparisonResult result;
Boolean rev1;
Boolean rev2;
// "default" domains sort before "supplemental" domains
domain1 = CFDictionaryGetValue(proxy1, kSCPropNetProxiesSupplementalMatchDomain);
domain2 = CFDictionaryGetValue(proxy2, kSCPropNetProxiesSupplementalMatchDomain);
if (domain1 == NULL) {
if (domain2 == NULL) {
return kCFCompareEqualTo;
}
return kCFCompareLessThan;
} else if (domain2 == NULL) {
return kCFCompareGreaterThan;
}
// forward (A, AAAA) domains sort before reverse (PTR) domains
rev1 = CFStringHasSuffix(domain1, CFSTR(".arpa"));
rev2 = CFStringHasSuffix(domain2, CFSTR(".arpa"));
if (rev1 != rev2) {
if (rev1) {
return kCFCompareGreaterThan;
} else {
return kCFCompareLessThan;
}
}
labels1 = CFStringCreateArrayBySeparatingStrings(NULL, domain1, CFSTR("."));
n1 = CFArrayGetCount(labels1);
labels2 = CFStringCreateArrayBySeparatingStrings(NULL, domain2, CFSTR("."));
n2 = CFArrayGetCount(labels2);
while ((n1 > 0) && (n2 > 0)) {
CFStringRef label1 = CFArrayGetValueAtIndex(labels1, --n1);
CFStringRef label2 = CFArrayGetValueAtIndex(labels2, --n2);
// compare domain labels
result = CFStringCompare(label1, label2, kCFCompareCaseInsensitive);
if (result != kCFCompareEqualTo) {
goto done;
}
}
// longer labels (corp.apple.com) sort before shorter labels (apple.com)
if (n1 > n2) {
result = kCFCompareLessThan;
goto done;
} else if (n1 < n2) {
result = kCFCompareGreaterThan;
goto done;
}
// sort by search order
result = compareBySearchOrder(val1, val2, context);
done :
if (labels1 != NULL) CFRelease(labels1);
if (labels2 != NULL) CFRelease(labels2);
return result;
}
OSStatus LLFilePicker::doNavSaveDialog(ESaveFilter filter, const std::string& filename)
{
OSStatus error = noErr;
NavDialogRef navRef = NULL;
NavReplyRecord navReply;
memset(&navReply, 0, sizeof(navReply));
// Setup the type, creator, and extension
OSType type, creator;
CFStringRef extension = NULL;
switch (filter)
{
case FFSAVE_WAV:
type = 'WAVE';
creator = 'TVOD';
extension = CFSTR(".wav");
break;
case FFSAVE_TGA:
type = 'TPIC';
creator = 'prvw';
extension = CFSTR(".tga");
break;
case FFSAVE_BMP:
type = 'BMPf';
creator = 'prvw';
extension = CFSTR(".bmp");
break;
case FFSAVE_JPEG:
type = 'JPEG';
creator = 'prvw';
extension = CFSTR(".jpeg");
break;
case FFSAVE_PNG:
type = 'PNG ';
creator = 'prvw';
extension = CFSTR(".png");
break;
case FFSAVE_AVI:
type = '\?\?\?\?';
creator = '\?\?\?\?';
extension = CFSTR(".mov");
break;
case FFSAVE_ANIM:
type = '\?\?\?\?';
creator = '\?\?\?\?';
extension = CFSTR(".xaf");
break;
#ifdef _CORY_TESTING
case FFSAVE_GEOMETRY:
type = '\?\?\?\?';
creator = '\?\?\?\?';
extension = CFSTR(".slg");
break;
#endif
case FFSAVE_RAW:
type = '\?\?\?\?';
creator = '\?\?\?\?';
extension = CFSTR(".raw");
break;
case FFSAVE_J2C:
type = '\?\?\?\?';
creator = 'prvw';
extension = CFSTR(".j2c");
break;
case FFSAVE_ALL:
default:
type = '\?\?\?\?';
creator = '\?\?\?\?';
extension = CFSTR("");
break;
}
// Create the dialog
error = NavCreatePutFileDialog(&mNavOptions, type, creator, NULL, NULL, &navRef);
if (error == noErr)
{
CFStringRef nameString = NULL;
bool hasExtension = true;
// Create a CFString of the initial file name
if (!filename.empty())
nameString = CFStringCreateWithCString(NULL, filename.c_str(), kCFStringEncodingUTF8);
else
nameString = CFSTR("Untitled");
// Add the extension if one was not provided
if (nameString && !CFStringHasSuffix(nameString, extension))
{
CFStringRef tempString = nameString;
hasExtension = false;
nameString = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@%@"), tempString, extension);
CFRelease(tempString);
}
// Set the name in the dialog
if (nameString)
{
error = NavDialogSetSaveFileName(navRef, nameString);
CFRelease(nameString);
}
else
{
error = paramErr;
}
}
gViewerWindow->mWindow->beforeDialog();
// Run the dialog
if (error == noErr)
error = NavDialogRun(navRef);
gViewerWindow->mWindow->afterDialog();
if (error == noErr)
error = NavDialogGetReply(navRef, &navReply);
if (navRef)
NavDialogDispose(navRef);
if (error == noErr && navReply.validRecord)
{
SInt32 count = 0;
// AE indexes are 1 based...
error = AECountItems(&navReply.selection, &count);
if (count > 0)
{
// Get the FSRef to the containing folder
FSRef fsRef;
AEKeyword theAEKeyword;
DescType typeCode;
Size actualSize = 0;
memset(&fsRef, 0, sizeof(fsRef));
error = AEGetNthPtr(&navReply.selection, 1, typeFSRef, &theAEKeyword, &typeCode, &fsRef, sizeof(fsRef), &actualSize);
if (error == noErr)
{
char path[PATH_MAX]; /*Flawfinder: ignore*/
char newFileName[SINGLE_FILENAME_BUFFER_SIZE]; /*Flawfinder: ignore*/
error = FSRefMakePath(&fsRef, (UInt8*)path, PATH_MAX);
if (error == noErr)
{
if (CFStringGetCString(navReply.saveFileName, newFileName, sizeof(newFileName), kCFStringEncodingUTF8))
{
mFiles.push_back(std::string(path) + "/" + std::string(newFileName));
}
else
{
error = paramErr;
}
}
else
{
error = paramErr;
}
}
}
}
return error;
}
int
checkVPNInterfaceOrServiceBlocked (const char *location,
char *interface_buf)
{
// check to see if interface is captive: if so, bail if the interface is not ready.
if (check_interface_captive_and_not_ready(gDynamicStore, interface_buf)) {
// TODO: perhaps we should wait for a few seconds?
return true;
}
// return 1, if this is a delete event, and;
// TODO: add support for IPv6 <rdar://problem/5920237>
// walk Setup:/Network/Service/* and check if there are service entries referencing this interface. e.g. Setup:/Network/Service/44DB8790-0177-4F17-8D4E-37F9413D1D87/Interface:DeviceName == interface, other_serv_found = 1
// Setup:/Network/Interface/"interface"/AirPort:'PowerEnable' == 0 || Setup:/Network/Interface/"interface"/IPv4 is missing, interf_down = 1
if (gDynamicStore) {
CFStringRef interf_key;
CFMutableArrayRef interf_keys;
CFStringRef pattern;
CFMutableArrayRef patterns;
CFDictionaryRef dict = NULL;
CFIndex i;
const void * keys_q[128];
const void ** keys = keys_q;
const void * values_q[128];
const void ** values = values_q;
CFIndex n;
CFStringRef vpn_if;
int other_serv_found = 0, interf_down = 0;
vpn_if = CFStringCreateWithCStringNoCopy(NULL,
interface_buf,
kCFStringEncodingASCII,
kCFAllocatorNull);
if (!vpn_if) {
// if we could not initialize interface CFString
syslog(LOG_NOTICE, "%s: failed to initialize interface CFString", location);
goto done;
}
interf_keys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
// get Setup:/Network/Interface/<vpn_if>/Airport
interf_key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
kSCDynamicStoreDomainSetup,
vpn_if,
kSCEntNetAirPort);
CFArrayAppendValue(interf_keys, interf_key);
CFRelease(interf_key);
// get State:/Network/Interface/<vpn_if>/Airport
interf_key = SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL,
kSCDynamicStoreDomainState,
vpn_if,
kSCEntNetAirPort);
CFArrayAppendValue(interf_keys, interf_key);
CFRelease(interf_key);
// get Setup:/Network/Service/*/Interface
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainSetup,
kSCCompAnyRegex,
kSCEntNetInterface);
CFArrayAppendValue(patterns, pattern);
CFRelease(pattern);
// get Setup:/Network/Service/*/IPv4
pattern = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
kSCDynamicStoreDomainSetup,
kSCCompAnyRegex,
kSCEntNetIPv4);
CFArrayAppendValue(patterns, pattern);
CFRelease(pattern);
dict = SCDynamicStoreCopyMultiple(gDynamicStore, interf_keys, patterns);
CFRelease(interf_keys);
CFRelease(patterns);
if (!dict) {
// if we could not access the SCDynamicStore
syslog(LOG_NOTICE, "%s: failed to initialize SCDynamicStore dictionary", location);
CFRelease(vpn_if);
goto done;
}
// look for the service which matches the provided prefixes
n = CFDictionaryGetCount(dict);
if (n <= 0) {
syslog(LOG_NOTICE, "%s: empty SCDynamicStore dictionary", location);
CFRelease(vpn_if);
goto done;
}
if (n > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
keys = CFAllocatorAllocate(NULL, n * sizeof(CFTypeRef), 0);
values = CFAllocatorAllocate(NULL, n * sizeof(CFTypeRef), 0);
}
CFDictionaryGetKeysAndValues(dict, keys, values);
for (i=0; i < n; i++) {
CFStringRef s_key = (CFStringRef)keys[i];
CFDictionaryRef s_dict = (CFDictionaryRef)values[i];
CFStringRef s_if;
if (!isA_CFString(s_key) || !isA_CFDictionary(s_dict)) {
continue;
}
if (CFStringHasSuffix(s_key, kSCEntNetInterface)) {
// is a Service Interface entity
s_if = CFDictionaryGetValue(s_dict, kSCPropNetInterfaceDeviceName);
if (isA_CFString(s_if) && CFEqual(vpn_if, s_if)) {
CFArrayRef components;
CFStringRef serviceIDRef = NULL, serviceKey = NULL;
other_serv_found = 1;
// extract service ID
components = CFStringCreateArrayBySeparatingStrings(NULL, s_key, CFSTR("/"));
if (CFArrayGetCount(components) > 3) {
serviceIDRef = CFArrayGetValueAtIndex(components, 3);
//if (new key) Setup:/Network/Service/service_id/IPv4 is missing, then interf_down = 1
serviceKey = SCDynamicStoreKeyCreateNetworkServiceEntity(0, kSCDynamicStoreDomainSetup, serviceIDRef, kSCEntNetIPv4);
if (!serviceKey ||
!CFDictionaryGetValue(dict, serviceKey)) {
syslog(LOG_NOTICE, "%s: detected disabled IPv4 Config", location);
interf_down = 1;
}
if (serviceKey) CFRelease(serviceKey);
}
if (components) CFRelease(components);
if (interf_down) break;
}
continue;
} else if (CFStringHasSuffix(s_key, kSCEntNetAirPort)) {
// Interface/<vpn_if>/Airport entity
if (CFStringHasPrefix(s_key, kSCDynamicStoreDomainSetup)) {
CFBooleanRef powerEnable = CFDictionaryGetValue(s_dict, kSCPropNetAirPortPowerEnabled);
if (isA_CFBoolean(powerEnable) &&
CFEqual(powerEnable, kCFBooleanFalse)) {
syslog(LOG_NOTICE, "%s: detected AirPort, PowerEnable == FALSE", location);
interf_down = 1;
break;
}
} else if (CFStringHasPrefix(s_key, kSCDynamicStoreDomainState)) {
UInt16 temp;
CFNumberRef airStatus = CFDictionaryGetValue(s_dict, CFSTR("Power Status"));
if (isA_CFNumber(airStatus) &&
CFNumberGetValue(airStatus, kCFNumberShortType, &temp)) {
if (temp ==0) {
syslog(LOG_NOTICE, "%s: detected AirPort, PowerStatus == 0", location);
}
}
}
continue;
}
}
if (vpn_if) CFRelease(vpn_if);
if (keys != keys_q) {
CFAllocatorDeallocate(NULL, keys);
CFAllocatorDeallocate(NULL, values);
}
done :
if (dict) CFRelease(dict);
return (other_serv_found == 0 || interf_down == 1);
}
return 0;
}
static void addShareToDictionary(SMBHANDLE inConnection,
CFMutableDictionaryRef shareDict,
CFStringRef shareName, CFStringRef comments,
u_int16_t shareType, struct statfs *fs, int fs_cnt)
{
CFMutableDictionaryRef currDict = NULL;
CFRange foundSlash;
CFRange foundPercentSign;
CFStringRef tempShareName1 = NULL;
CFStringRef tempShareName2 = NULL;
if (shareName == NULL) {
return;
}
currDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
if (currDict == NULL) {
/* Log error here, but keep going */
SMBLogInfo("addShareToDictionary: Couldn't create the dictionary!", ASL_LEVEL_DEBUG);
return;
}
if (CFStringHasSuffix(shareName, CFSTR("$"))) {
CFDictionarySetValue (currDict, kNetFSIsHiddenKey, kCFBooleanTrue);
}
if (comments) {
CFDictionarySetValue (currDict, kNetCommentStrKey, comments);
}
switch (shareType) {
case SMB_ST_DISK:
CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Disk"));
/* Now check to see if this share is already mounted */
if (fs) {
/* We only care if its already mounted ignore any other errors for now */
if (SMBCheckForAlreadyMountedShare(inConnection, shareName, currDict, fs, fs_cnt) == EEXIST) {
CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanTrue);
} else {
CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse);
}
}
break;
case SMB_ST_PRINTER:
CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Printer"));
CFDictionarySetValue (currDict, kNetFSPrinterShareKey, kCFBooleanTrue);
CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse);
break;
case SMB_ST_PIPE:
CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Pipe"));
CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse);
break;
case SMB_ST_COMM:
CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Comm"));
CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse);
break;
default:
CFDictionarySetValue (currDict, kNetShareTypeStrKey, CFSTR("Unknown"));
CFDictionarySetValue (currDict, kNetFSAlreadyMountedKey, kCFBooleanFalse);
break;
}
CFDictionarySetValue (currDict, kNetFSHasPasswordKey, kCFBooleanFalse);
/* Check for a '/' or '%' in the share name */
foundSlash = CFStringFind (shareName, CFSTR("/"), 0);
foundPercentSign = CFStringFind (shareName, CFSTR("%"), 0);
if ( (foundSlash.location != kCFNotFound) || (foundPercentSign.location != kCFNotFound) ) {
/* found a '/' or '%' in the name, so set a disply name to be used */
CFDictionarySetValue (currDict, kNetFSDisplayNameKey, shareName);
/* escape the vol name to get '/' converted to %2f and '%' to %25 */
tempShareName1 = CFURLCreateStringByAddingPercentEscapes(NULL, shareName, NULL, CFSTR("/%"), kCFStringEncodingUTF8);
/* re-escape it leaving the '/' as %2f and '%' as %25 */
tempShareName2 = CFURLCreateStringByReplacingPercentEscapesUsingEncoding(NULL, tempShareName1, CFSTR("/%"), kCFStringEncodingUTF8);
CFDictionarySetValue (shareDict, tempShareName2, currDict);
CFRelease (tempShareName1);
CFRelease (tempShareName2);
}
else {
CFDictionarySetValue (shareDict, shareName, currDict);
}
CFRelease (currDict);
}
int ListTrackFiles (FSVolumeRefNum theVolume, FSRef *trackFiles, int numTracks)
{
OSStatus result = -1;
FSIterator iterator;
ItemCount actualObjects;
FSRef rootDirectory;
FSRef ref;
HFSUniStr255 nameStr;
result = FSGetVolumeInfo (theVolume,
0,
NULL,
kFSVolInfoFSInfo,
NULL,
NULL,
&rootDirectory);
if (result != noErr) {
SDL_SetError ("ListTrackFiles: FSGetVolumeInfo returned %d", result);
return result;
}
result = FSOpenIterator (&rootDirectory, kFSIterateFlat, &iterator);
if (result == noErr) {
do
{
result = FSGetCatalogInfoBulk (iterator, 1, &actualObjects,
NULL, kFSCatInfoNone, NULL, &ref, NULL, &nameStr);
if (result == noErr) {
CFStringRef name;
name = CFStringCreateWithCharacters (NULL, nameStr.unicode, nameStr.length);
if (CFStringHasSuffix (name, CFSTR(".aiff")) ||
CFStringHasSuffix (name, CFSTR(".cdda"))) {
int trackID = 0, i = 0;
while (i < nameStr.length && !isdigit(nameStr.unicode[i])) {
++i;
}
while (i < nameStr.length && isdigit(nameStr.unicode[i])) {
trackID = 10 * trackID +(nameStr.unicode[i] - '0');
++i;
}
#if DEBUG_CDROM
printf("Found AIFF for track %d: '%s'\n", trackID,
CFStringGetCStringPtr (name, CFStringGetSystemEncoding()));
#endif
trackID--;
assert(0 <= trackID && trackID <= SDL_MAX_TRACKS);
if (trackID < numTracks)
memcpy (&trackFiles[trackID], &ref, sizeof(FSRef));
}
CFRelease (name);
}
} while(noErr == result);
FSCloseIterator (iterator);
}
return 0;
}
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;
}
CFStringRef
CopyNextWorkstationName(SCDynamicStoreRef store, CFStringRef currentName)
{
CFMutableStringRef computerName = NULL;
CFStringRef macAddress = NULL;
if (currentName) {
/* Sanity check to make sure the current Workstation name is longer than the length of a MAC address string */
CFIndex totalLengh = CFStringGetLength(currentName);
if (totalLengh >= (CFIndex)kMACAddressLengh) {
/* Create a substring that chops off the MAC addres, giving us the Computer Name */
CFRange range = CFRangeMake(0, totalLengh - kMACAddressLengh);
CFStringRef oldComputerName = CFStringCreateWithSubstring(NULL, currentName, range);
/* If the Computer Name contains a trailing close paren it means that this name may have
already experienced a name conflict which means it could have a trailing digit to increment */
if (CFStringHasSuffix(oldComputerName, CFSTR(")"))) {
CFRange result;
/* Search for the first open paren, starting the search from the end of the Computer Name */
if (CFStringFindWithOptions(oldComputerName, CFSTR("("), range, kCFCompareBackwards, &result)) {
/* Create a substring which contains the contents between the open and close paren */
range = CFRangeMake(result.location + 1, CFStringGetLength(oldComputerName) - result.location - 2);
CFStringRef countString = CFStringCreateWithSubstring(NULL, currentName, range);
/* Try converting the substring to an integer */
SInt32 conflictCount = CFStringGetIntValue(countString);
if (conflictCount) {
/* Create a substring of just the Computer Name without the trailing open paren, conflict integer, close paren */
range = CFRangeMake(0, result.location);
CFStringRef tempComputerName = CFStringCreateWithSubstring(NULL, oldComputerName, range);
/* Create a mutable copy of the Computer Name base substring */
computerName = CFStringCreateMutableCopy(NULL, 0, tempComputerName);
/* Create a string containing a space, open paren, previous conflict digit incremented by one, close paren */
CFStringRef numberString = CFStringCreateWithFormat(NULL, NULL, CFSTR(" (%d)"), ++conflictCount);
/* Truncate the Computer Name base as neccessary to ensure we can append the conflict digits */
CFStringTruncateToUTF8Length(computerName, kMaxComputerName - CFStringGetLength(numberString));
/* Append the incremented conflict digit to the Computer Name base string */
CFStringAppend(computerName, numberString);
}
}
}
/* If computerName is NULL it means that the previous Computer Name didn't contain any conflict digits so append a " (2)" */
if (!computerName) {
/* Create mutable copy of previous Computer Name */
computerName = CFStringCreateMutableCopy(NULL, 0, oldComputerName);
/* Make sure we have enough room to append 4 characters to the name by truncating the Computer Name if neccessary */
CFStringTruncateToUTF8Length(computerName, kMaxComputerName - 4);
/* Append the name conflict digits */
CFStringAppend(computerName, CFSTR(" (2)"));
}
CFRelease(oldComputerName);
} else {
DbgLog( kLogError, "Workstation name is shorter than a MAC address which shouldn't be possible" );
}
} else {
/* There's currently no registered Workstation name so get the Computer Name from the dynamic store */
CFStringRef tempName = SCDynamicStoreCopyComputerName(store, NULL);
if (tempName) {
/* Create a mutable copy of the Computer Name */
computerName = CFStringCreateMutableCopy(NULL, 0, tempName);
CFRelease(tempName);
/* Truncate the Computer Name to ensure we can append the MAC address */
CFStringTruncateToUTF8Length(computerName, kMaxComputerName);
} else {
return NULL;
}
}
/* Copy the primary MAC address string */
macAddress = CopyPrimaryMacAddress();
if (!macAddress) {
if (computerName) {
CFRelease(computerName);
}
return NULL;
}
/* Append a space */
CFStringAppend(computerName, CFSTR(" "));
/* Append the MAC address string */
CFStringAppend(computerName, macAddress);
CFRelease(macAddress);
return computerName;
}
