/* ----------------------------------------------------------------------------- plugin entry point, called by pppd ----------------------------------------------------------------------------- */ int start(CFBundleRef ref) { CFStringRef strref; CFURLRef urlref; bundle = ref; CFRetain(bundle); url = CFBundleCopyBundleURL(bundle); // hookup our handlers old_check_options = the_channel->check_options; the_channel->check_options = serial_check_options; old_connect = the_channel->connect; the_channel->connect = serial_connect; old_process_extra_options = the_channel->process_extra_options; the_channel->process_extra_options = serial_process_extra_options; add_notifier(&connect_fail_notify, serial_connect_notifier, 0); add_notifier(&lcp_lowerdown_notify, serial_lcpdown_notifier, 0); cancelstrref = CFBundleCopyLocalizedString(bundle, CFSTR("Cancel"), CFSTR("Cancel"), NULL); if (cancelstrref == 0) return 1; CFStringGetCString(cancelstrref, (char*)cancelstr, sizeof(cancelstr), kCFStringEncodingUTF8); icstrref = CFBundleCopyLocalizedString(bundle, CFSTR("Network Connection"), CFSTR("Network Connection"), NULL); if (icstrref == 0) return 1; CFStringGetCString(icstrref, (char*)icstr, sizeof(icstr), kCFStringEncodingUTF8); urlref = CFBundleCopyResourceURL(bundle, CFSTR("NetworkConnect.icns"), NULL, NULL); if (urlref == 0 || ((strref = CFURLGetString(urlref)) == 0)) { if (urlref) CFRelease(urlref); return 1; } CFStringGetCString(strref, (char*)iconstr, sizeof(iconstr), kCFStringEncodingUTF8); iconstrref = CFStringCreateCopy(NULL, strref); CFRelease(urlref); urlref = CFBundleCopyBuiltInPlugInsURL(bundle); if (urlref == 0 || ((CFURLGetFileSystemRepresentation(urlref, TRUE, pathccl, sizeof(pathccl))) == FALSE)) { if (urlref) CFRelease(urlref); return 1; } strlcat((char*)pathccl, SUFFIX_CCLENGINE, sizeof(pathccl)); CFRelease(urlref); // add the socket specific options add_options(serial_options); return 0; }
CF_EXPORT Boolean _CFBundleDlfcnPreflight(CFBundleRef bundle, CFErrorRef *error) { Boolean retval = true; CFErrorRef localError = NULL; if (!bundle->_isLoaded) { CFURLRef executableURL = CFBundleCopyExecutableURL(bundle); char buff[CFMaxPathSize]; retval = false; if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) { #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED retval = dlopen_preflight(buff); #endif if (!retval && error) { CFArrayRef archs = CFBundleCopyExecutableArchitectures(bundle); CFStringRef debugString = NULL; const char *errorString = dlerror(); if (errorString && strlen(errorString) > 0) debugString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString); if (archs) { Boolean hasSuitableArch = false, hasRuntimeMismatch = false; CFIndex i, count = CFArrayGetCount(archs); SInt32 arch, curArch = _CFBundleCurrentArchitecture(); for (i = 0; !hasSuitableArch && i < count; i++) { if (CFNumberGetValue((CFNumberRef)CFArrayGetValueAtIndex(archs, i), kCFNumberSInt32Type, (void *)&arch) && arch == curArch) hasSuitableArch = true; } #if defined(BINARY_SUPPORT_DYLD) if (hasSuitableArch) { uint32_t mainFlags = 0; if (_CFBundleGrokObjCImageInfoFromMainExecutable(NULL, &mainFlags) && (mainFlags & 0x2) != 0) { #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED uint32_t bundleFlags = 0; if (_CFBundleGetObjCImageInfo(bundle, NULL, &bundleFlags) && (bundleFlags & 0x2) == 0) hasRuntimeMismatch = true; #endif } } #endif /* BINARY_SUPPORT_DYLD */ if (hasRuntimeMismatch) { localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableRuntimeMismatchError, debugString); } else if (!hasSuitableArch) { localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableArchitectureMismatchError, debugString); } else { localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLoadError, debugString); } CFRelease(archs); } else { localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLoadError, debugString); } if (debugString) CFRelease(debugString); } } else { if (error) localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError); } if (executableURL) CFRelease(executableURL); } if (!retval && error) *error = localError; return retval; }
void setcwd(void) { // make sure cwd is where the app is (launching from Finder sets it to / by default) unsigned char parentdir[MAXPATHLEN]; CFURLRef url = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()); if (CFURLGetFileSystemRepresentation(url, true, parentdir, MAXPATHLEN)) { chdir((char *)parentdir); } CFRelease(url); }
std::string getExecutablePath() { CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle()); FixedStrT<512> buf; CFURLGetFileSystemRepresentation(url, true, (UInt8*) buf.str(), buf.capacity()); return buf.str(); }
const String application_path() { cf::Url url(CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle())); cf::String url_string(CFStringCreateCopy(NULL, CFURLGetString(url.c_obj()))); char path_buffer[PATH_MAX]; if (!CFURLGetFileSystemRepresentation( url.c_obj(), true, reinterpret_cast<UInt8*>(path_buffer), PATH_MAX)) { throw Exception("couldn't get application_path()"); } return String(utf8::decode(path_buffer)); }
char *HostFilesys::getDataFolder(char *buffer, unsigned int bufsize) { UInt8 main_bundle_loc[MAXPATHLEN]; CFURLRef url = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()); CFURLGetFileSystemRepresentation(url, true, main_bundle_loc, sizeof(main_bundle_loc)); CFRelease(url); //printf("Data folder ---------> %s\n", main_bundle_loc); return safe_strncpy(buffer, (char*)main_bundle_loc, bufsize); }
__private_extern__ SInt32 _CFGetFileProperties(CFAllocatorRef alloc, CFURLRef pathURL, Boolean *exists, SInt32 *posixMode, int64_t *size, CFDateRef *modTime, SInt32 *ownerID, CFArrayRef *dirContents) { char path[CFMaxPathSize]; if (!CFURLGetFileSystemRepresentation(pathURL, true, (uint8_t *)path, CFMaxPathLength)) { return -1; } return _CFGetPathProperties(alloc, path, exists, posixMode, size, modTime, ownerID, dirContents); }
char* bundle_path() { CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle); int len = 4096; char* path = malloc(len); CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8*)path, len); return path; }
void DAMountRemoveMountPoint( CFURLRef mountpoint ) { char path[MAXPATHLEN]; /* * Obtain the mount point path. */ if ( CFURLGetFileSystemRepresentation( mountpoint, TRUE, ( void * ) path, sizeof( path ) ) ) { if ( ___isautofs( path ) == 0 ) { Boolean remove; remove = FALSE; if ( strncmp( path, kDAMainMountPointFolder, strlen( kDAMainMountPointFolder ) ) == 0 ) { if ( strrchr( path + strlen( kDAMainMountPointFolder ), '/' ) == path + strlen( kDAMainMountPointFolder ) ) { remove = TRUE; } } ///w:start // if ( remove == FALSE ) ///w:stop { char file[MAXPATHLEN]; strlcpy( file, path, sizeof( file ) ); strlcat( file, "/", sizeof( file ) ); strlcat( file, kDAMainMountPointFolderCookieFile, sizeof( file ) ); /* * Remove the mount point cookie file. */ if ( unlink( file ) == 0 ) { remove = TRUE; } } if ( remove ) { /* * Remove the mount point. */ rmdir( path ); } } } }
void InitDirs(const std::string& argv0) { if (g_initialized) return; // store working dir fs::initial_path(); fs::path bundle_path; fs::path app_path; CFBundleRef bundle = CFBundleGetMainBundle(); char bundle_dir[MAXPATHLEN]; if (bundle) { CFURLRef bundleurl = CFBundleCopyBundleURL(bundle); CFURLGetFileSystemRepresentation(bundleurl, true, reinterpret_cast<UInt8*>(bundle_dir), MAXPATHLEN); } else { // executable is not the main binary in application bundle (i.e. Server or AI) uint32_t size = sizeof(bundle_dir); if (_NSGetExecutablePath(bundle_dir, &size) != 0) { std::cerr << "_NSGetExecutablePath() failed: buffer too small; need size " << size << std::endl; exit(-1); } } bundle_path = fs::path(bundle_dir); // search bundle_path for a directory named "FreeOrion.app", exiting if not found, else constructing a path to application bundle contents fs::path::iterator appiter = std::find(bundle_path.begin(), bundle_path.end(), "FreeOrion.app"); if (appiter == bundle_path.end()) { std::cerr << "Error: Application bundle must be named 'FreeOrion.app' and executables must not be called from outside of it." << std::endl; exit(-1); } else { for (fs::path::iterator piter = bundle_path.begin(); piter != appiter; ++piter) { app_path /= *piter; } app_path /= "FreeOrion.app/Contents"; } s_root_data_dir = app_path / "Resources"; s_user_dir = fs::path(getenv("HOME")) / "Library" / "Application Support" / "FreeOrion"; s_bin_dir = app_path / "Executables"; s_config_path = s_user_dir / "config.xml"; s_python_home = app_path / "Frameworks" / "Python.framework" / "Versions" / "Current"; fs::path p = s_user_dir; if (!exists(p)) fs::create_directories(p); p /= "save"; if (!exists(p)) fs::create_directories(p); g_initialized = true; }
__private_extern__ Boolean _CFWriteBytesToFile(CFURLRef url, const void *bytes, CFIndex length) { struct stat statBuf; int fd = -1; int mode; char path[CFMaxPathSize]; if (!CFURLGetFileSystemRepresentation(url, true, (uint8_t *)path, CFMaxPathSize)) { return false; } #if DEPLOYMENT_TARGET_WINDOWS || 0 mode = 0666; if (0 == stat(path, &statBuf)) { mode = statBuf.st_mode; } else if (thread_errno() != ENOENT) { return false; } fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|CF_OPENFLGS, 0666|_S_IWRITE); if (fd < 0) { return false; } if (length && write(fd, bytes, length) != length) { int saveerr = thread_errno(); close(fd); thread_set_errno(saveerr); return false; } FlushFileBuffers((HANDLE)_get_osfhandle(fd)); close(fd); #else int no_hang_fd = open("/dev/autofs_nowait", 0); mode = 0666; if (0 == stat(path, &statBuf)) { mode = statBuf.st_mode; } else if (thread_errno() != ENOENT) { close(no_hang_fd); return false; } fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|CF_OPENFLGS, 0666); if (fd < 0) { close(no_hang_fd); return false; } if (length && write(fd, bytes, length) != length) { int saveerr = thread_errno(); close(fd); close(no_hang_fd); thread_set_errno(saveerr); return false; } fsync(fd); close(fd); close(no_hang_fd); #endif return true; }
__private_extern__ Boolean _CFReadBytesFromFile(CFAllocatorRef alloc, CFURLRef url, void **bytes, CFIndex *length, CFIndex maxLength) { // maxLength is the number of bytes desired, or 0 if the whole file is desired regardless of length. struct stat statBuf; int fd = -1; char path[CFMaxPathSize]; if (!CFURLGetFileSystemRepresentation(url, true, path, CFMaxPathSize)) { return false; } *bytes = NULL; __CFSetNastyFile(url); #if defined(__WIN32__) fd = open(path, O_RDONLY|CF_OPENFLGS, 0666|_S_IREAD); #else fd = open(path, O_RDONLY|CF_OPENFLGS, 0666); #endif if (fd < 0) { return false; } if (fstat(fd, &statBuf) < 0) { int saveerr = thread_errno(); close(fd); thread_set_errno(saveerr); return false; } if ((statBuf.st_mode & S_IFMT) != S_IFREG) { close(fd); thread_set_errno(EACCES); return false; } if (statBuf.st_size == 0) { *bytes = CFAllocatorAllocate(alloc, 4, 0); // don't return constant string -- it's freed! if (__CFOASafe) __CFSetLastAllocationEventName(*bytes, "CFUtilities (file-bytes)"); *length = 0; } else { CFIndex desiredLength; if ((maxLength >= statBuf.st_size) || (maxLength == 0)) { desiredLength = statBuf.st_size; } else { desiredLength = maxLength; } *bytes = CFAllocatorAllocate(alloc, desiredLength, 0); if (__CFOASafe) __CFSetLastAllocationEventName(*bytes, "CFUtilities (file-bytes)"); if (read(fd, *bytes, desiredLength) < 0) { CFAllocatorDeallocate(alloc, *bytes); close(fd); return false; } *length = desiredLength; } close(fd); return true; }
static bool SecExtractFilesystemPathForKeychainFile(CFStringRef file, UInt8 *buffer, CFIndex maxBufLen) { bool translated = false; CFURLRef fileURL = SecCopyURLForFileInKeychainDirectory(file); if (fileURL && CFURLGetFileSystemRepresentation(fileURL, false, buffer, maxBufLen)) translated = true; CFReleaseSafe(fileURL); return translated; }
string cfString(CFURLRef inUrl) { if (!inUrl) CFError::throwMe(); UInt8 buffer[PATH_MAX+1]; if (CFURLGetFileSystemRepresentation(inUrl, true, buffer, sizeof(buffer))) return string(reinterpret_cast<char *>(buffer)); else CFError::throwMe(); }
bool SFB::Audio::WAVEMetadata::_WriteMetadata(CFErrorRef *error) { UInt8 buf [PATH_MAX]; if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX)) return false; std::unique_ptr<TagLib::FileStream> stream(new TagLib::FileStream((const char *)buf)); if(!stream->isOpen()) { if(error) { SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” could not be opened for writing."), ""); SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Input/output error"), ""); SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file may have been renamed, moved, deleted, or you may not have appropriate permissions."), ""); *error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion); } return false; } TagLib::RIFF::WAV::File file(stream.get(), false); if(!file.isValid()) { if(error) { SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid WAVE file."), ""); SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Not a WAVE file"), ""); SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""); *error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion); } return false; } // An Info tag is only written if present, but ID3v2 tags are always written // TODO: Should other field names from the Info tag be handled? if(file.InfoTag()) SetTagFromMetadata(*this, file.InfoTag()); SetID3v2TagFromMetadata(*this, file.ID3v2Tag()); if(!file.save()) { if(error) { SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid WAVE file."), ""); SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), ""); SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""); *error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion); } return false; } return true; }
SDLApplication::SDLApplication () { if (SDL_Init (SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER | SDL_INIT_TIMER | SDL_INIT_JOYSTICK) != 0) { printf ("Could not initialize SDL: %s.\n", SDL_GetError ()); } SDL_LogSetPriority (SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_WARN); currentApplication = this; framePeriod = 1000.0 / 60.0; #ifdef EMSCRIPTEN emscripten_cancel_main_loop (); emscripten_set_main_loop (UpdateFrame, 0, 0); emscripten_set_main_loop_timing (EM_TIMING_RAF, 1); #endif currentUpdate = 0; lastUpdate = 0; nextUpdate = 0; ApplicationEvent applicationEvent; DropEvent dropEvent; GamepadEvent gamepadEvent; JoystickEvent joystickEvent; KeyEvent keyEvent; MouseEvent mouseEvent; RenderEvent renderEvent; SensorEvent sensorEvent; TextEvent textEvent; TouchEvent touchEvent; WindowEvent windowEvent; SDL_EventState (SDL_DROPFILE, SDL_ENABLE); SDLJoystick::Init (); #ifdef HX_MACOS CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL (CFBundleGetMainBundle ()); char path[PATH_MAX]; if (CFURLGetFileSystemRepresentation (resourcesURL, TRUE, (UInt8 *)path, PATH_MAX)) { chdir (path); } CFRelease (resourcesURL); #endif }
bool SFB::Audio::TrueAudioMetadata::_ReadMetadata(CFErrorRef *error) { UInt8 buf [PATH_MAX]; if(!CFURLGetFileSystemRepresentation(mURL, FALSE, buf, PATH_MAX)) return false; std::unique_ptr<TagLib::FileStream> stream(new TagLib::FileStream((const char *)buf, true)); if(!stream->isOpen()) { if(error) { SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” could not be opened for reading."), ""); SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Input/output error"), ""); SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file may have been renamed, moved, deleted, or you may not have appropriate permissions."), ""); *error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion); } return false; } TagLib::TrueAudio::File file(stream.get()); if(!file.isValid()) { if(nullptr != error) { SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid True Audio file."), ""); SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("Not a True Audio file"), ""); SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""); *error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, mURL, failureReason, recoverySuggestion); } return false; } CFDictionarySetValue(mMetadata, kFormatNameKey, CFSTR("True Audio")); if(file.audioProperties()) { auto properties = file.audioProperties(); AddAudioPropertiesToDictionary(mMetadata, properties); if(properties->bitsPerSample()) AddIntToDictionary(mMetadata, kBitsPerChannelKey, properties->bitsPerSample()); if(properties->sampleFrames()) AddIntToDictionary(mMetadata, kTotalFramesKey, (int)properties->sampleFrames()); } // Add all tags that are present if(file.ID3v1Tag()) AddID3v1TagToDictionary(mMetadata, file.ID3v1Tag()); if(file.ID3v2Tag()) AddID3v2TagToDictionary(mMetadata, mPictures, file.ID3v2Tag()); return true; }
bool WavPackMetadata::ReadMetadata(CFErrorRef *error) { // Start from scratch CFDictionaryRemoveAllValues(mMetadata); CFDictionaryRemoveAllValues(mChangedMetadata); UInt8 buf [PATH_MAX]; if(!CFURLGetFileSystemRepresentation(mURL, FALSE, buf, PATH_MAX)) return false; auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf), true); TagLib::WavPack::File file(stream); if(!file.isValid()) { if(nullptr != error) { CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid WavPack file."), ""); CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not a WavPack file"), ""); CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""); *error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion); CFRelease(description), description = nullptr; CFRelease(failureReason), failureReason = nullptr; CFRelease(recoverySuggestion), recoverySuggestion = nullptr; } return false; } CFDictionarySetValue(mMetadata, kPropertiesFormatNameKey, CFSTR("WavPack")); if(file.audioProperties()) { auto properties = file.audioProperties(); AddAudioPropertiesToDictionary(mMetadata, properties); if(properties->bitsPerSample()) AddIntToDictionary(mMetadata, kPropertiesBitsPerChannelKey, properties->bitsPerSample()); if(properties->sampleFrames()) AddIntToDictionary(mMetadata, kPropertiesTotalFramesKey, properties->sampleFrames()); } if(file.ID3v1Tag()) AddID3v1TagToDictionary(mMetadata, file.ID3v1Tag()); if(file.APETag()) { std::vector<AttachedPicture *> pictures; AddAPETagToDictionary(mMetadata, pictures, file.APETag()); for(auto picture : pictures) AddSavedPicture(picture); } return true; }
void initI18n(void) { const char *textdomainDirectory = NULL; if (!setLanguage("")) // set to system default { // no system default? debug(LOG_ERROR, "initI18n: No system language found"); } #if defined(WZ_OS_WIN) { // Retrieve an absolute path to the locale directory char localeDir[PATH_MAX]; sstrcpy(localeDir, PHYSFS_getBaseDir()); sstrcat(localeDir, "\\" LOCALEDIR); // Set locale directory and translation domain name textdomainDirectory = bindtextdomain(PACKAGE, localeDir); } #else #ifdef WZ_OS_MAC { char resourcePath[PATH_MAX]; CFURLRef resourceURL = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()); if( CFURLGetFileSystemRepresentation( resourceURL, true, (UInt8 *) resourcePath, PATH_MAX) ) { sstrcat(resourcePath, "/locale"); textdomainDirectory = bindtextdomain(PACKAGE, resourcePath); } else { debug( LOG_ERROR, "Could not change to resources directory." ); } if (resourceURL != NULL) { CFRelease(resourceURL); } debug(LOG_INFO, "resourcePath is %s", resourcePath); } #else textdomainDirectory = bindtextdomain(PACKAGE, LOCALEDIR); #endif #endif if (!textdomainDirectory) { debug(LOG_ERROR, "initI18n: bindtextdomain failed!"); } (void)bind_textdomain_codeset(PACKAGE, "UTF-8"); (void)textdomain(PACKAGE); }
bool WavPackMetadata::WriteMetadata(CFErrorRef *error) { UInt8 buf [PATH_MAX]; if(!CFURLGetFileSystemRepresentation(mURL, false, buf, PATH_MAX)) return false; auto stream = new TagLib::FileStream(reinterpret_cast<const char *>(buf)); TagLib::WavPack::File file(stream, false); if(!file.isValid()) { if(nullptr != error) { CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid WavPack file."), ""); CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Not a WavPack file"), ""); CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""); *error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion); CFRelease(description), description = nullptr; CFRelease(failureReason), failureReason = nullptr; CFRelease(recoverySuggestion), recoverySuggestion = nullptr; } return false; } // ID3v1 tags are only written if present, but an APE tag is always written if(file.ID3v1Tag()) SetID3v1TagFromMetadata(*this, file.ID3v1Tag()); SetAPETagFromMetadata(*this, file.APETag(true)); if(!file.save()) { if(error) { CFStringRef description = CFCopyLocalizedString(CFSTR("The file “%@” is not a valid WavPack file."), ""); CFStringRef failureReason = CFCopyLocalizedString(CFSTR("Unable to write metadata"), ""); CFStringRef recoverySuggestion = CFCopyLocalizedString(CFSTR("The file's extension may not match the file's type."), ""); *error = CreateErrorForURL(AudioMetadataErrorDomain, AudioMetadataInputOutputError, description, mURL, failureReason, recoverySuggestion); CFRelease(description), description = nullptr; CFRelease(failureReason), failureReason = nullptr; CFRelease(recoverySuggestion), recoverySuggestion = nullptr; } return false; } MergeChangedMetadataIntoMetadata(); return true; }
ExitStatus checkKextForProblems( KcgenArgs * toolArgs, OSKextRef theKext, const NXArchInfo * arch) { ExitStatus result = EX_SOFTWARE; char kextPath[PATH_MAX]; if (!CFURLGetFileSystemRepresentation(OSKextGetURL(theKext), /* resolveToBase */ false, (UInt8 *)kextPath, sizeof(kextPath))) { strlcpy(kextPath, "(unknown)", sizeof(kextPath)); } /* Skip kexts we have no interest in for the current arch. */ if (!OSKextSupportsArchitecture(theKext, arch)) { OSKextLog(/* kext */ NULL, kOSKextLogErrorLevel | kOSKextLogArchiveFlag, "%s doesn't support architecture '%s'; ommiting.", kextPath, arch->name); goto finish; } if (!OSKextIsValid(theKext)) { OSKextLog(/* kext */ NULL, kOSKextLogErrorLevel | kOSKextLogArchiveFlag | kOSKextLogValidationFlag | kOSKextLogGeneralFlag, "%s is not valid; omitting.", kextPath); if (toolArgs->printTestResults) { OSKextLogDiagnostics(theKext, kOSKextDiagnosticsFlagAll); } goto finish; } if (!OSKextResolveDependencies(theKext)) { OSKextLog(/* kext */ NULL, kOSKextLogWarningLevel | kOSKextLogArchiveFlag | kOSKextLogDependenciesFlag | kOSKextLogGeneralFlag, "%s is missing dependencies (including anyway; " "dependencies may be available from elsewhere)", kextPath); if (toolArgs->printTestResults) { OSKextLogDiagnostics(theKext, kOSKextDiagnosticsFlagAll); } } result = EX_OK; finish: return result; }
void* AppleCMIODPSampleNewPlugIn(CFAllocatorRef allocator, CFUUIDRef requestedTypeUUID) { if (not CFEqual(requestedTypeUUID, kCMIOHardwarePlugInTypeID)) return 0; try { // Before going any further, make sure the SampleAssistant process is registerred with Mach's bootstrap service. Normally, this would be done by having an appropriately // configured plist in /Library/LaunchDaemons, but if that is done then the process will be owned by root, thus complicating the debugging process. Therefore, in the event that the // plist is missing (as would be the case for most debugging efforts) attempt to register the SampleAssistant now. It will fail gracefully if allready registered. mach_port_t assistantServicePort; name_t assistantServiceName = "com.apple.cmio.DPA.Sample"; kern_return_t err = bootstrap_look_up(bootstrap_port, assistantServiceName, &assistantServicePort); if (BOOTSTRAP_SUCCESS != err) { // Create an URL to SampleAssistant that resides at "/Library/CoreMediaIO/Plug-Ins/DAL/Sample.plugin/Contents/Resources/SampleAssistant" CACFURL assistantURL(CFURLCreateWithFileSystemPath(NULL, CFSTR("/Library/CoreMediaIO/Plug-Ins/DAL/Sample.plugin/Contents/Resources/SampleAssistant"), kCFURLPOSIXPathStyle, false)); ThrowIf(not assistantURL.IsValid(), CAException(-1), "AppleCMIODPSampleNewPlugIn: unable to create URL for the SampleAssistant"); // Get the maximum size of the of the file system representation of the SampleAssistant's absolute path CFIndex length = CFStringGetMaximumSizeOfFileSystemRepresentation(CACFString(CFURLCopyFileSystemPath(CACFURL(CFURLCopyAbsoluteURL(assistantURL.GetCFObject())).GetCFObject(), kCFURLPOSIXPathStyle)).GetCFString()); // Get the file system representation CAAutoFree<char> path(length); (void) CFURLGetFileSystemRepresentation(assistantURL.GetCFObject(), true, reinterpret_cast<UInt8*>(path.get()), length); mach_port_t assistantServerPort; err = bootstrap_create_server(bootstrap_port, path, getuid(), true, &assistantServerPort); ThrowIf(BOOTSTRAP_SUCCESS != err, CAException(err), "AppleCMIODPSampleNewPlugIn: couldn't create server"); err = bootstrap_check_in(assistantServerPort, assistantServiceName, &assistantServicePort); // The server port is no longer needed so get rid of it (void) mach_port_deallocate(mach_task_self(), assistantServerPort); // Make sure the call to bootstrap_create_service() succeeded ThrowIf(BOOTSTRAP_SUCCESS != err, CAException(err), "AppleCMIODPSampleNewPlugIn: couldn't create SampleAssistant service port"); } // The service port is not longer needed so get rid of it (void) mach_port_deallocate(mach_task_self(), assistantServicePort); CMIO::DP::Sample::PlugIn* plugIn = new CMIO::DP::Sample::PlugIn(requestedTypeUUID); plugIn->Retain(); return plugIn->GetInterface(); } catch (...) { return NULL; } }
void msGetExecutableDir(string &path) { CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle); char path1[PATH_MAX]; if (CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path1, PATH_MAX)) { CFRelease(resourcesURL); path = path1; } }
CF_PRIVATE Boolean _CFWriteBytesToFileAsync(CFURLRef url, const void *bytes, CFIndex length) { char path[CFMaxPathSize]; if (!CFURLGetFileSystemRepresentation(url, true, (uint8_t *)path, CFMaxPathSize)) { return false; } wchar_t wpath[CFMaxPathSize]; int convertedLength = MultiByteToWideChar(CP_UTF8, 0, path, CFMaxPathSize, wpath, CFMaxPathSize); if (0 == convertedLength) { unsigned error = GetLastError(); CFLog(kCFLogLevelWarning, CFSTR("_CFWriteBytesToFileAsync failed to convert the path (error %u)"), error); return false; } HANDLE fileHandle = NULL; CREATEFILE2_EXTENDED_PARAMETERS createExParams; createExParams.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS); createExParams.dwFileAttributes = FILE_ATTRIBUTE_NORMAL; createExParams.dwFileFlags = FILE_FLAG_OVERLAPPED; createExParams.dwSecurityQosFlags = 0; createExParams.lpSecurityAttributes = NULL; createExParams.hTemplateFile = NULL; OVERLAPPED* overlapped = (OVERLAPPED*)calloc(1, sizeof(OVERLAPPED)); if ((fileHandle = CreateFile2(wpath, GENERIC_WRITE, FILE_SHARE_READ, CREATE_ALWAYS, &createExParams)) == INVALID_HANDLE_VALUE) { unsigned error = GetLastError(); CFLog(kCFLogLevelWarning, CFSTR("_CFWriteBytesToFileAsync failed to open the file (error %u)"), error); free(overlapped); return false; } PTP_IO threadPoolIo = CreateThreadpoolIo(fileHandle, _threadpoolCallback, NULL, NULL); StartThreadpoolIo(threadPoolIo); if (!WriteFile(fileHandle, bytes, length, NULL, overlapped)) { unsigned error = GetLastError(); if (ERROR_IO_PENDING != error) { CFLog(kCFLogLevelWarning, CFSTR("_CFWriteBytesToFileAsync failed to write to the file (error %u)"), error); CloseHandle(fileHandle); CancelThreadpoolIo(threadPoolIo); CloseThreadpoolIo(threadPoolIo); free(overlapped); return false; } } CloseHandle(fileHandle); return true; }
CF_PRIVATE Boolean _CFBundleDYLDLoadFramework(CFBundleRef bundle, CFErrorRef *error) { // !!! Framework loading should be better. Can't unload frameworks. CFErrorRef localError = NULL, *subError = (error ? &localError : NULL); NSLinkEditErrors c = NSLinkEditUndefinedError; int errorNumber = 0; const char *fileName = NULL; const char *errorString = NULL; if (!bundle->_isLoaded) { CFURLRef executableURL = CFBundleCopyExecutableURL(bundle); char buff[CFMaxPathSize]; if (executableURL && CFURLGetFileSystemRepresentation(executableURL, true, (uint8_t *)buff, CFMaxPathSize)) { void *image = (void *)NSAddImage(buff, NSADDIMAGE_OPTION_RETURN_ON_ERROR); #if LOG_BUNDLE_LOAD printf("dyld load framework %p, add image of %s returns image %p\n", bundle, buff, image); #endif /* LOG_BUNDLE_LOAD */ if (image) { bundle->_imageCookie = image; bundle->_isLoaded = true; } else { NSLinkEditError(&c, &errorNumber, &fileName, &errorString); if (error) { #if defined(BINARY_SUPPORT_DLFCN) _CFBundleDlfcnPreflight(bundle, subError); #endif /* BINARY_SUPPORT_DLFCN */ if (!localError) { CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), debugString = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("error code %d, error number %d (%@)"), c, errorNumber, tempString); localError = _CFBundleCreateErrorDebug(CFGetAllocator(bundle), bundle, CFBundleExecutableLinkError, debugString); if (tempString) CFRelease(tempString); if (debugString) CFRelease(debugString); } } else { CFStringRef tempString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, errorString), executableString = CFStringCreateWithFileSystemRepresentation(kCFAllocatorSystemDefault, fileName); CFLog(__kCFLogBundle, CFSTR("Error loading %@: error code %d, error number %d (%@)"), executableString, c, errorNumber, tempString); if (tempString) CFRelease(tempString); if (executableString) CFRelease(executableString); } } } else { if (error) { localError = _CFBundleCreateError(CFGetAllocator(bundle), bundle, CFBundleExecutableNotFoundError); } else { CFLog(__kCFLogBundle, CFSTR("Cannot find executable for bundle %@"), bundle); } } if (executableURL) CFRelease(executableURL); } if (!bundle->_isLoaded && error) *error = localError; return bundle->_isLoaded; }
void mac_get_resource_path(const char *_path,MyString& _resPath) { CFURLRef resourceURL; _resPath.Empty(); // Look for the resource in the main bundle by name and type. #ifdef ACTIVEGSPLUGIN CFBundleRef bundle = CFBundleGetBundleWithIdentifier(__CFStringMakeConstantString("com.freetoolsassociation.activegs")); #else CFBundleRef bundle = CFBundleGetMainBundle(); #endif CFStringRef ce = CFStringCreateWithCString( NULL, _path, kCFStringEncodingASCII); resourceURL = CFBundleCopyResourceURL( bundle, ce, NULL, NULL ); if(!resourceURL) { printf("Failed to locate a file in the loaded bundle! (%s)",_path); return; } char fileurl[1024]; if(!CFURLGetFileSystemRepresentation( resourceURL, true, (UInt8*) fileurl, 1024)) { printf("Failed to turn a bundle resource URL into a filesystem path representation!"); return; } _resPath = fileurl; }
CFStringRef Resources::getResourcesPathFromBundleId() { //@@TODO char buffer[PATH_MAX]; CFBundleRef bundle = CFBundleGetBundleWithIdentifier(CFSTR("SuperColldierAU") ); if (bundle == NULL) return NULL; CFURLRef bundleURL = CFBundleCopyBundleURL(bundle); CFURLGetFileSystemRepresentation(bundleURL, TRUE, (UInt8*)buffer,PATH_MAX); CFStringRef bundlePath = CFStringCreateWithCString(NULL,buffer, kCFStringEncodingUTF8); CFURLRef bundleResourcesURL = CFBundleCopyResourcesDirectoryURL(bundle); CFStringRef resourcesRelativePath = CFURLGetString(bundleResourcesURL); CFMutableStringRef resourcesPath = CFStringCreateMutable(NULL,0); CFStringAppend(resourcesPath,bundlePath); CFStringAppend(resourcesPath,resourcesRelativePath); return resourcesPath; }
void setWorkdir(){ #ifdef __APPLE__ CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle); char path[PATH_MAX]; if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX)) { throw TetrisException("Could not initialize workdir."); } CFRelease(resourcesURL); chdir(path); #endif }
void OSystem_IPHONE::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) { // Get URL of the Resource directory of the .app bundle CFURLRef fileUrl = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()); if (fileUrl) { // Try to convert the URL to an absolute path UInt8 buf[MAXPATHLEN]; if (CFURLGetFileSystemRepresentation(fileUrl, true, buf, sizeof(buf))) { // Success: Add it to the search path Common::String bundlePath((const char *)buf); s.add("__OSX_BUNDLE__", new Common::FSDirectory(bundlePath), priority); } CFRelease(fileUrl); } }
void setMacOSXLibLoc(void) { /* lib-tkeden is located within the tkeden.app "bundle" directory (which is represented to the user in the Finder as an application icon). Get the reference to where it is. */ CFBundleRef mainBundleRef; mainBundleRef = CFBundleGetMainBundle(); if (mainBundleRef != NULL) { CFURLRef libtkedenURL; libtkedenURL = CFBundleCopyResourceURL(mainBundleRef, CFSTR("lib-tkeden"), NULL, NULL); if (libtkedenURL != NULL) { char *libtkedenPath = malloc(MAX_PATH_LEN + 1); /* char *cstr = malloc(1024); CFStringGetCString(CFURLGetString(libtkedenURL), cstr, 1024, kCFStringEncodingISOLatin2); fprintf(stderr, "libtkedenPath=%s\n", cstr); */ if (CFURLGetFileSystemRepresentation(libtkedenURL, true, libtkedenPath, MAX_PATH_LEN)) { setLibLocation(libtkedenPath); } else { /* gcc needs the -fpascal-strings option to allow \p (which means form a Pascal string: max 255 chars, the first byte states the length) */ /* ideally errors like this would appear in a Mac dialog box, eg via StandardAlert(), but I can't get this to link any more, so doing it this way instead. I think that if they occur, these errors will be visible in Console.app. [Ash] */ fprintf(stderr, "Ooops: couldn't GetFileSystemRepresentation of libtkedenURL"); exit(1); } free(libtkedenPath); } else { fprintf(stderr, "Ooops: Couldn't find libtkedenURL"); } } else { fprintf(stderr, "Ooops: Couldn't find mainBundleRef"); } }