static inline const char *
_bs_main_bundle_bs_path(void)
{
static bool done = false;
static char *path = NULL;
/* XXX not thread-safe */
if (!done) {
CFBundleRef bundle;
done = true;
bundle = CFBundleGetMainBundle();
if (bundle != NULL) {
CFURLRef url;
url = CFBundleCopyResourceURL(bundle, CFSTR("BridgeSupport"),
NULL, NULL);
if (url != NULL) {
CFStringRef str = CFURLCopyPath(url);
path = (char *)malloc(sizeof(char) * PATH_MAX);
ASSERT_ALLOC(path);
CFStringGetFileSystemRepresentation(str, path, PATH_MAX);
CFRelease(str);
CFRelease(url);
}
}
}
return path;
}
// Asssumes caller already knows the directory doesn't exist.
static Boolean _createDirectory(CFURLRef dirURL, Boolean worldReadable) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
CFURLRef parentURL = CFURLCreateCopyDeletingLastPathComponent(alloc, dirURL);
CFBooleanRef val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, parentURL, kCFURLFileExists, NULL);
Boolean parentExists = (val && CFBooleanGetValue(val));
SInt32 mode;
Boolean result;
if (val) CFRelease(val);
if (!parentExists) {
CFStringRef path = CFURLCopyPath(parentURL);
if (!CFEqual(path, CFSTR("/"))) {
_createDirectory(parentURL, worldReadable);
val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, parentURL, kCFURLFileExists, NULL);
parentExists = (val && CFBooleanGetValue(val));
if (val) CFRelease(val);
}
CFRelease(path);
}
if (parentURL) CFRelease(parentURL);
if (!parentExists) return false;
#if TARGET_OS_OSX || TARGET_OS_LINUX
mode = worldReadable ? S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH : S_IRWXU;
#else
mode = 0666;
#endif
result = CFURLWriteDataAndPropertiesToResource(dirURL, (CFDataRef)dirURL, URLPropertyDictForPOSIXMode(mode), NULL);
URLPropertyDictRelease();
return result;
}
const char *
sys_runtime_dir(void)
{
if (_nix_runtime_dir[0] == 0x0) {
#if defined(_IOS)
CFURLRef url = CFCopyHomeDirectoryURL();
CFStringRef path = CFURLCopyPath(url);
memset(_nix_tmp_buff, 0x0, PATH_MAX);
CFStringGetCString(path, _nix_tmp_buff, PATH_MAX, kCFStringEncodingUTF8);
CFRelease(path);
CFRelease(url);
snprintf(_nix_cache_dir, PATH_MAX, "%s/run", _nix_tmp_buff);
#elif defined(__ANDROID__)
#else
snprintf(_nix_runtime_dir, PATH_MAX, "/var/run/%s", _miwa_sys_name);
#endif
if (sys_directory_exists(_nix_runtime_dir) < 0)
sys_create_directory(_nix_runtime_dir);
}
return _nix_runtime_dir;
}
FILE* fopen (const char *filename, const char *mode) {
#ifdef HX_MACOS
FILE *result = ::fopen (filename, "rb");
if (!result) {
CFStringRef str = CFStringCreateWithCString (NULL, filename, kCFStringEncodingUTF8);
CFURLRef path = CFBundleCopyResourceURL (CFBundleGetMainBundle (), str, NULL, NULL);
CFRelease (str);
if (path) {
str = CFURLCopyPath (path);
CFIndex maxSize = CFStringGetMaximumSizeForEncoding (CFStringGetLength (str), kCFStringEncodingUTF8);
char *buffer = (char *)malloc (maxSize);
if (CFStringGetCString (str, buffer, maxSize, kCFStringEncodingUTF8)) {
result = ::fopen (buffer,"rb");
free (buffer);
}
CFRelease (str);
CFRelease (path);
}
}
return result;
#else
return ::fopen (filename, mode);
#endif
}
void fill_pathname_application_path(char *buf, size_t size)
{
size_t i;
(void)i;
if (!size)
return;
#ifdef _WIN32
DWORD ret = GetModuleFileName(GetModuleHandle(NULL), buf, size - 1);
buf[ret] = '\0';
#elif defined(__APPLE__)
CFBundleRef bundle = CFBundleGetMainBundle();
if (bundle)
{
CFURLRef bundle_url = CFBundleCopyBundleURL(bundle);
CFStringRef bundle_path = CFURLCopyPath(bundle_url);
CFStringGetCString(bundle_path, buf, size, kCFStringEncodingUTF8);
CFRelease(bundle_path);
CFRelease(bundle_url);
rarch_assert(strlcat(buf, "nobin", size) < size);
return;
}
#elif defined(__HAIKU__)
image_info info;
int32 cookie = 0;
while (get_next_image_info(0, &cookie, &info) == B_OK)
{
if (info.type == B_APP_IMAGE)
{
strlcpy(buf, info.name, size);
return;
}
}
#else
*buf = '\0';
pid_t pid = getpid();
char link_path[PATH_MAX];
/* Linux, BSD and Solaris paths. Not standardized. */
static const char *exts[] = { "exe", "file", "path/a.out" };
for (i = 0; i < ARRAY_SIZE(exts); i++)
{
snprintf(link_path, sizeof(link_path), "/proc/%u/%s",
(unsigned)pid, exts[i]);
ssize_t ret = readlink(link_path, buf, size - 1);
if (ret >= 0)
{
buf[ret] = '\0';
return;
}
}
RARCH_ERR("Cannot resolve application path! This should not happen.\n");
#endif
}
// function provides some Mac OS X specific source code to load files from the resources of the application bundle.
char * resPath(char **argv, char* name, char* type )
{
static char resource[1024];
CFURLRef cfBundleURL = CFBundleCopyResourceURL( CFBundleGetMainBundle(),
CFStringCreateWithCString(kCFAllocatorDefault,name, kCFStringEncodingISOLatin1),
CFStringCreateWithCString(kCFAllocatorDefault,type,kCFStringEncodingISOLatin1),
NULL);
CFStringGetCString( CFURLCopyPath(cfBundleURL),
resource,1023,kCFStringEncodingISOLatin1);
return resource;
}
CRESTRequestRef CRESTRequestCreateWithBytes(UInt8 const *bytes, ssize_t len)
{
CFURLRef url;
CRESTRequestRef request;
CFHTTPMessageRef message;
message = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, true);
request = calloc(1, sizeof(struct CRESTRequest));
assert(request);
bool isAppended = CFHTTPMessageAppendBytes(message, bytes, (CFIndex) len);
bool isComplete = CFHTTPMessageIsHeaderComplete(message);
if( ! ( isAppended && isComplete ) )
{
CFRelease(message);
CRESTRequestDealloc(request);
return NULL;
}
url = CFHTTPMessageCopyRequestURL(message);
CFMutableDictionaryRef params = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFStringRef query = CFURLCopyQueryString(url, NULL);
if( query )
{
parseParams(params, query);
CFRelease(query);
}
CFDataRef bodyData = CFHTTPMessageCopyBody(message);
if( CFDataGetLength(bodyData) )
{
CFStringRef bodyString = CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, bodyData,
kCFStringEncodingUTF8);
parseParams(params, bodyString);
CFRelease(bodyString);
}
CFRelease(bodyData);
request->method = CFHTTPMessageCopyRequestMethod(message);
request->path = CFURLCopyPath(url);
request->params = (CFDictionaryRef) params;
CFRelease(url);
CFRelease(message);
return request;
}
static CFIndex CFURLEnumeratorPushURL(CFURLEnumeratorRef enumerator, CFURLRef url, CFErrorRef *error) {
char path[PATH_MAX] = { 0 };
CFStringRef urlPath = CFURLCopyPath(url);
Boolean success = CFStringGetFileSystemRepresentation(urlPath, path, PATH_MAX);
if (!success) {
cocoaError(error, -1, url, urlPath);
CFRelease(urlPath);
return kCFNotFound;
}
DIR *dir = opendir(path);
if (dir == NULL) {
posixError(error, url, urlPath);
CFRelease(urlPath);
return kCFNotFound;
}
CFMutableArrayRef fileInfos = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
struct dirent *current = NULL;
while ((current = readdir(dir)) != NULL) {
if (strcmp(current->d_name, ".") == 0 || strcmp(current->d_name, "..") == 0) {
continue;
}
CFMutableDictionaryRef fileInfo = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFStringRef fileName = CFStringCreateWithBytes(kCFAllocatorDefault, current->d_name, strlen(current->d_name), kCFStringEncodingUTF8, false);
CFDictionarySetValue(fileInfo, fileInfoNameKey, fileName);
CFDictionarySetValue(fileInfo, fileInfoIsDirKey, current->d_type == DT_DIR ? kCFBooleanTrue : kCFBooleanFalse);
CFArrayAppendValue(fileInfos, fileInfo);
CFRelease(fileName);
CFRelease(fileInfo);
}
CFArraySortValues(fileInfos, CFRangeMake(0, CFArrayGetCount(fileInfos)), _compareFileInfo, nil);
CFArrayAppendValue(enumerator->urlStack, url);
CFArrayAppendValue(enumerator->dirFileInfos, fileInfos);
CFRelease(urlPath);
CFRelease(fileInfos);
closedir(dir);
return CFArrayGetCount(enumerator->urlStack);
}
CF::String URL::GetPath( void )
{
CF::String str;
CFStringRef cfStr;
if( this->_cfObject == NULL )
{
return str;
}
cfStr = CFURLCopyPath( this->_cfObject );
if( cfStr != NULL )
{
str = cfStr;
CFRelease( cfStr );
}
return str;
}
static void
__SCDynamicStoreInitialize(void)
{
CFBundleRef bundle;
/* register with CoreFoundation */
__kSCDynamicStoreTypeID = _CFRuntimeRegisterClass(&__SCDynamicStoreClass);
/* add handler to cleanup after fork() */
(void) pthread_atfork(NULL, NULL, childForkHandler);
/* get the application/executable/bundle name */
bundle = CFBundleGetMainBundle();
if (bundle != NULL) {
_sc_bundleID = CFBundleGetIdentifier(bundle);
if (_sc_bundleID != NULL) {
CFRetain(_sc_bundleID);
} else {
CFURLRef url;
url = CFBundleCopyExecutableURL(bundle);
if (url != NULL) {
_sc_bundleID = CFURLCopyPath(url);
CFRelease(url);
}
}
if (_sc_bundleID != NULL) {
if (CFEqual(_sc_bundleID, CFSTR("/"))) {
CFRelease(_sc_bundleID);
_sc_bundleID = CFStringCreateWithFormat(NULL, NULL, CFSTR("(%d)"), getpid());
}
}
}
return;
}
pid_t StartServer()
{
pid_t pid = fork();
if(pid == 0)
{
CFBundleRef bundle = CFBundleGetMainBundle();
CFURLRef url = CFBundleCopyExecutableURL(bundle);
CFStringRef urlString = CFURLCopyPath(url);
const char *file = CFStringGetCStringPtr(urlString, kCFStringEncodingUTF8);
const char *args[] = { file, "--start", NULL };
execv(file, (char *const *)args);
// Should not be reached, but let's exit gracefully anyway
CFRelease(url);
CFRelease(urlString);
exit(EXIT_FAILURE);
}
return pid;
}
static const char * /* O - Locale string */
appleLangDefault(void)
{
int i; /* Looping var */
CFBundleRef bundle; /* Main bundle (if any) */
CFArrayRef bundleList; /* List of localizations in bundle */
CFPropertyListRef localizationList = NULL;
/* List of localization data */
CFStringRef languageName; /* Current name */
CFStringRef localeName; /* Canonical from of name */
char *lang; /* LANG environment variable */
_cups_globals_t *cg = _cupsGlobals();
/* Pointer to library globals */
DEBUG_puts("2appleLangDefault()");
/*
* Only do the lookup and translation the first time.
*/
if (!cg->language[0])
{
if (getenv("SOFTWARE") != NULL && (lang = getenv("LANG")) != NULL)
{
DEBUG_printf(("3appleLangDefault: Using LANG=%s", lang));
strlcpy(cg->language, lang, sizeof(cg->language));
return (cg->language);
}
else if ((bundle = CFBundleGetMainBundle()) != NULL &&
(bundleList = CFBundleCopyBundleLocalizations(bundle)) != NULL)
{
CFURLRef resources = CFBundleCopyResourcesDirectoryURL(bundle);
DEBUG_puts("3appleLangDefault: Getting localizationList from bundle.");
if (resources)
{
CFStringRef cfpath = CFURLCopyPath(resources);
char path[1024];
if (cfpath)
{
/*
* See if we have an Info.plist file in the bundle...
*/
CFStringGetCString(cfpath, path, sizeof(path), kCFStringEncodingUTF8);
DEBUG_printf(("3appleLangDefault: Got a resource URL (\"%s\")", path));
strlcat(path, "Contents/Info.plist", sizeof(path));
if (!access(path, R_OK))
localizationList = CFBundleCopyPreferredLocalizationsFromArray(bundleList);
else
DEBUG_puts("3appleLangDefault: No Info.plist, ignoring resource URL...");
CFRelease(cfpath);
}
CFRelease(resources);
}
else
DEBUG_puts("3appleLangDefault: No resource URL.");
CFRelease(bundleList);
}
if (!localizationList)
{
DEBUG_puts("3appleLangDefault: Getting localizationList from preferences.");
localizationList =
CFPreferencesCopyAppValue(CFSTR("AppleLanguages"),
kCFPreferencesCurrentApplication);
}
if (localizationList)
{
#ifdef DEBUG
if (CFGetTypeID(localizationList) == CFArrayGetTypeID())
DEBUG_printf(("3appleLangDefault: Got localizationList, %d entries.",
(int)CFArrayGetCount(localizationList)));
else
DEBUG_puts("3appleLangDefault: Got localizationList but not an array.");
#endif /* DEBUG */
if (CFGetTypeID(localizationList) == CFArrayGetTypeID() &&
CFArrayGetCount(localizationList) > 0)
{
languageName = CFArrayGetValueAtIndex(localizationList, 0);
if (languageName &&
CFGetTypeID(languageName) == CFStringGetTypeID())
{
localeName = CFLocaleCreateCanonicalLocaleIdentifierFromString(
kCFAllocatorDefault, languageName);
if (localeName)
{
CFStringGetCString(localeName, cg->language, sizeof(cg->language),
kCFStringEncodingASCII);
CFRelease(localeName);
DEBUG_printf(("3appleLangDefault: cg->language=\"%s\"",
cg->language));
/*
* Map new language identifiers to locales...
*/
for (i = 0;
i < (int)(sizeof(apple_language_locale) /
sizeof(apple_language_locale[0]));
i ++)
{
if (!strcmp(cg->language, apple_language_locale[i].language))
{
DEBUG_printf(("3appleLangDefault: mapping \"%s\" to \"%s\"...",
cg->language, apple_language_locale[i].locale));
strlcpy(cg->language, apple_language_locale[i].locale,
sizeof(cg->language));
break;
}
}
/*
* Convert language subtag into region subtag...
*/
if (cg->language[2] == '-')
cg->language[2] = '_';
if (!strchr(cg->language, '.'))
strlcat(cg->language, ".UTF-8", sizeof(cg->language));
}
else
DEBUG_puts("3appleLangDefault: Unable to get localeName.");
}
}
CFRelease(localizationList);
}
/*
* If we didn't find the language, default to en_US...
*/
if (!cg->language[0])
{
DEBUG_puts("3appleLangDefault: Defaulting to en_US.");
strlcpy(cg->language, "en_US.UTF-8", sizeof(cg->language));
}
}
else
DEBUG_printf(("3appleLangDefault: Using previous locale \"%s\".", cg->language));
/*
* Return the cached locale...
*/
return (cg->language);
}
static void frontend_apple_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
char bundle_path_buf[PATH_MAX_LENGTH], home_dir_buf[PATH_MAX_LENGTH],
support_path_buf[PATH_MAX_LENGTH];
CFURLRef bundle_url;
CFStringRef bundle_path;
CFBundleRef bundle = CFBundleGetMainBundle();
(void)support_path_buf;
if (!bundle)
return;
bundle_url = CFBundleCopyBundleURL(bundle);
bundle_path = CFURLCopyPath(bundle_url);
CFStringGetCString(bundle_path, bundle_path_buf, sizeof(bundle_path_buf), kCFStringEncodingUTF8);
(void)home_dir_buf;
#ifdef IOS
CFSearchPathForDirectoriesInDomains(CFDocumentDirectory, CFUserDomainMask, 1, home_dir_buf, sizeof(home_dir_buf));
fill_pathname_join(g_defaults.system_dir, home_dir_buf, ".RetroArch", sizeof(g_defaults.system_dir));
fill_pathname_join(g_defaults.core_dir, bundle_path_buf, "modules", sizeof(g_defaults.core_dir));
fill_pathname_join(g_defaults.core_info_dir, bundle_path_buf, "info", sizeof(g_defaults.core_info_dir));
fill_pathname_join(g_defaults.shader_dir, bundle_path_buf, "shaders_glsl", sizeof(g_defaults.shader_dir));
fill_pathname_join(g_defaults.overlay_dir, bundle_path_buf, "overlays", sizeof(g_defaults.overlay_dir));
strlcpy(g_defaults.menu_config_dir, g_defaults.system_dir, sizeof(g_defaults.menu_config_dir));
fill_pathname_join(g_defaults.config_path, g_defaults.menu_config_dir, "retroarch.cfg", sizeof(g_defaults.config_path));
strlcpy(g_defaults.sram_dir, g_defaults.system_dir, sizeof(g_defaults.sram_dir));
strlcpy(g_defaults.savestate_dir, g_defaults.system_dir, sizeof(g_defaults.savestate_dir));
path_mkdir(bundle_path_buf);
if (access(bundle_path_buf, 0755) != 0)
RARCH_ERR("Failed to create or access base directory: %s\n", bundle_path_buf);
else
{
path_mkdir(g_defaults.system_dir);
if (access(g_defaults.system_dir, 0755) != 0)
RARCH_ERR("Failed to create or access system directory: %s.\n", g_defaults.system_dir);
}
#elif defined(OSX)
CFSearchPathForDirectoriesInDomains(CFApplicationSupportDirectory, CFUserDomainMask, 1, support_path_buf, sizeof(support_path_buf));
fill_pathname_join(g_defaults.core_dir, "~/Library/Application Support/RetroArch", "cores", sizeof(g_defaults.core_dir));
fill_pathname_join(g_defaults.core_info_dir, "~/Library/Application Support/RetroArch", "info", sizeof(g_defaults.core_info_dir));
/* TODO/FIXME - we might need to update all these paths too and put them all in ~/Library/Application Support, but that would
* require copying all the resource files that are bundled in the app bundle over first to this new directory.
*
* Ideas: There's some overlap here with how the Android APK has to extract all its resource files over to the actual sandboxed
* app dir, maybe try to create something standardized for both platforms (OSX/Android) */
fill_pathname_join(g_defaults.overlay_dir, bundle_path_buf, "Contents/Resources/overlays", sizeof(g_defaults.overlay_dir));
fill_pathname_join(g_defaults.autoconfig_dir, bundle_path_buf, "Contents/Resources/autoconfig/apple", sizeof(g_defaults.autoconfig_dir));
fill_pathname_join(g_defaults.assets_dir, bundle_path_buf, "Contents/Resources/assets", sizeof(g_defaults.assets_dir));
fill_pathname_join(g_defaults.shader_dir, bundle_path_buf, "Contents/Resources/shaders", sizeof(g_defaults.shader_dir));
fill_pathname_join(g_defaults.audio_filter_dir, bundle_path_buf, "Contents/Resources/audio_filters", sizeof(g_defaults.audio_filter_dir));
fill_pathname_join(g_defaults.video_filter_dir, bundle_path_buf, "Contents/Resources/video_filters", sizeof(g_defaults.video_filter_dir));
fill_pathname_join(g_defaults.menu_config_dir, support_path_buf, "RetroArch", sizeof(g_defaults.menu_config_dir));
fill_pathname_join(g_defaults.config_path, g_defaults.menu_config_dir, "retroarch.cfg", sizeof(g_defaults.config_path));
#endif
CFRelease(bundle_path);
CFRelease(bundle_url);
}
/*
* Creates a vector of driver bundle info structures from the hot-plug driver
* directory.
*
* Returns NULL on error and a pointer to an allocated HPDriver vector on
* success. The caller must free the HPDriver with a call to
* HPDriversRelease().
*/
static HPDriverVector HPDriversGetFromDirectory(const char *driverBundlePath)
{
#ifdef DEBUG_HOTPLUG
Log2(PCSC_LOG_DEBUG, "Entering HPDriversGetFromDirectory: %s",
driverBundlePath);
#endif
int readersNumber = 0;
HPDriverVector bundleVector = NULL;
CFArrayRef bundleArray;
CFStringRef driverBundlePathString =
CFStringCreateWithCString(kCFAllocatorDefault,
driverBundlePath,
kCFStringEncodingMacRoman);
CFURLRef pluginUrl = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
driverBundlePathString,
kCFURLPOSIXPathStyle, TRUE);
CFRelease(driverBundlePathString);
if (!pluginUrl)
{
Log1(PCSC_LOG_ERROR, "error getting plugin directory URL");
return NULL;
}
bundleArray = CFBundleCreateBundlesFromDirectory(kCFAllocatorDefault,
pluginUrl, NULL);
if (!bundleArray)
{
Log1(PCSC_LOG_ERROR, "error getting plugin directory bundles");
return NULL;
}
CFRelease(pluginUrl);
size_t bundleArraySize = CFArrayGetCount(bundleArray);
size_t i;
/* get the number of readers (including aliases) */
for (i = 0; i < bundleArraySize; i++)
{
CFBundleRef currBundle =
(CFBundleRef) CFArrayGetValueAtIndex(bundleArray, i);
CFDictionaryRef dict = CFBundleGetInfoDictionary(currBundle);
const void * blobValue = CFDictionaryGetValue(dict,
CFSTR(PCSCLITE_HP_MANUKEY_NAME));
if (!blobValue)
{
Log1(PCSC_LOG_ERROR, "error getting vendor ID from bundle");
return NULL;
}
if (CFGetTypeID(blobValue) == CFArrayGetTypeID())
{
/* alias found, each reader count as 1 */
CFArrayRef propertyArray = blobValue;
readersNumber += CFArrayGetCount(propertyArray);
}
else
/* No alias, only one reader supported */
readersNumber++;
}
#ifdef DEBUG_HOTPLUG
Log2(PCSC_LOG_DEBUG, "Total of %d readers supported", readersNumber);
#endif
/* The last entry is an end marker (m_vendorId = 0)
* see checks in HPDriversMatchUSBDevices:503
* and HPDriverVectorRelease:376 */
readersNumber++;
bundleVector = calloc(readersNumber, sizeof(HPDriver));
if (!bundleVector)
{
Log1(PCSC_LOG_ERROR, "memory allocation failure");
return NULL;
}
HPDriver *driverBundle = bundleVector;
for (i = 0; i < bundleArraySize; i++)
{
CFBundleRef currBundle =
(CFBundleRef) CFArrayGetValueAtIndex(bundleArray, i);
CFDictionaryRef dict = CFBundleGetInfoDictionary(currBundle);
CFURLRef bundleUrl = CFBundleCopyBundleURL(currBundle);
CFStringRef bundlePath = CFURLCopyPath(bundleUrl);
driverBundle->m_libPath = strdup(CFStringGetCStringPtr(bundlePath,
CFStringGetSystemEncoding()));
const void * blobValue = CFDictionaryGetValue(dict,
CFSTR(PCSCLITE_HP_MANUKEY_NAME));
if (!blobValue)
{
Log1(PCSC_LOG_ERROR, "error getting vendor ID from bundle");
return bundleVector;
}
if (CFGetTypeID(blobValue) == CFArrayGetTypeID())
{
CFArrayRef vendorArray = blobValue;
CFArrayRef productArray;
CFArrayRef friendlyNameArray;
char *libPath = driverBundle->m_libPath;
#ifdef DEBUG_HOTPLUG
Log2(PCSC_LOG_DEBUG, "Driver with aliases: %s", libPath);
#endif
/* get list of ProductID */
productArray = CFDictionaryGetValue(dict,
CFSTR(PCSCLITE_HP_PRODKEY_NAME));
if (!productArray)
{
Log1(PCSC_LOG_ERROR, "error getting product ID from bundle");
return bundleVector;
}
/* get list of FriendlyName */
friendlyNameArray = CFDictionaryGetValue(dict,
CFSTR(PCSCLITE_HP_NAMEKEY_NAME));
if (!friendlyNameArray)
{
Log1(PCSC_LOG_ERROR, "error getting product ID from bundle");
return bundleVector;
}
int reader_nb = CFArrayGetCount(vendorArray);
if (reader_nb != CFArrayGetCount(productArray))
{
Log3(PCSC_LOG_ERROR,
"Malformed Info.plist: %d vendors and %ld products",
reader_nb, CFArrayGetCount(productArray));
return bundleVector;
}
if (reader_nb != CFArrayGetCount(friendlyNameArray))
{
Log3(PCSC_LOG_ERROR,
"Malformed Info.plist: %d vendors and %ld friendlynames",
reader_nb, CFArrayGetCount(friendlyNameArray));
return bundleVector;
}
int j;
for (j=0; j<reader_nb; j++)
{
CFStringRef strValue = CFArrayGetValueAtIndex(vendorArray, j);
driverBundle->m_vendorId = strtoul(CFStringGetCStringPtr(strValue,
CFStringGetSystemEncoding()), NULL, 16);
strValue = CFArrayGetValueAtIndex(productArray, j);
driverBundle->m_productId = strtoul(CFStringGetCStringPtr(strValue,
CFStringGetSystemEncoding()), NULL, 16);
strValue = CFArrayGetValueAtIndex(friendlyNameArray, j);
const char *cstr = CFStringGetCStringPtr(strValue,
CFStringGetSystemEncoding());
driverBundle->m_friendlyName = strdup(cstr);
if (!driverBundle->m_libPath)
driverBundle->m_libPath = strdup(libPath);
#ifdef DEBUG_HOTPLUG
Log2(PCSC_LOG_DEBUG, "VendorID: 0x%04X",
driverBundle->m_vendorId);
Log2(PCSC_LOG_DEBUG, "ProductID: 0x%04X",
driverBundle->m_productId);
Log2(PCSC_LOG_DEBUG, "Friendly name: %s",
driverBundle->m_friendlyName);
Log2(PCSC_LOG_DEBUG, "Driver: %s", driverBundle->m_libPath);
#endif
/* go to next bundle in the vector */
driverBundle++;
}
}
else
{
CFStringRef strValue = blobValue;
#ifdef DEBUG_HOTPLUG
Log3(PCSC_LOG_DEBUG, "Driver without alias: %s %s",
driverBundle->m_friendlyName, driverBundle->m_libPath);
#endif
driverBundle->m_vendorId = strtoul(CFStringGetCStringPtr(strValue,
CFStringGetSystemEncoding()), NULL, 16);
strValue = (CFStringRef) CFDictionaryGetValue(dict,
CFSTR(PCSCLITE_HP_PRODKEY_NAME));
if (!strValue)
{
Log1(PCSC_LOG_ERROR, "error getting product ID from bundle");
return bundleVector;
}
driverBundle->m_productId = strtoul(CFStringGetCStringPtr(strValue,
CFStringGetSystemEncoding()), NULL, 16);
strValue = (CFStringRef) CFDictionaryGetValue(dict,
CFSTR(PCSCLITE_HP_NAMEKEY_NAME));
if (!strValue)
{
Log1(PCSC_LOG_ERROR, "error getting product friendly name from bundle");
driverBundle->m_friendlyName = strdup("unnamed device");
}
else
{
const char *cstr = CFStringGetCStringPtr(strValue,
CFStringGetSystemEncoding());
driverBundle->m_friendlyName = strdup(cstr);
}
#ifdef DEBUG_HOTPLUG
Log2(PCSC_LOG_DEBUG, "VendorID: 0x%04X", driverBundle->m_vendorId);
Log2(PCSC_LOG_DEBUG, "ProductID: 0x%04X", driverBundle->m_productId);
Log2(PCSC_LOG_DEBUG, "Friendly name: %s", driverBundle->m_friendlyName);
Log2(PCSC_LOG_DEBUG, "Driver: %s", driverBundle->m_libPath);
#endif
/* go to next bundle in the vector */
driverBundle++;
}
}
CFRelease(bundleArray);
return bundleVector;
}
int convertMain (int argc, char * const argv[])
{
#if TARGET_OS_WIN32
QTLicenseRef aacEncoderLicenseRef = nil;
QTLicenseRef amrEncoderLicenseRef = nil;
OSErr localerr;
#endif
int result = 0;
CFURLRef inputFileURL = NULL;
CFURLRef outputFileURL = NULL;
#if TARGET_OS_WIN32
InitializeQTML(0L);
{
OSErr localerr;
const char *licenseDesc = "AAC Encode License Verification";
const char *amrLicenseDesc = "AMR Encode License Verification";
localerr = QTRequestLicensedTechnology("com.apple.quicktimeplayer","com.apple.aacencoder",
(void *)licenseDesc,strlen(licenseDesc),&aacEncoderLicenseRef);
localerr = QTRequestLicensedTechnology("com.apple.quicktimeplayer","1D07EB75-3D5E-4DA6-B749-D497C92B06D8",
(void *)amrLicenseDesc,strlen(amrLicenseDesc),&amrEncoderLicenseRef);
}
#endif
try {
OSType format = 0;
Float64 sampleRate = 0;
AudioFileTypeID outputFileType = kAudioFileCAFType;
UInt32 outputBitRate = 0;
UInt32 outputBitDepth = 0;
ParseArgs (argc, argv, format, sampleRate, outputFileType, inputFileURL, outputFileURL, outputBitDepth, outputBitRate);
// printf ("args:%4.4s, sample rate:%.1f, outputFileType: %4.4s\n", (char*)&format, sampleRate, (char*)&outputFileType);
CAStreamBasicDescription inputFormat;
CAStreamBasicDescription outputFormat;
ConstructOutputFormatFromArgs (inputFileURL, outputFileType, format, sampleRate, inputFormat, outputBitDepth, outputFormat);
printf ("Source File format:\n\t"); inputFormat.Print();
printf ("Dest File format:\n\t"); outputFormat.Print();
result = ConvertFile (inputFileURL, inputFormat, outputFileURL, outputFileType, outputFormat, outputBitRate);
CFStringRef path = CFURLCopyPath(outputFileURL);
printf("done: "); fflush(stdout); CFShow(path);
if (path) CFRelease(path);
} catch (CAXException e) {
char buf[256];
fprintf(stderr, "Error in: %s\nException thrown: %s\n", e.mOperation, e.FormatError(buf));
result = 1;
} catch (...) {
fprintf(stderr, "Unspecified exception\n");
result = 1;
}
if (inputFileURL) CFRelease(inputFileURL);
if (outputFileURL) CFRelease(outputFileURL);
#if TARGET_OS_WIN32
TerminateQTML();
if (aacEncoderLicenseRef)
{
localerr = QTReleaseLicensedTechnology(aacEncoderLicenseRef);
aacEncoderLicenseRef = nil;
}
if(amrEncoderLicenseRef)
{
localerr = QTReleaseLicensedTechnology(amrEncoderLicenseRef);
amrEncoderLicenseRef = nil;
}
#endif
return result;
}
SCPreferencesRef
SCPreferencesCreateWithOptions(CFAllocatorRef allocator,
CFStringRef name,
CFStringRef prefsID,
AuthorizationRef authorization,
CFDictionaryRef options)
{
CFDataRef authorizationData = NULL;
SCPreferencesPrivateRef prefsPrivate;
if (options != NULL) {
if (!isA_CFDictionary(options)) {
_SCErrorSet(kSCStatusInvalidArgument);
return NULL;
}
}
if (authorization != NULL) {
CFMutableDictionaryRef authorizationDict;
CFBundleRef bundle;
CFStringRef bundleID = NULL;
authorizationDict = CFDictionaryCreateMutable(NULL,
0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
#if !TARGET_OS_IPHONE
if (authorization != kSCPreferencesUseEntitlementAuthorization) {
CFDataRef data;
AuthorizationExternalForm extForm;
OSStatus os_status;
os_status = AuthorizationMakeExternalForm(authorization, &extForm);
if (os_status != errAuthorizationSuccess) {
SCLog(TRUE, LOG_INFO, CFSTR("_SCHelperOpen AuthorizationMakeExternalForm() failed"));
_SCErrorSet(kSCStatusInvalidArgument);
CFRelease(authorizationDict);
return NULL;
}
data = CFDataCreate(NULL, (const UInt8 *)extForm.bytes, sizeof(extForm.bytes));
CFDictionaryAddValue(authorizationDict,
kSCHelperAuthAuthorization,
data);
CFRelease(data);
}
#endif
/* get the application/executable/bundle name */
bundle = CFBundleGetMainBundle();
if (bundle != NULL) {
bundleID = CFBundleGetIdentifier(bundle);
if (bundleID != NULL) {
CFRetain(bundleID);
} else {
CFURLRef url;
url = CFBundleCopyExecutableURL(bundle);
if (url != NULL) {
bundleID = CFURLCopyPath(url);
CFRelease(url);
}
}
if (bundleID != NULL) {
if (CFEqual(bundleID, CFSTR("/"))) {
CFRelease(bundleID);
bundleID = NULL;
}
}
}
if (bundleID == NULL) {
bundleID = CFStringCreateWithFormat(NULL, NULL, CFSTR("Unknown(%d)"), getpid());
}
CFDictionaryAddValue(authorizationDict,
kSCHelperAuthCallerInfo,
bundleID);
CFRelease(bundleID);
if (authorizationDict != NULL) {
_SCSerialize((CFPropertyListRef)authorizationDict,
&authorizationData,
NULL,
NULL);
CFRelease(authorizationDict);
}
}
prefsPrivate = __SCPreferencesCreate(allocator, name, prefsID, authorizationData, options);
if (authorizationData != NULL) CFRelease(authorizationData);
return (SCPreferencesRef)prefsPrivate;
}
/* ioLoadModule:
Load a module from disk.
WARNING: this always loads a *new* module. Don't even attempt to find a loaded one.
WARNING: never primitiveFail() within, just return 0
*/
void* ioLoadModule(char *pluginName) {
char pluginDirPath[DOCUMENT_NAME_SIZE+1];
CFragConnectionID libHandle;
#ifndef BROWSERPLUGIN
#if !defined ( __APPLE__ ) && !defined ( __MACH__ )
Ptr mainAddr;
Str255 errorMsg,tempPluginName;
OSErr err;
#endif
#endif
/* first, look in the "<Squeak VM directory>Plugins" directory for the library */
getVMPathWithEncoding(pluginDirPath,gCurrentVMEncoding);
#ifdef BROWSERPLUGIN
createBrowserPluginPath(pluginDirPath);
#else
strcat(pluginDirPath, "Plugins");
#endif
libHandle = LoadLibViaPath(pluginName, pluginDirPath);
if (libHandle != nil) return (void *) libHandle;
#ifndef BROWSERPLUGIN
/* second, look directly in Squeak VM directory for the library */
getVMPathWithEncoding(pluginDirPath,gCurrentVMEncoding);
libHandle = LoadLibViaPath(pluginName, pluginDirPath);
if (libHandle != nil) return (void*) libHandle;
#if !defined ( __APPLE__ ) && !defined ( __MACH__ )
/* Lastly look for it as a shared import library */
CopyCStringToPascal(pluginName,tempPluginName);
err = GetSharedLibrary(tempPluginName, kAnyCFragArch, kLoadCFrag, &libHandle, &mainAddr, errorMsg);
if (err == noErr)
err = GetSharedLibrary(tempPluginName, kAnyCFragArch, kFindCFrag, &libHandle, &mainAddr, errorMsg);
if (libHandle != nil) return (void*) libHandle;
#else
{
CFBundleRef mainBundle;
CFURLRef bundleURL,bundleURL2,resourceURL;
CFStringRef filePath,resourcePathString;
mainBundle = CFBundleGetMainBundle();
bundleURL = CFBundleCopyBundleURL(mainBundle);
resourceURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
resourcePathString = CFURLCopyPath(resourceURL);
CFRelease(resourceURL);
bundleURL2 = CFURLCreateCopyAppendingPathComponent( kCFAllocatorSystemDefault, bundleURL, resourcePathString, false );
CFRelease(bundleURL);
#ifdef MACINTOSHUSEUNIXFILENAMES
filePath = CFURLCopyFileSystemPath (bundleURL2, kCFURLPOSIXPathStyle);
#else
filePath = CFURLCopyFileSystemPath (bundleURL2, kCFURLHFSPathStyle);
#endif
CFRelease(bundleURL2);
CFStringGetCString (filePath,pluginDirPath,DOCUMENT_NAME_SIZE, gCurrentVMEncoding);
CFRelease(filePath);
libHandle = LoadLibViaPath(pluginName, pluginDirPath);
if (libHandle != nil) return (void *) libHandle;
}
#endif
#endif
return nil;
}
void fill_pathname_application_path(char *s, size_t len)
{
size_t i;
#ifdef __APPLE__
CFBundleRef bundle = CFBundleGetMainBundle();
#endif
#ifdef _WIN32
DWORD ret;
wchar_t ws[PATH_MAX_LENGTH] = {0};
#endif
#ifdef __HAIKU__
image_info info;
int32_t cookie = 0;
#endif
(void)i;
if (!len)
return;
#ifdef _WIN32
ret = GetModuleFileName(GetModuleHandle(NULL), s, len - 1);
s[ret] = '\0';
#elif defined(__APPLE__)
if (bundle)
{
CFURLRef bundle_url = CFBundleCopyBundleURL(bundle);
CFStringRef bundle_path = CFURLCopyPath(bundle_url);
CFStringGetCString(bundle_path, s, len, kCFStringEncodingUTF8);
CFRelease(bundle_path);
CFRelease(bundle_url);
retro_assert(strlcat(s, "nobin", len) < len);
return;
}
#elif defined(__HAIKU__)
while (get_next_image_info(0, &cookie, &info) == B_OK)
{
if (info.type == B_APP_IMAGE)
{
strlcpy(s, info.name, len);
return;
}
}
#else
{
pid_t pid;
static const char *exts[] = { "exe", "file", "path/a.out" };
char link_path[255];
link_path[0] = *s = '\0';
pid = getpid();
/* Linux, BSD and Solaris paths. Not standardized. */
for (i = 0; i < ARRAY_SIZE(exts); i++)
{
ssize_t ret;
snprintf(link_path, sizeof(link_path), "/proc/%u/%s",
(unsigned)pid, exts[i]);
ret = readlink(link_path, s, len - 1);
if (ret >= 0)
{
s[ret] = '\0';
return;
}
}
}
RARCH_ERR("Cannot resolve application path! This should not happen.\n");
#endif
}
