std::string GetBinaryPath() { #ifdef linux std::string path(GetBinaryFile()); size_t pathlength = path.find_last_of('/'); if (pathlength != std::string::npos) return path.substr(0, pathlength); else return path; #elif WIN32 TCHAR currentDir[MAX_PATH+1]; int ret = ::GetModuleFileName(0, currentDir, sizeof(currentDir)); if (ret == 0 || ret == sizeof(currentDir)) return ""; char drive[MAX_PATH], dir[MAX_PATH], file[MAX_PATH], ext[MAX_PATH]; _splitpath(currentDir, drive, dir, file, ext); _makepath(currentDir, drive, dir, NULL, NULL); return std::string(currentDir); #elif MACOSX_BUNDLE char cPath[1024]; CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle); CFURLRef binaryPathURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault , mainBundleURL); CFStringRef cfStringRef = CFURLCopyFileSystemPath(binaryPathURL, kCFURLPOSIXPathStyle); CFStringGetCString(cfStringRef, cPath, 1024, kCFStringEncodingASCII); CFRelease(mainBundleURL); CFRelease(binaryPathURL); CFRelease(cfStringRef); return std::string(cPath); #else return ""; #endif }
/** * returns the path of the .app bundle on MacOS X * * this is needed to handle resource locations and config file pathes * propperly on Mac OS X. */ std::string macBundlePath() { char path[1024]; CFBundleRef mainBundle = CFBundleGetMainBundle(); assert(mainBundle); CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle); assert(mainBundleURL); CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle); assert(cfStringRef); CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII); CFRelease(mainBundleURL); CFRelease(cfStringRef); return std::string(path); }
QString Uploader::sam7Path( ) { QString uploaderName; #ifdef Q_OS_MAC // get the path within the app bundle CFURLRef pluginRef = CFBundleCopyBundleURL(CFBundleGetMainBundle()); CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle); QDir appBundle( CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding()) ); uploaderName = appBundle.filePath( "Contents/Resources/sam7" ); #elif defined (Q_OS_WIN) QDir d = QDir::current(); if(!d.exists("sam7.exe")) // in dev mode, we're one dir down in 'bin' d.cdUp(); uploaderName = d.filePath("sam7.exe"); #else QSettings settings; QDir dir( settings.value("sam7_path", DEFAULT_SAM7_PATH).toString() ); uploaderName = dir.filePath("sam7"); #endif return uploaderName; }
OSStatus SetVMPathFromApplicationDirectory() { CFBundleRef mainBundle; CFURLRef bundleURL,bundleURLPrefix; CFStringRef filePath; CFMutableStringRef vmPathString; mainBundle = CFBundleGetMainBundle(); bundleURL = CFBundleCopyBundleURL(mainBundle); bundleURLPrefix = CFURLCreateCopyDeletingLastPathComponent(NULL,bundleURL); CFRelease(bundleURL); filePath = CFURLCopyFileSystemPath (bundleURLPrefix, kCFURLPOSIXPathStyle); CFRelease(bundleURLPrefix); vmPathString = CFStringCreateMutableCopy(NULL, 0, filePath); CFStringAppendCString(vmPathString, "/", kCFStringEncodingMacRoman); SetVMPathFromCFString(vmPathString); CFRelease(filePath); CFRelease(vmPathString); return 0; }
int switch_to_game_directory() { log_message("finding the bundle directory"); CFBundleRef bundle = CFBundleGetMainBundle(); CFURLRef url = NULL; if(bundle) url = CFBundleCopyBundleURL(bundle); if(!url) { log_message("no bundle found"); return 0; } CFStringRef str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); CFRelease(url); int size = CFStringGetLength(str) + 1; char *dir = (char *)malloc(size); int success = CFStringGetCString(str, dir, size, kCFURLPOSIXPathStyle); CFRelease(str); if(success) { int success = chdir(dir); if(success == 0) log_messagef("changed directory to '%s'", dir); else log_messagef("failed changing directory to '%s'", dir); // there must be a better way to tell if we're bundled :/ if(chdir("Contents/Resources") == 0) log_message("running as an app bundle, changed to resources directory"); else log_message("running unbundled"); } free(dir); return success; }
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; }
char *Sys_PathFromOpenMenu(void) { /* present an open file dialog and return the file's path */ OSStatus res; NavDialogCreationOptions options; NavDialogRef dialog; NavReplyRecord reply; NavUserAction action; FSRef fileRef; CFURLRef cfUrl; CFStringRef cfString; res = NavGetDefaultDialogCreationOptions(&options); options.modality = kWindowModalityAppModal; res = NavCreateGetFileDialog(&options, NULL, NULL, NULL, NULL, NULL, &dialog); NavDialogRun(dialog); action = NavDialogGetUserAction(dialog); if (action == kNavUserActionNone || action == kNavUserActionCancel) return NULL; res = NavDialogGetReply(dialog, &reply); if (res != noErr) return NULL; res = AEGetNthPtr(&reply.selection, 1, typeFSRef, NULL, NULL, &fileRef, sizeof(FSRef), NULL); cfUrl = CFURLCreateFromFSRef(NULL, &fileRef); cfString = NULL; if (cfUrl) { cfString = CFURLCopyFileSystemPath(cfUrl, kCFURLPOSIXPathStyle); CFRelease(cfUrl); } memset(g_OpenFileName, 0, PATH_MAX); CFStringGetCString(cfString, g_OpenFileName, PATH_MAX, kCFStringEncodingMacRoman); return g_OpenFileName; }
CF::String URL::GetFileSystemPath( CFURLPathStyle style ) { CF::String str; CFStringRef cfStr; if( this->_cfObject == NULL ) { return str; } cfStr = CFURLCopyFileSystemPath( this->_cfObject, style ); if( cfStr != NULL ) { str = cfStr; CFRelease( cfStr ); } return str; }
char* getBundleRoot(){ // Adjust the path to the folder containing .app file: CFBundleRef br; CFURLRef ur; CFStringRef sr; br = CFBundleGetMainBundle(); if (br) { long i; ur = CFBundleCopyBundleURL(br); sr = CFURLCopyFileSystemPath(ur, kCFURLPOSIXPathStyle); i = switches_count++; switches = realloc(switches,switches_count*sizeof(char*)); switches[i] = malloc(FILENAME_MAX); CFStringGetCString(sr,switches[i],FILENAME_MAX,kCFStringEncodingASCII); CFRelease(ur); CFRelease(sr); return switches[i]; } return 0; };
void getexecutablepath(char* buffer, size_t bufferLen) { #if defined( OS_MACOSX ) CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef executableUrl = CFBundleCopyExecutableURL(mainBundle); CFStringRef executableString = CFURLCopyFileSystemPath(executableUrl, kCFURLPOSIXPathStyle); CFMutableStringRef normalizedString = CFStringCreateMutableCopy(NULL, 0, executableString); CFStringGetCString(normalizedString, buffer, bufferLen - 1, kCFStringEncodingUTF8); CFRelease(executableUrl); CFRelease(executableString); CFRelease(normalizedString); #elif defined(__FreeBSD__) sysctl_get_pathname(buffer, bufferLen); #else if (readlink("/proc/self/exe", buffer, bufferLen) != -1) { return; } *buffer = 0; #endif }
pascal OSStatus MoreAEOCreateObjSpecifierFromCFURLRef(const CFURLRef pCFURLRef,AEDesc *pObjSpecifier) { OSErr anErr = paramErr; if (NULL != pCFURLRef) { CFStringRef tCFStringRef = CFURLCopyFileSystemPath(pCFURLRef,kCFURLHFSPathStyle); anErr = coreFoundationUnknownErr; if (NULL != tCFStringRef) { Boolean isDirectory = CFURLHasDirectoryPath(pCFURLRef); AEDesc containerDesc = {typeNull, NULL}; AEDesc nameDesc = {typeNull, NULL}; Size bufSize = (CFStringGetLength(tCFStringRef) + (isDirectory ? 1 : 0)) * sizeof(UniChar); UniCharPtr buf = (UniCharPtr) NewPtr(bufSize); if ((anErr = MemError()) == noErr) { CFStringGetCharacters(tCFStringRef, CFRangeMake(0,bufSize/2), buf); if (isDirectory) (buf)[(bufSize-1)/2] = (UniChar) 0x003A; } if (anErr == noErr) anErr = AECreateDesc(typeUnicodeText, buf, GetPtrSize((Ptr) buf), &nameDesc); if (anErr == noErr) { if (isDirectory) // we use cObject here since this might be a package (and we have no way to tell) anErr = CreateObjSpecifier(cObject, &containerDesc, formName, &nameDesc, false, pObjSpecifier); else anErr = CreateObjSpecifier(cFile, &containerDesc, formName, &nameDesc, false, pObjSpecifier); } MoreAEDisposeDesc(&nameDesc); if (buf) DisposePtr((Ptr)buf); } } return anErr; }//end MoreAEOCreateObjSpecifierFromCFURLRef
static FILE* ios_open_from_bundle(const char path[], const char* perm) { // Get a reference to the main bundle CFBundleRef mainBundle = CFBundleGetMainBundle(); // Get a reference to the file's URL CFStringRef pathRef = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8); CFURLRef imageURL = CFBundleCopyResourceURL(mainBundle, pathRef, NULL, NULL); if (!imageURL) { return nullptr; } // Convert the URL reference into a string reference CFStringRef imagePath = CFURLCopyFileSystemPath(imageURL, kCFURLPOSIXPathStyle); // Get the system encoding method CFStringEncoding encodingMethod = CFStringGetSystemEncoding(); // Convert the string reference into a C string const char *finalPath = CFStringGetCStringPtr(imagePath, encodingMethod); return fopen(finalPath, perm); }
static void GetTempFolderPath( uint16 *tempPath, size_t destMaxLength) { //Find the Temp directory #if MSWindows wchar_t tempFolderPath[4096]; GetTempPathW(4096,tempFolderPath); StringCopy3D(tempPath,tempFolderPath, 4096); #else FSRef folderRef; OSErr err = FSFindFolder( kOnSystemDisk, kTemporaryFolderType, true, &folderRef ); if ( err != noErr ) { err = FSFindFolder( kOnAppropriateDisk, kTemporaryFolderType, true, &folderRef ); } if(err != noErr) { wchar_t tempFolderPath[]=L"/tmp/"; StringCopy3D(tempPath,tempFolderPath, destMaxLength); } else { CFURLRef url = CFURLCreateFromFSRef( kCFAllocatorDefault, &folderRef ); CFStringRef cfString = NULL; if ( url != NULL ) { cfString = CFURLCopyFileSystemPath( url, kCFURLPOSIXPathStyle ); CFStringGetCString(cfString,(char*)tempPath,2048,kCFStringEncodingUnicode); int32 len=CFStringGetLength(cfString); CFRelease( url ); tempPath[len]='/'; tempPath[len+1]=0; } } #endif }
void Cinderactor::init(const std::string & ini_file ) { // Get a reference to the main bundle #ifdef _WIN32 std::string bundle_path(".\\resources\\"); #else CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyBundleURL(mainBundle); CFStringRef str = CFURLCopyFileSystemPath( resourcesURL, kCFURLPOSIXPathStyle ); CFRelease(resourcesURL); char path[PATH_MAX]; CFStringGetCString( str, path, FILENAME_MAX, kCFStringEncodingASCII ); CFRelease(str); std::string bundle_path(path); bundle_path= bundle_path+"/Contents/Resources/"; #endif std::cout << ">>>>>>>>>>>> BUNDLE : bundle_path " << bundle_path << std::endl; gestoos::nui::Interactor::set_resources_path(bundle_path); gestoos::nui::Interactor::init( ini_file ); init_ok = true; }
/** * Get the location for global or user-local support files. * @return NULL if it could not be determined */ char *Bgetsupportdir(int global) { char *dir = NULL; #ifdef __APPLE__ FSRef ref; CFStringRef str; CFURLRef base; const char *s; if (FSFindFolder(global ? kLocalDomain : kUserDomain, kApplicationSupportFolderType, kDontCreateFolder, &ref) < 0) return NULL; base = CFURLCreateFromFSRef(NULL, &ref); if (!base) { return NULL; } str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle); CFRelease(base); if (!str) { return NULL; } s = CFStringGetCStringPtr(str, CFStringGetSystemEncoding()); if (s) { dir = strdup(s); } CFRelease(str); #else if (!global) { dir = Bgethomedir(); } #endif return dir; }
QList<QStorageInfo> QStorageInfoPrivate::mountedVolumes() { QList<QStorageInfo> volumes; QCFType<CFURLEnumeratorRef> enumerator; enumerator = CFURLEnumeratorCreateForMountedVolumes(Q_NULLPTR, kCFURLEnumeratorSkipInvisibles, Q_NULLPTR); CFURLEnumeratorResult result = kCFURLEnumeratorSuccess; do { CFURLRef url; CFErrorRef error; result = CFURLEnumeratorGetNextURL(enumerator, &url, &error); if (result == kCFURLEnumeratorSuccess) { const QCFString urlString = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); volumes.append(QStorageInfo(urlString)); } } while (result != kCFURLEnumeratorEnd); return volumes; }
CFIndex addCTFontDescriptor(CTFontDescriptorRef fd, JNIEnv *env, jobjectArray result, CFIndex index) { if (fd) { CFStringRef name = CTFontDescriptorCopyAttribute(fd, kCTFontDisplayNameAttribute); CFStringRef family = CTFontDescriptorCopyAttribute(fd, kCTFontFamilyNameAttribute); CFURLRef url = CTFontDescriptorCopyAttribute(fd, kCTFontURLAttribute); CFStringRef file = url ? CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle) : NULL; if (name && family && file) { jstring jname = createJavaString(env, name); jstring jfamily = createJavaString(env, family); jstring jfile = createJavaString(env, file); (*env)->SetObjectArrayElement(env, result, index++, jname); (*env)->SetObjectArrayElement(env, result, index++, jfamily); (*env)->SetObjectArrayElement(env, result, index++, jfile); } if (name) CFRelease(name); if (family) CFRelease(family); if (url) CFRelease(url); if (file) CFRelease(file); } return index; }
QString ScPaths::bundleDir(void) const { // On MacOS/X, override the compile-time settings with a location // obtained from the system. #ifdef Q_WS_MAC // Set up the various app paths to look inside the app bundle CFURLRef pluginRef = CFBundleCopyBundleURL(CFBundleGetMainBundle()); CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle); const char *pathPtr = CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding()); // make sure we get the Scribus.app directory, not some subdir // strip trailing '/': char *p = const_cast<char*>(pathPtr + strlen(pathPtr) - 1); while (*p == '/') --p; ++p; *p = '\0'; if (strcmp("/bin", p-4) == 0) { p -= 4; *p = '\0'; } if (strcmp("/MacOS", p-6) == 0) { p -= 6; *p = '\0'; } if (strcmp("/Contents", p-9) == 0) { p -= 9; *p = '\0'; } CFRelease(pluginRef); CFRelease(macPath); return QString("%1").arg(pathPtr); #endif return QString::null; }
JNIEXPORT jstring JNICALL Java_org_gudy_azureus2_platform_macosx_access_jnilib_OSXAccess_getDocDir( JNIEnv *env, jclass cla ) { CFURLRef docURL; CFStringRef docPath; FSRef fsRef; OSErr err = FSFindFolder(kUserDomain, kDocumentsFolderType, kDontCreateFolder, &fsRef); jstring result = 0; if (err == noErr) { if((docURL = CFURLCreateFromFSRef( kCFAllocatorSystemDefault, &fsRef))) { docPath = CFURLCopyFileSystemPath(docURL, kCFURLPOSIXPathStyle); if (docPath) { // convert to unicode CFIndex strLen = CFStringGetLength( docPath ); UniChar uniStr[ strLen ]; CFRange strRange; strRange.location = 0; strRange.length = strLen; CFStringGetCharacters( docPath, strRange, uniStr ); result = (*env)->NewString( env, (jchar*)uniStr, (jsize)strLen ); CFRelease(docPath); return result; } CFRelease(docURL); } return result; } }
char *Bgethomedir(void) { #ifdef _WIN32 TCHAR appdata[MAX_PATH]; if (SUCCEEDED(SHGetSpecialFolderPathA(NULL, appdata, CSIDL_APPDATA, FALSE))) return strdup(appdata); return NULL; #elif defined __APPLE__ #if LOWANG_IOS const char* Sys_GetResourceDir(void); return strdup(Sys_GetResourceDir()); #else FSRef ref; CFStringRef str; CFURLRef base; char *s; if (FSFindFolder(kUserDomain, kVolumeRootFolderType, kDontCreateFolder, &ref) < 0) return NULL; base = CFURLCreateFromFSRef(NULL, &ref); if (!base) return NULL; str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle); CFRelease(base); if (!str) return NULL; s = (char*)CFStringGetCStringPtr(str,CFStringGetSystemEncoding()); if (s) s = strdup(s); CFRelease(str); return s; #endif #else char *e = getenv("HOME"); if (!e) return NULL; return strdup(e); #endif }
char *Bgetsupportdir(int global) { #ifndef __APPLE__ return Bgethomedir(); #else FSRef ref; CFStringRef str; CFURLRef base; char *s; if (FSFindFolder(global ? kLocalDomain : kUserDomain, kApplicationSupportFolderType, kDontCreateFolder, &ref) < 0) return NULL; base = CFURLCreateFromFSRef(NULL, &ref); if (!base) return NULL; str = CFURLCopyFileSystemPath(base, kCFURLPOSIXPathStyle); CFRelease(base); if (!str) return NULL; s = (char*)CFStringGetCStringPtr(str,CFStringGetSystemEncoding()); if (s) s = strdup(s); CFRelease(str); return s; #endif }
long GetProcDir(std::string & Dest) { CFAuto<CFURLRef> TestURL( CFBundleCopyExecutableURL(CFBundleGetMainBundle())); CFAuto<CFStringRef> PathCFString( CFURLCopyFileSystemPath(TestURL,kCFURLPOSIXPathStyle)); long PathLen = CFStringGetLength(PathCFString) + 1; char PathString[PathLen]; //AutoCharBuf PathString(PathLen); CFStringGetCString(PathCFString, PathString, PathLen ,kCFStringEncodingUTF8); char* PathTerm = strrchr(PathString, '/'); if (PathTerm != NULL) *(PathTerm + 1) = '\0'; Dest = PathString; return 0; }
QString mac_app_filename() { static QString appFileName; if (appFileName.isEmpty()) { CFURLRef bundleURL = NULL; CFBundleRef bundle = NULL; CFStringRef bundlePath = NULL; bundle = CFBundleGetMainBundle(); if (bundle) { bundleURL = CFBundleCopyBundleURL(bundle); bundlePath = CFURLCopyFileSystemPath(bundleURL, kCFURLPOSIXPathStyle); if (bundleURL) { CFRelease(bundleURL); } if (bundlePath) { appFileName = convert_CFString_to_QString(bundlePath); CFRelease(bundlePath); } } } return appFileName; }
void read_database() { int i; #ifdef __APPLE__ char app_path[1024]; CFURLRef mainBundleURL = CFBundleCopyBundleURL( CFBundleGetMainBundle()); CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle); CFStringGetCString( cfStringRef, app_path, 1024, kCFStringEncodingASCII); CFRelease( mainBundleURL); CFRelease( cfStringRef); sprintf(db_file_name,"%s/Contents/Resources/nfosc.db",app_path); #else strcpy(db_file_name,"nfosc.db"); #endif nfosc_t db_entry; char line[36]; FILE *db_file = fopen(db_file_name, "r"); if (db_file==NULL) return; while (fgets (line, 32, db_file)) { db_entry.symbol_id = max_symbol_id; for (i=0; i<32; i++) { if (line[i]=='\n') { db_entry.uid_str[i]='\0'; break; } db_entry.uid_str[i]=line[i]; } if (verbose) printf("assigning ID %d to UID %s\n",max_symbol_id,db_entry.uid_str); tag_database[max_symbol_id] = db_entry; max_symbol_id++; } fclose (db_file); }
#endif QSettings mySettings; // For non static builds on mac and win (static builds are not supported) // we need to be sure we can find the qt image // plugins. In mac be sure to look in the // application bundle... #ifdef Q_OS_WIN QCoreApplication::addLibraryPath( QApplication::applicationDirPath() + QDir::separator() + "qtplugins" ); #endif #ifdef Q_OS_MACX //qDebug("Adding qt image plugins to plugin search path..."); CFURLRef myBundleRef = CFBundleCopyBundleURL( CFBundleGetMainBundle() ); CFStringRef myMacPath = CFURLCopyFileSystemPath( myBundleRef, kCFURLPOSIXPathStyle ); const char *mypPathPtr = CFStringGetCStringPtr( myMacPath, CFStringGetSystemEncoding() ); CFRelease( myBundleRef ); CFRelease( myMacPath ); QString myPath( mypPathPtr ); // if we are not in a bundle assume that the app is built // as a non bundle app and that image plugins will be // in system Qt frameworks. If the app is a bundle // lets try to set the qt plugin search path... QFileInfo myInfo( myPath ); if ( myInfo.isBundle() ) { // First clear the plugin search paths so we can be sure // only plugins from the bundle are being used QStringList myPathList; QCoreApplication::setLibraryPaths( myPathList );
CFDictionaryRef createDockDescriptionForURL(CFURLRef url) { if (!url) { NSLog(CFSTR("%@"), CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: Cannot copy Dock description for a NULL URL")); return NULL; } //return NULL for non-file: URLs. CFStringRef scheme = CFURLCopyScheme(url); Boolean isFileURL = (CFStringCompare(scheme, CFSTR("file"), kCFCompareCaseInsensitive) == kCFCompareEqualTo); CFRelease(scheme); if (!isFileURL) return NULL; CFDictionaryRef dict = NULL; CFStringRef path = NULL; CFDataRef aliasData = NULL; FSRef fsref; if (CFURLGetFSRef(url, &fsref)) { AliasHandle alias = NULL; OSStatus err = FSNewAlias(/*fromFile*/ NULL, &fsref, &alias); if (err != noErr) { NSLog(CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: FSNewAlias for %@ returned %li"), url, (long)err); } else { HLock((Handle)alias); err = FSCopyAliasInfo(alias, /*targetName*/ NULL, /*volumeName*/ NULL, (CFStringRef *)&path, /*whichInfo*/ NULL, /*info*/ NULL); if (err != noErr) { NSLog(CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: FSCopyAliasInfo for %@ returned %li"), url, (long)err); } aliasData = CFDataCreate(kCFAllocatorDefault, (UInt8 *)*alias, GetHandleSize((Handle)alias)); HUnlock((Handle)alias); DisposeHandle((Handle)alias); } } if (!path) { path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); } if (path || aliasData) { CFMutableDictionaryRef temp = CFDictionaryCreateMutable(kCFAllocatorDefault, /*capacity*/ 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (path) { CFDictionarySetValue(temp, _CFURLStringKey, path); CFRelease(path); int pathStyle = kCFURLPOSIXPathStyle; CFNumberRef pathStyleNum = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &pathStyle); CFDictionarySetValue(temp, _CFURLStringTypeKey, pathStyleNum); CFRelease(pathStyleNum); } if (aliasData) { CFDictionarySetValue(temp, _CFURLAliasDataKey, aliasData); CFRelease(aliasData); } dict = temp; } return dict; }
CFStringRef copyCurrentProcessPath(void) { CFURLRef URL = copyCurrentProcessURL(); CFStringRef path = CFURLCopyFileSystemPath(URL, kCFURLPOSIXPathStyle); CFRelease(URL); return path; }
/** ** The main program: initialise, parse options and arguments. ** ** @param argc Number of arguments. ** @param argv Vector of arguments. */ int main(int argc, char **argv) { #ifdef REDIRECT_OUTPUT RedirectOutput(); #endif #ifdef USE_BEOS // Parse arguments for BeOS beos_init(argc, argv); #endif // Setup some defaults. #ifndef MAC_BUNDLE StratagusLibPath = "."; #else freopen("/tmp/stdout.txt", "w", stdout); freopen("/tmp/stderr.txt", "w", stderr); // Look for the specified data set inside the application bundle // This should be a subdir of the Resources directory CFURLRef pluginRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR(MAC_BUNDLE_DATADIR), NULL, NULL); CFStringRef macPath = CFURLCopyFileSystemPath(pluginRef, kCFURLPOSIXPathStyle); const char *pathPtr = CFStringGetCStringPtr(macPath, CFStringGetSystemEncoding()); Assert(pathPtr); StratagusLibPath = pathPtr; #endif Parameters ¶meters = Parameters::Instance; parameters.SetDefaultValues(); parameters.LocalPlayerName = GetLocalPlayerNameFromEnv(); if (argc > 0) { parameters.applicationName = argv[0]; } // FIXME: Parse options before or after scripts? ParseCommandLine(argc, argv, parameters); // Init the random number generator. InitSyncRand(); makedir(parameters.GetUserDirectory().c_str(), 0777); // Init Lua and register lua functions! InitLua(); LuaRegisterModules(); // Initialise AI module InitAiModule(); LoadCcl(parameters.luaStartFilename); PrintHeader(); PrintLicense(); // Setup video display InitVideo(); // Setup sound card if (!InitSound()) { InitMusic(); } #ifndef DEBUG // For debug it's better not to have: srand(time(NULL)); // Random counter = random each start #endif // Show title screens. SetDefaultTextColors(FontYellow, FontWhite); LoadFonts(); SetClipping(0, 0, Video.Width - 1, Video.Height - 1); Video.ClearScreen(); ShowTitleScreens(); // Init player data ThisPlayer = NULL; //Don't clear the Players strucure as it would erase the allowed units. // memset(Players, 0, sizeof(Players)); NumPlayers = 0; UnitManager.Init(); // Units memory management PreMenuSetup(); // Load everything needed for menus MenuLoop(); Exit(0); return 0; }
void StartDebuggingAndDetach(char *udid, char *app_path) { SDMMD_AMDeviceRef device = FindDeviceFromUDID(udid); if (device) { CFStringRef bundleId = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)app_path, strlen(app_path), kCFStringEncodingUTF8, false); CFURLRef relative_url = CFURLCreateWithFileSystemPath(NULL, bundleId, kCFURLPOSIXPathStyle, false); CFURLRef disk_app_url = CFURLCopyAbsoluteURL(relative_url); CFStringRef bundle_identifier = copy_disk_app_identifier(disk_app_url); SDMMD_AMDebugConnectionRef debug = SDMMD_AMDebugConnectionCreateForDevice(device); SDMMD_AMDebugConnectionStart(debug); uintptr_t socket = SDMMD_AMDServiceConnectionGetSocket(debug->connection); CFSocketContext context = { 0, (void*)socket, NULL, NULL, NULL }; CFSocketRef fdvendor = CFSocketCreate(NULL, AF_UNIX, 0, 0, kCFSocketAcceptCallBack, &socket_callback, &context); int yes = 1; setsockopt(CFSocketGetNative(fdvendor), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)); struct sockaddr_un address; memset(&address, 0, sizeof(address)); address.sun_family = AF_UNIX; strcpy(address.sun_path, SDM_LLDB_SOCKET); address.sun_len = SUN_LEN(&address); CFDataRef address_data = CFDataCreate(NULL, (const UInt8 *)&address, sizeof(address)); unlink(SDM_LLDB_SOCKET); CFSocketSetAddress(fdvendor, address_data); CFRelease(address_data); CFRunLoopAddSource(CFRunLoopGetMain(), CFSocketCreateRunLoopSource(NULL, fdvendor, 0), kCFRunLoopCommonModes); SDMMD_AMDeviceRef device = SDMMD_AMDServiceConnectionGetDevice(debug->connection); CFMutableStringRef cmds = CFStringCreateMutableCopy(NULL, 0, LLDB_PREP_CMDS); CFRange range = { 0, CFStringGetLength(cmds) }; CFURLRef device_app_url = copy_device_app_url(device, bundle_identifier); CFStringRef device_app_path = CFURLCopyFileSystemPath(device_app_url, kCFURLPOSIXPathStyle); CFStringFindAndReplace(cmds, CFSTR("{DEVICE_PATH}"), device_app_path, range, 0); range.length = CFStringGetLength(cmds); CFStringRef disk_app_path = CFURLCopyFileSystemPath(disk_app_url, kCFURLPOSIXPathStyle); CFStringFindAndReplace(cmds, CFSTR("{APP_PATH}"), disk_app_path, range, 0); range.length = CFStringGetLength(cmds); CFURLRef device_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, device_app_url); CFStringRef device_container_path = CFURLCopyFileSystemPath(device_container_url, kCFURLPOSIXPathStyle); CFMutableStringRef dcp_noprivate = CFStringCreateMutableCopy(NULL, 0, device_container_path); range.length = CFStringGetLength(dcp_noprivate); CFStringFindAndReplace(dcp_noprivate, CFSTR("/private/var/"), CFSTR("/var/"), range, 0); range.length = CFStringGetLength(cmds); CFStringFindAndReplace(cmds, CFSTR("{device_container}"), dcp_noprivate, range, 0); range.length = CFStringGetLength(cmds); CFURLRef disk_container_url = CFURLCreateCopyDeletingLastPathComponent(NULL, disk_app_url); CFStringRef disk_container_path = CFURLCopyFileSystemPath(disk_container_url, kCFURLPOSIXPathStyle); CFStringFindAndReplace(cmds, CFSTR("{disk_container}"), disk_container_path, range, 0); CFDataRef cmds_data = CFStringCreateExternalRepresentation(NULL, cmds, kCFStringEncodingASCII, 0); FILE *out = fopen(PREP_CMDS_PATH, "w"); fwrite(CFDataGetBytePtr(cmds_data), CFDataGetLength(cmds_data), 1, out); fclose(out); CFSafeRelease(cmds); CFSafeRelease(bundle_identifier); CFSafeRelease(device_app_url); CFSafeRelease(device_app_path); CFSafeRelease(disk_app_path); CFSafeRelease(device_container_url); CFSafeRelease(device_container_path); CFSafeRelease(dcp_noprivate); CFSafeRelease(disk_container_url); CFSafeRelease(disk_container_path); CFSafeRelease(cmds_data); signal(SIGHUP, exit); pid_t parent = getpid(); int pid = fork(); if (pid == 0) { system("xcrun -sdk iphoneos lldb /tmp/sdmmd-lldb-prep"); kill(parent, SIGHUP); _exit(0); } CFRunLoopRun(); } }
__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; }