sdmmd_return_t SDMMD_AMDeviceSecureInstallApplication(SDMMD_AMConnectionRef conn, SDMMD_AMDeviceRef device, CFURLRef path, CFDictionaryRef options, CallBack installCallback, void *unknown) { sdmmd_return_t result = kAMDSuccess; SDMMD_AMConnectionRef connection = NULL; bool hasConnection = (conn ? true : false); if (device) { result = SDMMD_AMDeviceSecureStartService(device, CFSTR(AMSVC_INSTALLATION_PROXY), NULL, &connection); if (result == 0) { hasConnection = true; } else { printf("%s: Was unable to start the install service on the device 0x%x.\n", __FUNCTION__, result); } } if (hasConnection) { CFStringRef lastComp = CFURLCopyLastPathComponent(path); if (CFStringGetLength(lastComp) == 0) { CFSafeRelease(lastComp); CFURLRef pathURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, path); lastComp = CFURLCopyLastPathComponent(pathURL); CFSafeRelease(pathURL); } if (lastComp) { CFStringRef format = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("PublicStaging/%@"), lastComp); if (format) { char *appName = SDMCFStringGetString(format); printf("%s: Attempting install of %s.\n", __FUNCTION__, appName); result = SDMMD_perform_command(connection, CFSTR("Install"), 0, installCallback, 4, unknown, CFSTR("PackagePath"), format, CFSTR("ClientOptions"), options); if (result) { printf("%s: Old style of install failed for (%s).\n", __FUNCTION__, appName); } Safe(free, appName); } else { printf("%s: Unable to create CFString!\n", __FUNCTION__); } CFSafeRelease(format); } else { char *lastCompString = SDMCFStringGetString(lastComp); printf("%s: Could not copy last path component from url %s.\n", __FUNCTION__, lastCompString); Safe(free, lastCompString); } CFSafeRelease(lastComp); } CFSafeRelease(connection); char *pathString = SDMCFURLGetString(path); printf("%s: Installation of package %s returned 0x%x.\n", __FUNCTION__, pathString, result); Safe(free, pathString); return result; }
OSStatus PosixPathToParentFSRefAndName(const char *path, FSRef &outParentDir, CFStringRef &outFileName) { // convert C string to CFString #if !TARGET_OS_WIN32 CFStringRef cfFullPath = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8); #else CFStringRef cfFullPath = CFStringCreateWithCString(NULL, path, kCFStringEncodingWindowsLatin1); #endif // convert CF string to URL CFURLRef fullurl = CFURLCreateWithFileSystemPath(NULL, cfFullPath, TARGET_OS_WIN32 ? kCFURLWindowsPathStyle : kCFURLPOSIXPathStyle, false); CFRelease(cfFullPath); // get the directory portion of the URL CFURLRef dirurl = CFURLCreateCopyDeletingLastPathComponent(NULL, fullurl); // get the directory's FSSpec OSStatus err = CFURLGetFSRef(dirurl, &outParentDir) ? OSStatus(noErr) : OSStatus(fnfErr); CFRelease(dirurl); CFStringRef lastPathComponent = CFURLCopyLastPathComponent(fullurl); CFRelease(fullurl); CFMutableStringRef filename = CFStringCreateMutableCopy(NULL, 0, lastPathComponent); CFRelease(lastPathComponent); // convert colons (legal in POSIX paths, illegal in File Manager) to slashes CFStringFindAndReplace(filename, CFSTR(":"), CFSTR("/"), CFRangeMake(0, CFStringGetLength(filename)), 0); outFileName = filename; return err; }
void _glfwChangeToResourcesDirectory( void ) { CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL( mainBundle ); char resourcesPath[ _GLFW_MAX_PATH_LENGTH ]; CFStringRef lastComponent = CFURLCopyLastPathComponent( resourcesURL ); if ( kCFCompareEqualTo != CFStringCompare( CFSTR( "Resources" ), lastComponent, 0 ) ) { UNBUNDLED; } CFRelease( lastComponent ); if( !CFURLGetFileSystemRepresentation( resourcesURL, TRUE, (UInt8*)resourcesPath, _GLFW_MAX_PATH_LENGTH ) ) { CFRelease( resourcesURL ); UNBUNDLED; } CFRelease( resourcesURL ); if( chdir( resourcesPath ) != 0 ) { UNBUNDLED; } }
int makeHFSFromPosixPath(char *pathString, int pathStringLength,char *dst,char *lastpart) { CFStringRef filePath; CFURLRef sillyThing; CFStringRef filePath2,lastPathPart; dst[0] = 0x00; if (lastpart) lastpart[0] = 0x00; filePath = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)pathString,pathStringLength,gCurrentVMEncoding,false); if (filePath == nil) return -1; // HFS+ imposes Unicode2.1 decomposed UTF-8 encoding on all path elements CFMutableStringRef str= CFStringCreateMutableCopy(NULL, 0, filePath); if (gCurrentVMEncoding == kCFStringEncodingUTF8) CFStringNormalize(str, kCFStringNormalizationFormKC); // canonical decomposition sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, str, kCFURLPOSIXPathStyle,false); CFRelease(str); if (sillyThing == NULL) return -2; filePath2 = CFURLCopyFileSystemPath (sillyThing, kCFURLHFSPathStyle); CFStringGetCString (filePath2,dst,1000, gCurrentVMEncoding); if (lastpart) { lastPathPart = CFURLCopyLastPathComponent(sillyThing); CFStringGetCString(lastPathPart,lastpart,256, gCurrentVMEncoding); CFRelease(lastPathPart); } CFRelease(filePath); CFRelease(sillyThing); CFRelease(filePath2); return 0; }
char* SDMDaodanFindTargetBundleIdentifier(char *targetPath) { CFStringRef targetExecutablePath = CFStringCreateWithCString(kCFAllocatorDefault, targetPath, kCFStringEncodingUTF8); CFURLRef executableURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, targetExecutablePath, kCFURLPOSIXPathStyle, false); CFRelease(targetExecutablePath); CFURLRef macOSURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, executableURL); CFURLRef contentsURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, macOSURL); CFRelease(macOSURL); CFURLRef appURL = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, contentsURL); CFRelease(contentsURL); CFArrayRef bundles = CFBundleCreateBundlesFromDirectory(kCFAllocatorDefault, appURL, NULL); CFRelease(appURL); CFStringRef targetIdentifier = NULL; for (uint32_t i = 0x0; i < CFArrayGetCount(bundles); i++) { CFBundleRef bundleItem = (CFBundleRef)CFArrayGetValueAtIndex(bundles, i); targetIdentifier = CFBundleGetIdentifier(bundleItem); if (targetIdentifier) { break; } } CFRelease(bundles); char *bundle; if (!targetIdentifier) { CFStringRef executableIdentifier = CFURLCopyLastPathComponent(executableURL); bundle = SDMCFStringGetString(executableIdentifier); CFRelease(executableIdentifier); } else { bundle = SDMCFStringGetString(targetIdentifier); } CFRelease(executableURL); return bundle; }
/******************************************************************** * MoveFile * lpFromFileName: old file path * lpToFileName: new file path ********************************************************************/ BOOL MoveFile(const char * lpFromFileName, const char * lpToFileName) { OSErr theErr; FSRef fromFileRef; FSRef toFileRef; FSRef parentFolderRef; // Get the path to the old file theErr = FSPathMakeRef((const UInt8 *)lpFromFileName, &fromFileRef, NULL); if (theErr != noErr) { SetLastError(theErr); return false; } // Get the path to the new folder for the file char folderName[strlen(lpToFileName)]; CFStringRef folderPathCFString = CFStringCreateWithCString(NULL, lpToFileName, kCFStringEncodingUTF8); CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, folderPathCFString, kCFURLPOSIXPathStyle, FALSE); CFURLRef folderURL = CFURLCreateCopyDeletingLastPathComponent(NULL, fileURL); CFURLGetFileSystemRepresentation(folderURL, TRUE, (UInt8 *)folderName, strlen(lpToFileName)); theErr = FSPathMakeRef((UInt8 *)folderName, &parentFolderRef, NULL); CFRelease(fileURL); CFRelease(folderURL); CFRelease(folderPathCFString); // Move the old file theErr = FSMoveObject(&fromFileRef, &parentFolderRef, &toFileRef); if (theErr != noErr) { SetLastError(theErr); return false; } // Get a CFString for the new file name CFStringRef newFileNameCFString = CFStringCreateWithCString(NULL, lpToFileName, kCFStringEncodingUTF8); fileURL = CFURLCreateWithFileSystemPath(NULL, newFileNameCFString, kCFURLPOSIXPathStyle, FALSE); CFRelease(newFileNameCFString); newFileNameCFString = CFURLCopyLastPathComponent(fileURL); CFRelease(fileURL); // Convert CFString to Unicode and rename the file UniChar unicodeFileName[256]; CFStringGetCharacters(newFileNameCFString, CFRangeMake(0, CFStringGetLength(newFileNameCFString)), unicodeFileName); theErr = FSRenameUnicode(&toFileRef, CFStringGetLength(newFileNameCFString), unicodeFileName, kTextEncodingUnknown, NULL); if (theErr != noErr) { SetLastError(theErr); CFRelease(newFileNameCFString); return false; } CFRelease(newFileNameCFString); SetLastError(theErr); return true; }
char* SDMDaodanFindTargetName(char *targetPath) { CFStringRef targetExecutablePath = CFStringCreateWithCString(kCFAllocatorDefault, targetPath, kCFStringEncodingUTF8); CFURLRef executableURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, targetExecutablePath, kCFURLPOSIXPathStyle, false); CFRelease(targetExecutablePath); CFStringRef targetIdentifier = CFURLCopyLastPathComponent(executableURL); char *targetName = SDMCFStringGetString(targetIdentifier); CFRelease(targetIdentifier); CFRelease(executableURL); return targetName; }
int dir_Create(char *pathString, int pathStringLength) { /* Create a new directory with the given path. By default, this directory is created in the current directory. Use a full path name such as "MyDisk:Working:New Folder" to create folders elsewhere. */ char cFileName[1001]; if (pathStringLength >= 1000) { return false; } /* copy the file name into a null-terminated C string */ sqFilenameFromString((char *) cFileName, (int) pathString, pathStringLength); #if defined(__MWERKS__) { CFStringRef filePath,lastFilePath; CFURLRef sillyThing,sillyThing2; FSRef parentFSRef; UniChar buffer[1024]; long tokenLength; int err; filePath = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)cFileName,strlen(cFileName),gCurrentVMEncoding,false); if (filePath == nil) return false; sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLHFSPathStyle,true); CFRelease(filePath); lastFilePath = CFURLCopyLastPathComponent(sillyThing); tokenLength = CFStringGetLength(lastFilePath); if (tokenLength > 1024) return false; CFStringGetCharacters(lastFilePath,CFRangeMake(0,tokenLength),buffer); CFRelease(lastFilePath); sillyThing2 = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault,sillyThing); err = CFURLGetFSRef(sillyThing2,&parentFSRef); CFRelease(sillyThing); CFRelease(sillyThing2); if (err == 0) { return false; } err = FSCreateDirectoryUnicode(&parentFSRef,tokenLength,buffer,kFSCatInfoNone,NULL,NULL,NULL,NULL); return (err == noErr ? 1 : 0); } #else return mkdir(cFileName, 0777) == 0; #endif }
void MDSAttrParser::parseAttrs(CFStringRef subdir) { /* get all *.mdsinfo files */ CFArrayRef bundleInfoFiles = CFBundleCopyResourceURLsOfType(mBundle, CFSTR(MDS_INFO_TYPE), subdir); if(bundleInfoFiles == NULL) { Syslog::alert("MDSAttrParser: no mdsattr files for %s", mPath); return; } assert(CFGetTypeID(bundleInfoFiles) == CFArrayGetTypeID()); /* process each .mdsinfo file */ CFIndex numFiles = CFArrayGetCount(bundleInfoFiles); for(CFIndex i=0; i<numFiles; i++) { /* get filename as CFURL */ CFURLRef infoUrl = NULL; infoUrl = reinterpret_cast<CFURLRef>( CFArrayGetValueAtIndex(bundleInfoFiles, i)); if(infoUrl == NULL) { MPDebug("MDSAttrParser: CFBundleCopyResourceURLsOfType screwup 1"); continue; } if(CFGetTypeID(infoUrl) != CFURLGetTypeID()) { MPDebug("MDSAttrParser: CFBundleCopyResourceURLsOfType screwup 2"); continue; } // @@@ Workaround for 4234967: skip any filename beginning with "._" CFStringRef lastComponent = CFURLCopyLastPathComponent(infoUrl); if (lastComponent) { CFStringRef resFilePfx = CFSTR("._"); // setting the search length and location like this permits, // e.g., ".foo.mdsinfo" to be valid CFIndex resFilePfxLen = CFStringGetMaximumSizeForEncoding(CFStringGetLength(resFilePfx), kCFStringEncodingUTF8); CFRange range = CFRangeMake(0, resFilePfxLen); Boolean skip = CFStringFindWithOptions(lastComponent, resFilePfx, range, 0/*options*/, NULL/*returned substr*/); CFRelease(lastComponent); if (skip == true) { Syslog::warning("MDSAttrParser: ignoring resource file"); continue; } } parseFile(infoUrl, subdir); } /* for each mdsinfo */ CF_RELEASE(bundleInfoFiles); }
//--------------------------------------------------------------------- // Sets up the window's title and proxy icon based on the given file. // void SetWindowTitleAndProxyFromCFURL(WindowRef window, CFURLRef file) { CFStringRef title; FSRef fileAsFSRef; require( (CFURLGetFSRef(file, &fileAsFSRef) != false), CantGetFSRef ); verify_noerr( HIWindowSetProxyFSRef(window, &fileAsFSRef) ); title = CFURLCopyLastPathComponent(file); verify_noerr( SetWindowTitleWithCFString(window, title) ); CFRelease(title); CantGetFSRef: return; }
// // set our static text control to be the name of the movie // static OSStatus SetControlTextToMovieName() { CFStringRef stringRef = CFURLCopyLastPathComponent (mMovieFileURLref); CFIndex size = CFStringGetLength (stringRef); CFRange range = CFRangeMake(0, size); UniChar *buffer = (UniChar *)malloc(range.length * sizeof(UniChar)); if (buffer) { CFStringGetCharacters(stringRef, range, buffer); SetControlData (mMovNameRef, kControlNoPart, kControlStaticTextTextTag, size * 2, buffer); free((void *)buffer); CFRelease(stringRef); } }
int getLastPathComponentInCurrentEncoding(char *pathString,char * lastPathPart,CFStringEncoding encoding) { CFURLRef sillyThing; CFStringRef tmpStrRef; sillyThing = makeFileSystemURLFromString(pathString,strlen(pathString),encoding); if (sillyThing == NULL) return -2000; tmpStrRef = CFURLCopyLastPathComponent(sillyThing); CFRelease(sillyThing); CFMutableStringRef mutableStr= CFStringCreateMutableCopy(NULL, 0, tmpStrRef); CFRelease(tmpStrRef); // HFS+ imposes Unicode2.1 decomposed UTF-8 encoding on all path elements if (gCurrentVMEncoding == kCFStringEncodingUTF8) CFStringNormalize(mutableStr, kCFStringNormalizationFormC); // pre-combined CFStringGetCString (mutableStr, lastPathPart,256, gCurrentVMEncoding); CFRelease(mutableStr); return 0; }
OSStatus GeneratePreviewForURL(void *thisInterface, QLPreviewRequestRef preview, CFURLRef url, CFStringRef contentTypeUTI, CFDictionaryRef options) { CGDataProviderRef dataProvider = CGDataProviderCreateWithURL(url); if (!dataProvider) return -1; CFDataRef data = CGDataProviderCopyData(dataProvider); CGDataProviderRelease(dataProvider); if (!data) return -1; int width, height, channels; unsigned char* rgbadata = SOIL_load_image_from_memory(CFDataGetBytePtr(data), CFDataGetLength(data), &width, &height, &channels, SOIL_LOAD_RGBA); CFStringRef format=CFStringCreateWithBytes(NULL, CFDataGetBytePtr(data) + 0x54, 4, kCFStringEncodingASCII, false); CFRelease(data); if (!rgbadata) return -1; CGColorSpaceRef rgb = CGColorSpaceCreateDeviceRGB(); CGContextRef context = CGBitmapContextCreate(rgbadata, width, height, 8, width * 4, rgb, kCGImageAlphaPremultipliedLast); SOIL_free_image_data(rgbadata); CGColorSpaceRelease(rgb); if (!context) return -1; CGImageRef image = CGBitmapContextCreateImage(context); CGContextRelease(context); if (!image) return -1; /* Add basic metadata to title */ CFStringRef name = CFURLCopyLastPathComponent(url); CFTypeRef keys[1] = {kQLPreviewPropertyDisplayNameKey}; CFTypeRef values[1] = {CFStringCreateWithFormat(NULL, NULL, CFSTR("%@ (%dx%d %@)"), name, width, height, format)}; CFDictionaryRef properties = CFDictionaryCreate(NULL, (const void**)keys, (const void**)values, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFRelease(name); context = QLPreviewRequestCreateContext(preview, CGSizeMake(width, height), true, properties); CGContextDrawImage(context, CGRectMake(0, 0, width, height), image); QLPreviewRequestFlushContext(preview, context); CGContextRelease(context); CFRelease(format); CFRelease(properties); return noErr; }
CF::String URL::GetLastPathComponent( void ) { CF::String str; CFStringRef cfStr; if( this->_cfObject == NULL ) { return str; } cfStr = CFURLCopyLastPathComponent( this->_cfObject ); if( cfStr != NULL ) { str = cfStr; CFRelease( cfStr ); } return str; }
CFStringRef CreateDisplayNameForURL(CFURLRef url) { assert(nullptr != url); CFStringRef displayName = nullptr; #if !TARGET_OS_IPHONE CFStringRef scheme = CFURLCopyScheme(url); if(scheme) { bool isFileURL = (kCFCompareEqualTo == CFStringCompare(CFSTR("file"), scheme, kCFCompareCaseInsensitive)); CFRelease(scheme), scheme = nullptr; if(isFileURL) { OSStatus result = LSCopyDisplayNameForURL(url, &displayName); if(noErr != result) { LOGGER_WARNING("org.sbooth.AudioEngine", "LSCopyDisplayNameForURL failed: " << result); displayName = CFURLCopyLastPathComponent(url); } } else { displayName = CFURLGetString(url); CFRetain(displayName); } } // If scheme is nullptr the URL is probably invalid, but can still be logged else { displayName = CFURLGetString(url); CFRetain(displayName); } #else displayName = CFURLGetString(url); CFRetain(displayName); #endif return displayName; }
sqInt ioFilenamefromStringofLengthresolveAliases(char* dst, char* src, sqInt num, sqInt resolveAlias) { FSRef theFSRef; FSSpec convertFileNameSpec,failureRetry; OSErr err; Boolean isFolder=false,isAlias=false; CFURLRef sillyThing,appendedSillyThing; CFStringRef lastPartOfPath,filePath2; CFMutableStringRef filePath; *dst = 0x00; err = quicklyMakePath((char *) src,num,dst,resolveAlias); if (err == noErr) return; err = lookupPath((char *) src,num,&convertFileNameSpec,true,false); if ((err == noErr) && resolveAlias) { err = ResolveAliasFile(&convertFileNameSpec,true,&isFolder,&isAlias); if (err == fnfErr) { err = lookupPath((char *) src,num,&convertFileNameSpec,false,false); err = ResolveAliasFile(&convertFileNameSpec,true,&isFolder,&isAlias); } } if (err == fnfErr) { failureRetry = convertFileNameSpec; CopyCStringToPascal("::",failureRetry.name); err = FSpMakeFSRef(&failureRetry,&theFSRef); if (err != noErr) return; // filePath = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)src,num,gCurrentVMEncoding,false); CFStringRef tmpStrRef = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)src,num,gCurrentVMEncoding,false); if (tmpStrRef == nil) return; filePath = CFStringCreateMutableCopy(NULL, 0, tmpStrRef); if (gCurrentVMEncoding == kCFStringEncodingUTF8) CFStringNormalize(filePath, kCFStringNormalizationFormKD); // canonical decomposition sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLHFSPathStyle,false); CFRelease(filePath); if (sillyThing == NULL) return; lastPartOfPath = CFURLCopyLastPathComponent(sillyThing); CFRelease(sillyThing); sillyThing = CFURLCreateFromFSRef(kCFAllocatorDefault,&theFSRef); appendedSillyThing = CFURLCreateCopyAppendingPathComponent(kCFAllocatorDefault,sillyThing,lastPartOfPath,false); #if defined(__MWERKS__) && !defined(__APPLE__) && !defined(__MACH__) filePath2 = CFURLCopyFileSystemPath (appendedSillyThing, kCFURLHFSPathStyle); #else filePath2 = CFURLCopyFileSystemPath (appendedSillyThing, kCFURLPOSIXPathStyle); #endif CFStringGetCString (filePath2,dst,1000, gCurrentVMEncoding); CFRelease(sillyThing); CFRelease(appendedSillyThing); CFRelease(lastPartOfPath); CFRelease(filePath2); return; } err = FSpMakeFSRef(&convertFileNameSpec,&theFSRef); #if defined(__MWERKS__) && !defined(__APPLE__) && !defined(__MACH__) sillyThing = CFURLCreateFromFSRef(kCFAllocatorDefault,&theFSRef); filePath = CFURLCopyFileSystemPath (sillyThing, kCFURLHFSPathStyle); CFStringGetCString (filePath,dst,1000, gCurrentVMEncoding); CFRelease(sillyThing); CFRelease(filePath); return; #else err = FSRefMakePath(&theFSRef,(UInt8 *)dst,1000); #endif }
static int quicklyMakePath(char *pathString, int pathStringLength,char *dst, Boolean resolveAlias) { CFStringRef filePath; CFURLRef sillyThing,firstPartOfPath; FSRef theFSRef; Boolean isFolder,isAlias; OSErr err; filePath = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)pathString,pathStringLength,gCurrentVMEncoding,false); if (filePath == nil) return -1; CFMutableStringRef str= CFStringCreateMutableCopy(NULL, 0, filePath); // HFS+ imposes Unicode2.1 decomposed UTF-8 encoding on all path elements if (gCurrentVMEncoding == kCFStringEncodingUTF8) CFStringNormalize(str, kCFStringNormalizationFormKC); // canonical decomposition sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, str, kCFURLHFSPathStyle,false); if (sillyThing == NULL) { CFRelease(filePath); return -2; } CFRelease(str); if (!CFURLGetFSRef(sillyThing,&theFSRef)) { firstPartOfPath = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault,sillyThing); if (!CFURLGetFSRef(firstPartOfPath,&theFSRef)) { CFRelease(firstPartOfPath); CFRelease(filePath); CFRelease(sillyThing); return -1; } else { CFStringRef lastPathPart; char lastpart[256]; CFRelease(filePath); CFRelease(firstPartOfPath); lastPathPart = CFURLCopyLastPathComponent(sillyThing); CFRelease(sillyThing); err = noErr; if (resolveAlias) err = FSResolveAliasFile (&theFSRef,true,&isFolder,&isAlias); if (err) return 2; err = FSRefMakePath(&theFSRef,(UInt8 *)dst,1000); CFStringGetCString(lastPathPart,lastpart,256, kCFStringEncodingUTF8); CFRelease(lastPathPart); if (strlen(dst)+1+strlen(lastpart) < 1000) { strcat(dst,"/"); strcat(dst,lastpart); #if defined(__MWERKS__) && !defined(__APPLE__) && !defined(__MACH__) filePath = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)dst,strlen(dst),gCurrentVMEncoding,false); if (filePath == nil) return 2; sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLPOSIXPathStyle,true); CFRelease(filePath); filePath = CFURLCopyFileSystemPath (sillyThing, kCFURLHFSPathStyle); CFStringGetCString (filePath,dst,1000, gCurrentVMEncoding); CFRelease(sillyThing); CFRelease(filePath); #endif return 0; } else return 2; } } CFRelease(filePath); CFRelease(sillyThing); if (resolveAlias) err = FSResolveAliasFile (&theFSRef,true,&isFolder,&isAlias); #if defined(__MWERKS__) && !defined(__APPLE__) && !defined(__MACH__) sillyThing = CFURLCreateFromFSRef(kCFAllocatorDefault,&theFSRef); filePath = CFURLCopyFileSystemPath (sillyThing, kCFURLHFSPathStyle); CFStringGetCString (filePath,dst,1000, gCurrentVMEncoding); CFRelease(sillyThing); CFRelease(filePath); return 0; #else err = FSRefMakePath(&theFSRef,(UInt8 *)dst,1000); return err; #endif }
mDNSlocal void FetchRootTA(mDNS *const m) { CFStringRef urlString = CFSTR("https://data.iana.org/root-anchors/root-anchors.xml"); CFDataRef xmlData; CFStringRef fileRef = NULL; const char *xmlFileName = NULL; char buf[512]; CFURLRef url = NULL; static unsigned int RootTAFetchInterval = InitialTAFetchInterval; (void) m; TrustAnchor *ta = (TrustAnchor *)mDNSPlatformMemAllocate(sizeof(TrustAnchor)); if (!ta) { LogMsg("FetchRootTA: TrustAnchor alloc failed"); return; } memset(ta, 0, sizeof(TrustAnchor)); url = CFURLCreateWithString(NULL, urlString, NULL); if (!url) { LogMsg("FetchRootTA: CFURLCreateWithString error"); mDNSPlatformMemFree(ta); return; } // If we can't fetch the XML file e.g., network problems, trigger a timer. All other failures // should hardly happen in practice for which schedule the normal interval to refetch the TA. if (!CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, url, &xmlData, NULL, NULL, NULL)) { LogInfo("FetchRootTA: CFURLCreateDataAndPropertiesFromResource error"); CFRelease(url); mDNSPlatformMemFree(ta); RegisterNotification(m, RootTAFetchInterval); RootTAFetchInterval *= 2 + 1; return; } // get the name of the last component from the url, libxml will use it if // it has to report an error fileRef = CFURLCopyLastPathComponent(url); if (fileRef) { xmlFileName = CFStringGetCStringPtr(fileRef, kCFStringEncodingUTF8); if (!xmlFileName) { if (!CFStringGetCString(fileRef, buf, sizeof(buf), kCFStringEncodingUTF8) ) strlcpy(buf, "nofile.xml", sizeof(buf)); xmlFileName = (const char *)buf; } } // Parse the XML and get the CFXMLTree. xmlDocPtr tadoc = xmlReadMemory((const char*)CFDataGetBytePtr(xmlData), (int)CFDataGetLength(xmlData), xmlFileName, NULL, 0); CFRelease(fileRef); CFRelease(url); CFRelease(xmlData); if (!tadoc) { LogMsg("FetchRootTA: xmlReadMemory failed"); goto done; } xmlNodePtr root = xmlDocGetRootElement(tadoc); if (!root) { LogMsg("FetchRootTA: Cannot get root element"); goto done; } if (ParseElement(tadoc, root, ta) && ValidateTrustAnchor(ta)) { // Do the actual addition of TA on the main queue. mDNSPlatformDispatchAsync(m, ta, TAComplete); } else { if (ta->rds.digest) mDNSPlatformMemFree(ta->rds.digest); mDNSPlatformMemFree(ta); } done: if (tadoc) xmlFreeDoc(tadoc); RegisterNotification(m, ROOT_TA_UPDATE_INTERVAL); RootTAFetchInterval = InitialTAFetchInterval; return; }
static pascal OSStatus MultiCartPaneEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; HIViewRef view; DragRef drag; PasteboardRef pasteboard; PasteboardItemID itemID; CFArrayRef array; CFStringRef flavorType; CFIndex numFlavors; ItemCount numItems; int index = *((int *) inUserData); switch (GetEventClass(inEvent)) { case kEventClassControl: { switch (GetEventKind(inEvent)) { case kEventControlDraw: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { CGContextRef ctx; err = GetEventParameter(inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(CGContextRef), NULL, &ctx); if (err == noErr) { HIThemeFrameDrawInfo info; HIRect bounds, frame; HIViewGetBounds(view, &bounds); CGContextSetRGBFillColor(ctx, 1.0f, 1.0f, 1.0f, 1.0f); CGContextFillRect(ctx, bounds); info.version = 0; info.kind = kHIThemeFrameTextFieldSquare; info.state = kThemeStateInactive; info.isFocused = false; err = HIThemeDrawFrame(&bounds, &info, ctx, kHIThemeOrientationNormal); if (multiCartDragHilite == index && systemVersion >= 0x1040) { err = HIThemeSetStroke(kThemeBrushDragHilite, NULL, ctx, kHIThemeOrientationNormal); frame = CGRectInset(bounds, 1, 1); CGContextBeginPath(ctx); CGContextAddRect(ctx, frame); CGContextStrokePath(ctx); } } } result = noErr; break; } case kEventControlDragEnter: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { err = GetEventParameter(inEvent, kEventParamDragRef, typeDragRef, NULL, sizeof(DragRef), NULL, &drag); if (err == noErr) { err = GetDragPasteboard(drag, &pasteboard); if (err == noErr) { err = PasteboardGetItemCount(pasteboard, &numItems); if (err == noErr && numItems == 1) { err = PasteboardGetItemIdentifier(pasteboard, 1, &itemID); if (err == noErr) { err = PasteboardCopyItemFlavors(pasteboard, itemID, &array); if (err == noErr) { numFlavors = CFArrayGetCount(array); for (CFIndex i = 0; i < numFlavors; i++) { flavorType = (CFStringRef) CFArrayGetValueAtIndex(array, i); if (UTTypeConformsTo(flavorType, CFSTR("public.file-url"))) { Boolean accept = true; err = SetEventParameter(inEvent, kEventParamControlWouldAcceptDrop, typeBoolean, sizeof(Boolean), &accept); if (err == noErr) { multiCartDragHilite = index; HIViewSetNeedsDisplay(view, true); result = noErr; } } } CFRelease(array); } } } } } } break; } case kEventControlDragWithin: { result = noErr; break; } case kEventControlDragLeave: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { multiCartDragHilite = -1; HIViewSetNeedsDisplay(view, true); } result = noErr; break; } case kEventControlDragReceive: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { err = GetEventParameter(inEvent, kEventParamDragRef, typeDragRef, NULL, sizeof(DragRef), NULL, &drag); if (err == noErr) { multiCartDragHilite = -1; HIViewSetNeedsDisplay(view, true); err = GetDragPasteboard(drag, &pasteboard); if (err == noErr) { err = PasteboardGetItemIdentifier(pasteboard, 1, &itemID); if (err == noErr) { err = PasteboardCopyItemFlavors(pasteboard, itemID, &array); if (err == noErr) { numFlavors = CFArrayGetCount(array); for (CFIndex i = 0; i < numFlavors; i++) { flavorType = (CFStringRef) CFArrayGetValueAtIndex(array, i); if (UTTypeConformsTo(flavorType, CFSTR("public.file-url"))) { CFDataRef flavorData; err = PasteboardCopyItemFlavorData(pasteboard, itemID, flavorType, &flavorData); if (err == noErr) { CFIndex dataSize; UInt8 *data; dataSize = CFDataGetLength(flavorData); data = (UInt8 *) malloc(dataSize); if (data) { CFDataGetBytes(flavorData, CFRangeMake(0, dataSize), data); HIViewRef ctl; HIViewID cid; CFStringRef str; CFURLRef url; GetControlID(view, &cid); cid.signature = 'MNAM'; HIViewFindByID(view, cid, &ctl); url = CFURLCreateWithBytes(kCFAllocatorDefault, data, dataSize, kCFStringEncodingUTF8, NULL); str = CFURLCopyLastPathComponent(url); SetStaticTextCFString(ctl, str, true); CFRelease(str); str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); if (multiCartPath[cid.id]) CFRelease(multiCartPath[cid.id]); multiCartPath[cid.id] = str; CFRelease(url); result = noErr; free(data); } CFRelease(flavorData); } } } CFRelease(array); } } } } } } } } } return (result); }
int keychain_import(int argc, char * const *argv) { int ch, result = 0; char *inFile = NULL; char *kcName = NULL; SecKeychainRef kcRef = NULL; SecExternalFormat externFormat = kSecFormatUnknown; SecExternalItemType itemType = kSecItemTypeUnknown; Boolean wrapped = FALSE; Boolean nonExtractable = FALSE; const char *passphrase = NULL; unsigned char *inFileData = NULL; unsigned inFileLen = 0; CFDataRef inData = NULL; unsigned numExtendedAttributes = 0; char **attrNames = NULL; char **attrValues = NULL; Boolean access_specified = FALSE; Boolean always_allow = FALSE; SecAccessRef access = NULL; CFMutableArrayRef trusted_list = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks); if(argc < 2) { result = 2; /* @@@ Return 2 triggers usage message. */ goto cleanup; } inFile = argv[1]; if((argc == 2) && (inFile[0] == '-')) { result = 2; goto cleanup; } optind = 2; while ((ch = getopt(argc, argv, "k:t:f:P:wxa:hAT:")) != -1) { switch (ch) { case 'k': kcName = optarg; break; case 't': if(!strcmp("pub", optarg)) { itemType = kSecItemTypePublicKey; } else if(!strcmp("priv", optarg)) { itemType = kSecItemTypePrivateKey; } else if(!strcmp("session", optarg)) { itemType = kSecItemTypeSessionKey; } else if(!strcmp("cert", optarg)) { itemType = kSecItemTypeCertificate; } else if(!strcmp("agg", optarg)) { itemType = kSecItemTypeAggregate; } else { result = 2; /* @@@ Return 2 triggers usage message. */ goto cleanup; } break; case 'f': if(!strcmp("openssl", optarg)) { externFormat = kSecFormatOpenSSL; } else if(!strcmp("openssh1", optarg)) { externFormat = kSecFormatSSH; } else if(!strcmp("openssh2", optarg)) { externFormat = kSecFormatSSHv2; } else if(!strcmp("bsafe", optarg)) { externFormat = kSecFormatBSAFE; } else if(!strcmp("raw", optarg)) { externFormat = kSecFormatRawKey; } else if(!strcmp("pkcs7", optarg)) { externFormat = kSecFormatPKCS7; } else if(!strcmp("pkcs8", optarg)) { externFormat = kSecFormatWrappedPKCS8; } else if(!strcmp("pkcs12", optarg)) { externFormat = kSecFormatPKCS12; } else if(!strcmp("netscape", optarg)) { externFormat = kSecFormatNetscapeCertSequence; } else if(!strcmp("x509", optarg)) { externFormat = kSecFormatX509Cert; } else if(!strcmp("pemseq", optarg)) { externFormat = kSecFormatPEMSequence; } else { result = 2; /* @@@ Return 2 triggers usage message. */ goto cleanup; } break; case 'w': wrapped = TRUE; break; case 'x': nonExtractable = TRUE; break; case 'P': passphrase = optarg; break; case 'a': /* this takes an additional argument */ if(optind > (argc - 1)) { result = 2; /* @@@ Return 2 triggers usage message. */ goto cleanup; } attrNames = (char **)realloc(attrNames, numExtendedAttributes * sizeof(char *)); attrValues = (char **)realloc(attrValues, numExtendedAttributes * sizeof(char *)); attrNames[numExtendedAttributes] = optarg; attrValues[numExtendedAttributes] = argv[optind]; numExtendedAttributes++; optind++; break; case 'A': always_allow = TRUE; access_specified = TRUE; break; case 'T': if (optarg[0]) { SecTrustedApplicationRef app = NULL; OSStatus status = noErr; /* check whether the argument specifies an application group */ const char *groupPrefix = "group://"; size_t prefixLen = strlen(groupPrefix); if (strlen(optarg) > prefixLen && !memcmp(optarg, groupPrefix, prefixLen)) { const char *groupName = &optarg[prefixLen]; if ((status = SecTrustedApplicationCreateApplicationGroup(groupName, NULL, &app)) != noErr) { sec_error("SecTrustedApplicationCreateApplicationGroup %s: %s", optarg, sec_errstr(status)); } } else { if ((status = SecTrustedApplicationCreateFromPath(optarg, &app)) != noErr) { sec_error("SecTrustedApplicationCreateFromPath %s: %s", optarg, sec_errstr(status)); } } if (status) { result = 1; goto cleanup; } CFArrayAppendValue(trusted_list, app); CFRelease(app); } access_specified = TRUE; break; case '?': default: result = 2; /* @@@ Return 2 triggers usage message. */ goto cleanup; } } if(wrapped) { switch(externFormat) { case kSecFormatOpenSSL: case kSecFormatUnknown: // i.e., use default externFormat = kSecFormatWrappedOpenSSL; break; case kSecFormatSSH: externFormat = kSecFormatWrappedSSH; break; case kSecFormatSSHv2: /* there is no wrappedSSHv2 */ externFormat = kSecFormatWrappedOpenSSL; break; case kSecFormatWrappedPKCS8: /* proceed */ break; default: fprintf(stderr, "Don't know how to wrap in specified format/type\n"); result = 2; /* @@@ Return 2 triggers usage message. */ goto cleanup; } } if(kcName) { kcRef = keychain_open(kcName); if(kcRef == NULL) { return 1; } } if(readFile(inFile, &inFileData, &inFileLen)) { sec_error("Error reading infile %s: %s", inFile, strerror(errno)); result = 1; goto cleanup; } inData = CFDataCreate(NULL, inFileData, inFileLen); if(inData == NULL) { result = 1; goto cleanup; } free(inFileData); if(access_specified) { char *accessName = NULL; CFStringRef fileStr = CFStringCreateWithCString(NULL, inFile, kCFStringEncodingUTF8); if (fileStr) { CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, fileStr, kCFURLPOSIXPathStyle, FALSE); if (fileURL) { CFStringRef nameStr = CFURLCopyLastPathComponent(fileURL); if (nameStr) { CFIndex nameLen = CFStringGetLength(nameStr); CFIndex bufLen = 1 + CFStringGetMaximumSizeForEncoding(nameLen, kCFStringEncodingUTF8); accessName = (char *)malloc(bufLen); if (!CFStringGetCString(nameStr, accessName, bufLen-1, kCFStringEncodingUTF8)) accessName[0]=0; nameLen = strlen(accessName); char *p = &accessName[nameLen]; // initially points to terminating null while (--nameLen > 0) { if (*p == '.') { // strip extension, if any *p = '\0'; break; } p--; } safe_CFRelease(&nameStr); } safe_CFRelease(&fileURL); } safe_CFRelease(&fileStr); } result = create_access(accessName, always_allow, trusted_list, &access); if (accessName) { free(accessName); } if (result != 0) { goto cleanup; } } result = do_keychain_import(kcRef, inData, externFormat, itemType, access, nonExtractable, passphrase, inFile, attrNames, attrValues, numExtendedAttributes); cleanup: safe_CFRelease(&trusted_list); safe_CFRelease(&access); safe_CFRelease(&kcRef); safe_CFRelease(&inData); return result; }
LLDir_Mac::LLDir_Mac() { mDirDelimiter = "/"; mCurrentDirIndex = -1; mCurrentDirCount = -1; CFBundleRef mainBundleRef = NULL; CFURLRef executableURLRef = NULL; CFStringRef stringRef = NULL; OSStatus error = noErr; FSRef fileRef; CFStringRef secondLifeString = CFSTR("SecondLife"); mainBundleRef = CFBundleGetMainBundle(); executableURLRef = CFBundleCopyExecutableURL(mainBundleRef); if (executableURLRef != NULL) { // mExecutablePathAndName CFURLRefToLLString(executableURLRef, mExecutablePathAndName, false); // mExecutableFilename stringRef = CFURLCopyLastPathComponent(executableURLRef); CFStringRefToLLString(stringRef, mExecutableFilename, true); // mExecutableDir CFURLRef executableParentURLRef = CFURLCreateCopyDeletingLastPathComponent(NULL, executableURLRef); CFURLRefToLLString(executableParentURLRef, mExecutableDir, true); // mAppRODataDir CFURLRef resourcesURLRef = CFBundleCopyResourcesDirectoryURL(mainBundleRef); CFURLRefToLLString(resourcesURLRef, mAppRODataDir, true); // mOSUserDir error = FSFindFolder(kUserDomain, kApplicationSupportFolderType, true, &fileRef); if (error == noErr) { FSRef newFileRef; // Create the directory error = CFCreateDirectory(&fileRef, secondLifeString, &newFileRef); if (error == noErr) { // Save the full path to the folder FSRefToLLString(&newFileRef, mOSUserDir); // Create our sub-dirs (void) CFCreateDirectory(&newFileRef, CFSTR("data"), NULL); //(void) CFCreateDirectory(&newFileRef, CFSTR("cache"), NULL); (void) CFCreateDirectory(&newFileRef, CFSTR("logs"), NULL); (void) CFCreateDirectory(&newFileRef, CFSTR("user_settings"), NULL); (void) CFCreateDirectory(&newFileRef, CFSTR("browser_profile"), NULL); } } //mOSCacheDir FSRef cacheDirRef; error = FSFindFolder(kUserDomain, kCachedDataFolderType, true, &cacheDirRef); if (error == noErr) { FSRefToLLString(&cacheDirRef, mOSCacheDir); (void)CFCreateDirectory(&cacheDirRef, CFSTR("SecondLife"),NULL); } // mOSUserAppDir mOSUserAppDir = mOSUserDir; // mTempDir error = FSFindFolder(kOnAppropriateDisk, kTemporaryFolderType, true, &fileRef); if (error == noErr) { FSRef tempRef; error = CFCreateDirectory(&fileRef, secondLifeString, &tempRef); if (error == noErr) FSRefToLLString(&tempRef, mTempDir); } mWorkingDir = getCurPath(); mLLPluginDir = mAppRODataDir + mDirDelimiter + "llplugin"; CFRelease(executableURLRef); executableURLRef = NULL; } }
string URL::basename() const { return mkstr(CFURLCopyLastPathComponent(ref)); }
int __open_file(const char * name, __file_modes mode, __file_handle * handle) { FSSpec spec; OSErr ioResult; HParamBlockRec pb; ioResult = __path2fss(name, &spec); if (ioResult) gSqueakFileLastError = ioResult; if (__system7present()) /* mm 980424 */ { /* mm 980424 */ Boolean targetIsFolder, wasAliased; /* mm 980424 */ ResolveAliasFile(&spec, true, &targetIsFolder, &wasAliased); /* mm 980424 */ } /* mm 980424 */ if (ioResult && (ioResult != fnfErr || mode.open_mode == __must_exist)) return(__io_error); #if TARGET_API_MAC_CARBON if (ioResult) { CFStringRef filePath; CFURLRef sillyThing, sillyThing2; FSRef parentFSRef; short int fileRefNum; OSErr err; UniChar buffer[1024]; long tokenLength; filePath = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)name,strlen(name),gCurrentVMEncoding,false); if (filePath == nil) return __io_error; sillyThing = CFURLCreateWithFileSystemPath (kCFAllocatorDefault,filePath,kCFURLHFSPathStyle,false); CFRelease(filePath); sillyThing2 = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault,sillyThing); err = CFURLGetFSRef(sillyThing2,&parentFSRef); if (err == 0) { CFRelease(sillyThing); CFRelease(sillyThing2); return fnfErr; } filePath = CFURLCopyLastPathComponent(sillyThing); tokenLength = CFStringGetLength(filePath); if (tokenLength > 1024) { CFRelease(filePath); CFRelease(sillyThing); CFRelease(sillyThing2); return(__io_error); } CFStringGetCharacters(filePath,CFRangeMake(0,tokenLength),buffer); CFRelease(filePath); CFRelease(sillyThing); CFRelease(sillyThing2); ioResult = FSCreateFileUnicode(&parentFSRef,tokenLength,buffer,kFSCatInfoNone,NULL,NULL,&spec); if (ioResult) gSqueakFileLastError = ioResult; if (ioResult) return(__io_error); pb.ioParam.ioNamePtr = spec.name; pb.ioParam.ioVRefNum = spec.vRefNum; pb.ioParam.ioPermssn = (mode.io_mode == __read) ? fsRdPerm : fsRdWrPerm; pb.ioParam.ioMisc = 0; pb.fileParam.ioFVersNum = 0; pb.fileParam.ioDirID = spec.parID; set_file_type(&spec, mode.binary_io); ioResult = PBHOpenDFSync(&pb); /* HH 10/25/97 was PBHOpenSync */ if (ioResult) return(__io_error); *handle = pb.ioParam.ioRefNum; return(__no_io_error); } #endif pb.ioParam.ioNamePtr = spec.name; pb.ioParam.ioVRefNum = spec.vRefNum; pb.ioParam.ioPermssn = (mode.io_mode == __read) ? fsRdPerm : fsRdWrPerm; pb.ioParam.ioMisc = 0; pb.fileParam.ioFVersNum = 0; pb.fileParam.ioDirID = spec.parID; if (ioResult) { if (!(ioResult = PBHCreateSync(&pb))) { if (ioResult) gSqueakFileLastError = ioResult; set_file_type(&spec, mode.binary_io); ioResult = PBHOpenDFSync(&pb); /* HH 10/25/97 was PBHOpenSync */ if (ioResult) gSqueakFileLastError = ioResult; } } else { if (!(ioResult = PBHOpenDFSync(&pb)) && mode.open_mode == __create_or_truncate) /* HH 10/25/97 was PBHOpenSync */ { pb.ioParam.ioMisc = 0; ioResult = PBSetEOFSync((ParmBlkPtr) &pb); if (ioResult) gSqueakFileLastError = ioResult; if (ioResult) PBCloseSync((ParmBlkPtr) &pb); } else { if (ioResult) gSqueakFileLastError = ioResult; } } if (ioResult) return(__io_error); *handle = pb.ioParam.ioRefNum; return(__no_io_error); }
kim_error kim_os_library_get_caller_name (kim_string *out_application_name) { kim_error err = KIM_NO_ERROR; kim_string name = NULL; CFBundleRef bundle = CFBundleGetMainBundle (); CFStringRef cfname = NULL; if (!err && !out_application_name) { err = check_error (KIM_NULL_PARAMETER_ERR); } if (!err && bundle) { cfname = CFBundleGetValueForInfoDictionaryKey (bundle, kCFBundleNameKey); if (!cfname || CFGetTypeID (cfname) != CFStringGetTypeID ()) { cfname = CFBundleGetValueForInfoDictionaryKey (bundle, kCFBundleExecutableKey); } if (cfname) { cfname = CFStringCreateCopy (kCFAllocatorDefault, cfname); } } if (!err && !cfname) { kim_string path = NULL; CFURLRef cfpath = NULL; CFURLRef cfpathnoext = NULL; err = kim_os_library_get_application_path (&path); if (!err) { cfpath = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault, (const UInt8 *) path, strlen (path), 0); if (cfpath) { cfpathnoext = CFURLCreateCopyDeletingPathExtension (kCFAllocatorDefault, cfpath); } if (cfpathnoext) { cfname = CFURLCopyLastPathComponent (cfpathnoext); } else { cfname = CFURLCopyLastPathComponent (cfpath); } } if (cfpathnoext) { CFRelease (cfpathnoext); } if (cfpath ) { CFRelease (cfpath); } kim_string_free (&path); } if (!err && cfname) { err = kim_os_string_create_from_cfstring (&name, cfname); } if (!err) { *out_application_name = name; name = NULL; } if (cfname) { CFRelease (cfname); } kim_string_free (&name); return check_error (err); }
AudioDecoder * AudioDecoder::CreateDecoderForInputSource(InputSource *inputSource, CFStringRef mimeType, CFErrorRef *error) { if(NULL == inputSource) return NULL; AudioDecoder *decoder = NULL; // Open the input source if it isn't already if(AutomaticallyOpenDecoders() && !inputSource->IsOpen() && !inputSource->Open(error)) return NULL; // As a factory this class has knowledge of its subclasses // It would be possible (and perhaps preferable) to switch to a generic // plugin interface at a later date #if 0 // If the input is an instance of HTTPInputSource, use the MIME type from the server // This code is disabled because most HTTP servers don't send the correct MIME types HTTPInputSource *httpInputSource = dynamic_cast<HTTPInputSource *>(inputSource); bool releaseMIMEType = false; if(!mimeType && httpInputSource && httpInputSource->IsOpen()) { mimeType = httpInputSource->CopyContentMIMEType(); if(mimeType) releaseMIMEType = true; } #endif // The MIME type takes precedence over the file extension if(mimeType) { #if BUILD_FOR_MAC_OSX if(FLACDecoder::HandlesMIMEType(mimeType)) { decoder = new FLACDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && WavPackDecoder::HandlesMIMEType(mimeType)) { decoder = new WavPackDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MPEGDecoder::HandlesMIMEType(mimeType)) { decoder = new MPEGDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && OggVorbisDecoder::HandlesMIMEType(mimeType)) { decoder = new OggVorbisDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MusepackDecoder::HandlesMIMEType(mimeType)) { decoder = new MusepackDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MonkeysAudioDecoder::HandlesMIMEType(mimeType)) { decoder = new MonkeysAudioDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && OggSpeexDecoder::HandlesMIMEType(mimeType)) { decoder = new OggSpeexDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MODDecoder::HandlesMIMEType(mimeType)) { decoder = new MODDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && LibsndfileDecoder::HandlesMIMEType(mimeType)) { decoder = new LibsndfileDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } #endif if(NULL == decoder && CoreAudioDecoder::HandlesMIMEType(mimeType)) { decoder = new CoreAudioDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } #if 0 if(releaseMIMEType) CFRelease(mimeType), mimeType = NULL; #endif if(decoder) return decoder; } // If no MIME type was specified, use the extension-based resolvers CFURLRef inputURL = inputSource->GetURL(); if(!inputURL) return NULL; CFStringRef pathExtension = CFURLCopyPathExtension(inputURL); if(!pathExtension) { if(error) { CFMutableDictionaryRef errorDictionary = CFDictionaryCreateMutable(kCFAllocatorDefault, 32, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); CFStringRef displayName = CFURLCopyLastPathComponent(inputURL); CFStringRef errorString = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFCopyLocalizedString(CFSTR("The type of the file “%@” could not be determined."), ""), displayName); CFDictionarySetValue(errorDictionary, kCFErrorLocalizedDescriptionKey, errorString); CFDictionarySetValue(errorDictionary, kCFErrorLocalizedFailureReasonKey, CFCopyLocalizedString(CFSTR("Unknown file type"), "")); CFDictionarySetValue(errorDictionary, kCFErrorLocalizedRecoverySuggestionKey, CFCopyLocalizedString(CFSTR("The file's extension may be missing or may not match the file's type."), "")); CFRelease(errorString), errorString = NULL; CFRelease(displayName), displayName = NULL; *error = CFErrorCreate(kCFAllocatorDefault, InputSourceErrorDomain, InputSourceFileNotFoundError, errorDictionary); CFRelease(errorDictionary), errorDictionary = NULL; } return NULL; } // TODO: Some extensions (.oga for example) support multiple audio codecs (Vorbis, FLAC, Speex) // and if openDecoder is false the wrong decoder type may be returned, since the file isn't analyzed // until Open() is called #if BUILD_FOR_MAC_OSX if(FLACDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new FLACDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && WavPackDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new WavPackDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MPEGDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new MPEGDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && OggVorbisDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new OggVorbisDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MusepackDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new MusepackDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MonkeysAudioDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new MonkeysAudioDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && OggSpeexDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new OggSpeexDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && MODDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new MODDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } if(NULL == decoder && LibsndfileDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new LibsndfileDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } #endif if(NULL == decoder && CoreAudioDecoder::HandlesFilesWithExtension(pathExtension)) { decoder = new CoreAudioDecoder(inputSource); if(AutomaticallyOpenDecoders() && !decoder->Open(error)) { decoder->mInputSource = NULL; delete decoder, decoder = NULL; } } CFRelease(pathExtension), pathExtension = NULL; return decoder; }
int Tcl_MacOSXOpenVersionedBundleResources( Tcl_Interp *interp, const char *bundleName, const char *bundleVersion, int hasResourceFile, int maxPathLen, char *libraryPath) { #ifdef HAVE_COREFOUNDATION CFBundleRef bundleRef, versionedBundleRef = NULL; CFStringRef bundleNameRef; CFURLRef libURL; libraryPath[0] = '\0'; bundleNameRef = CFStringCreateWithCString(NULL, bundleName, kCFStringEncodingUTF8); bundleRef = CFBundleGetBundleWithIdentifier(bundleNameRef); CFRelease(bundleNameRef); if (bundleVersion && bundleRef) { /* * Create bundle from bundleVersion subdirectory of 'Versions'. */ CFURLRef bundleURL = CFBundleCopyBundleURL(bundleRef); if (bundleURL) { CFStringRef bundleVersionRef = CFStringCreateWithCString(NULL, bundleVersion, kCFStringEncodingUTF8); if (bundleVersionRef) { CFStringRef bundleTailRef = CFURLCopyLastPathComponent( bundleURL); if (bundleTailRef) { if (CFStringCompare(bundleTailRef, bundleVersionRef, 0) == kCFCompareEqualTo) { versionedBundleRef = (CFBundleRef) CFRetain(bundleRef); } CFRelease(bundleTailRef); } if (!versionedBundleRef) { CFURLRef versURL = CFURLCreateCopyAppendingPathComponent( NULL, bundleURL, CFSTR("Versions"), TRUE); if (versURL) { CFURLRef versionedBundleURL = CFURLCreateCopyAppendingPathComponent( NULL, versURL, bundleVersionRef, TRUE); if (versionedBundleURL) { versionedBundleRef = CFBundleCreate(NULL, versionedBundleURL); CFRelease(versionedBundleURL); } CFRelease(versURL); } } CFRelease(bundleVersionRef); } CFRelease(bundleURL); } if (versionedBundleRef) { bundleRef = versionedBundleRef; } } if (bundleRef) { if (hasResourceFile) { /* * Dynamically acquire address for CFBundleOpenBundleResourceMap * symbol, since it is only present in full CoreFoundation on Mac * OS X and not in CFLite on pure Darwin. */ static int initialized = FALSE; static short (*openresourcemap)(CFBundleRef) = NULL; if (!initialized) { #if TCL_DYLD_USE_DLFCN #if MAC_OS_X_VERSION_MIN_REQUIRED < 1040 if (tclMacOSXDarwinRelease >= 8) #endif { const char *errMsg = nil; openresourcemap = dlsym(RTLD_NEXT, "CFBundleOpenBundleResourceMap"); if (!openresourcemap) { errMsg = dlerror(); TclLoadDbgMsg("dlsym() failed: %s", errMsg); } } if (!openresourcemap) #endif { #if TCL_DYLD_USE_NSMODULE NSSymbol nsSymbol = NULL; if (NSIsSymbolNameDefinedWithHint( "_CFBundleOpenBundleResourceMap", "CoreFoundation")) { nsSymbol = NSLookupAndBindSymbolWithHint( "_CFBundleOpenBundleResourceMap", "CoreFoundation"); if (nsSymbol) { openresourcemap = NSAddressOfSymbol(nsSymbol); } } #endif } initialized = TRUE; } if (openresourcemap) { short refNum; refNum = openresourcemap(bundleRef); } } libURL = CFBundleCopyResourceURL(bundleRef, CFSTR("Scripts"), NULL, NULL); if (libURL) { /* * FIXME: This is a quick fix, it is probably not right for * internationalization. */ CFURLGetFileSystemRepresentation(libURL, TRUE, (unsigned char*) libraryPath, maxPathLen); CFRelease(libURL); } if (versionedBundleRef) { CFRelease(versionedBundleRef); } } if (libraryPath[0]) { return TCL_OK; } else { return TCL_ERROR; } #else /* HAVE_COREFOUNDATION */ return TCL_ERROR; #endif /* HAVE_COREFOUNDATION */ }
URL_TYPE createURLByMakingDirectoryAtURLWithName(URL_TYPE parent, STRING_TYPE name) { CFURLRef newDirectory = NULL; CFAllocatorRef allocator = parent ? CFGetAllocator(parent) : name ? CFGetAllocator(name) : kCFAllocatorDefault; if (parent) parent = CFRetain(parent); else { char *cwdBytes = alloca(PATH_MAX); getcwd(cwdBytes, PATH_MAX); parent = CFURLCreateFromFileSystemRepresentation(allocator, (const unsigned char *)cwdBytes, strlen(cwdBytes), /*isDirectory*/ true); if (!name) { newDirectory = parent; goto end; } } if (!parent) NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: parent directory URL is NULL (please tell the Growl developers)\n"), parent); else { if (name) name = CFRetain(name); else { name = CFURLCopyLastPathComponent(parent); CFURLRef newParent = CFURLCreateCopyDeletingLastPathComponent(allocator, parent); CFRelease(parent); parent = newParent; } if (!name) NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: name of directory to create is NULL (please tell the Growl developers)\n"), parent); else { FSRef parentRef; if (!CFURLGetFSRef(parent, &parentRef)) NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: could not create FSRef for parent directory at %@ (please tell the Growl developers)\n"), parent); else { FSRef newDirectoryRef; struct HFSUniStr255 nameUnicode; CFRange range = { 0, MIN(CFStringGetLength(name), USHRT_MAX) }; CFStringGetCharacters(name, range, nameUnicode.unicode); nameUnicode.length = range.length; struct FSRefParam refPB = { .ref = &parentRef, .nameLength = nameUnicode.length, .name = nameUnicode.unicode, .whichInfo = kFSCatInfoNone, .catInfo = NULL, .textEncodingHint = kTextEncodingUnknown, .newRef = &newDirectoryRef, }; OSStatus err = PBCreateDirectoryUnicodeSync(&refPB); if (err == dupFNErr) { //dupFNErr == file (or folder) exists already. this is fine. err = PBMakeFSRefUnicodeSync(&refPB); } if (err == noErr) { NSLog(CFSTR("PBCreateDirectoryUnicodeSync or PBMakeFSRefUnicodeSync returned %li; calling CFURLCreateFromFSRef"), (long)err); //XXX newDirectory = CFURLCreateFromFSRef(allocator, &newDirectoryRef); NSLog(CFSTR("CFURLCreateFromFSRef returned %@"), newDirectory); //XXX } else NSLog(CFSTR("in createURLByMakingDirectoryAtURLWithName in CFGrowlAdditions: could not create directory '%@' in parent directory at %@: FSCreateDirectoryUnicode returned %li (please tell the Growl developers)"), name, parent, (long)err); } CFRelease(parent); } //if (name) CFRelease(name); } //if (parent) end: return newDirectory; } #ifndef COPYFORK_BUFSIZE # define COPYFORK_BUFSIZE 5242880U /*5 MiB*/ #endif static OSStatus copyFork(const struct HFSUniStr255 *forkName, const FSRef *srcFile, const FSRef *destDir, const struct HFSUniStr255 *destName, FSRef *outDestFile) { OSStatus err, closeErr; struct FSForkIOParam srcPB = { .ref = srcFile, .forkNameLength = forkName->length, .forkName = forkName->unicode, .permissions = fsRdPerm, }; unsigned char debuggingPathBuf[PATH_MAX] = ""; OSStatus debuggingPathErr; err = PBOpenForkSync(&srcPB); if (err != noErr) { debuggingPathErr = FSRefMakePath(srcFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBOpenForkSync (source: %s) returned %li"), debuggingPathBuf, (long)err); } else { FSRef destFile; /*the first thing to do is get the name of the destination file, if one * wasn't provided. *and while we're at it, we get the catalogue info as well. */ struct FSCatalogInfo catInfo; struct FSRefParam refPB = { .ref = srcFile, .whichInfo = kFSCatInfoGettableInfo & kFSCatInfoSettableInfo, .catInfo = &catInfo, .spec = NULL, .parentRef = NULL, .outName = destName ? NULL : (struct HFSUniStr255 *)(destName = alloca(sizeof(struct HFSUniStr255))), }; err = PBGetCatalogInfoSync(&refPB); if (err != noErr) { debuggingPathErr = FSRefMakePath(srcFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBGetCatalogInfoSync (source: %s) returned %li"), debuggingPathBuf, (long)err); } else { refPB.ref = destDir; refPB.nameLength = destName->length; refPB.name = destName->unicode; refPB.textEncodingHint = kTextEncodingUnknown; refPB.newRef = &destFile; const char *functionName = "PBMakeFSRefUnicodeSync"; //for error-reporting message err = PBMakeFSRefUnicodeSync(&refPB); if ((err != noErr) && (err != fnfErr)) { handleMakeFSRefError: debuggingPathErr = FSRefMakePath(destDir, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for destination directory: FSRefMakePath returned %li)", (long)debuggingPathErr); //get filename too CFStringRef debuggingFilename = CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, destName->unicode, destName->length, /*contentsDeallocator*/ kCFAllocatorNull); if (!debuggingFilename) debuggingFilename = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, "(could not get filename for destination file: CFStringCreateWithCharactersNoCopy returned NULL)", kCFStringEncodingASCII, /*contentsDeallocator*/ kCFAllocatorNull); NSLog(CFSTR("in copyFork in CFGrowlAdditions: %s (destination: %s/%@) returned %li"), functionName, debuggingPathBuf, debuggingFilename, (long)err); if (debuggingFilename) CFRelease(debuggingFilename); } else { //that file doesn't exist in that folder; create it. err = PBCreateFileUnicodeSync(&refPB); if (err == noErr) { /*make sure the Finder knows about the new file. *FNNotify returns a status code too, but this isn't an * essential step, so we just ignore it. */ FNNotify(destDir, kFNDirectoryModifiedMessage, kNilOptions); } else if (err == dupFNErr) { /*dupFNErr: the file already exists. *we can safely ignore this error. */ err = noErr; } else { functionName = "PBCreateFileUnicodeSync"; goto handleMakeFSRefError; } } } if (err == noErr) { if (outDestFile) memcpy(outDestFile, &destFile, sizeof(destFile)); struct FSForkIOParam destPB = { .ref = &destFile, .forkNameLength = forkName->length, .forkName = forkName->unicode, .permissions = fsWrPerm, }; err = PBOpenForkSync(&destPB); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBOpenForkSync (dest) returned %li"), (long)err); if (err != noErr) { debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for dest file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBOpenForkSync (destination: %s) returned %li"), debuggingPathBuf, (long)err); } else { void *buf = malloc(COPYFORK_BUFSIZE); if (buf) { srcPB.buffer = destPB.buffer = buf; srcPB.requestCount = COPYFORK_BUFSIZE; while (err == noErr) { err = PBReadForkSync(&srcPB); if (err == eofErr) { err = noErr; if (srcPB.actualCount == 0) break; } if (err != noErr) { debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBReadForkSync (source: %s) returned %li"), debuggingPathBuf, (long)err); } else { destPB.requestCount = srcPB.actualCount; err = PBWriteForkSync(&destPB); if (err != noErr) { debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for dest file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBWriteForkSync (destination: %s) returned %li"), debuggingPathBuf, (long)err); } } } free(buf); } closeErr = PBCloseForkSync(&destPB); if (closeErr != noErr) { debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for dest file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBCloseForkSync (destination: %s) returned %li"), debuggingPathBuf, (long)err); } if (err == noErr) err = closeErr; } } closeErr = PBCloseForkSync(&srcPB); if (closeErr != noErr) { debuggingPathErr = FSRefMakePath(&destFile, debuggingPathBuf, PATH_MAX); if (debuggingPathErr != noErr) snprintf((char *)debuggingPathBuf, PATH_MAX, "(could not get path for source file: FSRefMakePath returned %li)", (long)debuggingPathErr); NSLog(CFSTR("in copyFork in CFGrowlAdditions: PBCloseForkSync (source: %s) returned %li"), debuggingPathBuf, (long)err); } if (err == noErr) err = closeErr; } return err; } static OSStatus GrowlCopyObjectSync(const FSRef *fileRef, const FSRef *destRef, FSRef *destFileRef) { OSStatus err; struct HFSUniStr255 forkName; struct FSForkIOParam forkPB = { .ref = fileRef, .forkIterator = { .initialize = 0L }, .outForkName = &forkName, }; do { err = PBIterateForksSync(&forkPB); NSLog(CFSTR("PBIterateForksSync returned %li"), (long)err); if (err != noErr) { if (err != errFSNoMoreItems) NSLog(CFSTR("in GrowlCopyObjectSync in CFGrowlAdditions: PBIterateForksSync returned %li"), (long)err); } else { err = copyFork(&forkName, fileRef, destRef, /*destName*/ NULL, /*outDestFile*/ destFileRef); //copyFork prints its own error messages } } while (err == noErr); if (err == errFSNoMoreItems) err = noErr; return err; } CFURLRef createURLByCopyingFileFromURLToDirectoryURL(CFURLRef file, CFURLRef dest) { CFURLRef destFileURL = NULL; FSRef fileRef, destRef, destFileRef; Boolean gotFileRef = CFURLGetFSRef(file, &fileRef); Boolean gotDestRef = CFURLGetFSRef(dest, &destRef); if (!gotFileRef) NSLog(CFSTR("in createURLByCopyingFileFromURLToDirectoryURL in CFGrowlAdditions: CFURLGetFSRef failed with source URL %@"), file); else if (!gotDestRef) NSLog(CFSTR("in createURLByCopyingFileFromURLToDirectoryURL in CFGrowlAdditions: CFURLGetFSRef failed with destination URL %@"), dest); else { OSStatus err; /* * 10.2 has a problem with weak symbols in frameworks so we use * MAC_OS_X_VERSION_MIN_REQUIRED >= 10.3. */ #if defined(NSAppKitVersionNumber10_3) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3 if (FSCopyObjectSync) { err = FSCopyObjectSync(&fileRef, &destRef, /*destName*/ NULL, &destFileRef, kFSFileOperationOverwrite); } else { #endif err = GrowlCopyObjectSync(&fileRef, &destRef, &destFileRef); #if defined(NSAppKitVersionNumber10_3) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 && MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3 } #endif if (err == noErr) destFileURL = CFURLCreateFromFSRef(kCFAllocatorDefault, &destFileRef); else NSLog(CFSTR("in createURLByCopyingFileFromURLToDirectoryURL in CFGrowlAdditions: CopyObjectSync returned %li for source URL %@"), (long)err, file); } return destFileURL; }
Boolean MultiCartDialog (void) { OSStatus err; IBNibRef nibRef; multiCartDragHilite = -1; multiCartDialogResult = false; err = CreateNibReference(kMacS9XCFString, &nibRef); if (err == noErr) { WindowRef window; err = CreateWindowFromNib(nibRef, CFSTR("MultiCart"), &window); if (err == noErr) { static int index[2] = { 0, 1 }; EventHandlerRef wRef, cRef[2]; EventHandlerUPP wUPP, cUPP[2]; EventTypeSpec wEvent[] = { { kEventClassCommand, kEventCommandProcess }, { kEventClassCommand, kEventCommandUpdateStatus } }, cEvent[] = { { kEventClassControl, kEventControlDraw }, { kEventClassControl, kEventControlDragEnter }, { kEventClassControl, kEventControlDragWithin }, { kEventClassControl, kEventControlDragLeave }, { kEventClassControl, kEventControlDragReceive } }; HIViewRef ctl, root, pane[2]; HIViewID cid; root = HIViewGetRoot(window); wUPP = NewEventHandlerUPP(MultiCartEventHandler); err = InstallWindowEventHandler(window, wUPP, GetEventTypeCount(wEvent), wEvent, (void *) window, &wRef); err = SetAutomaticControlDragTrackingEnabledForWindow(window, true); for (int i = 0; i < 2; i++) { cid.id = i; cid.signature = 'MPan'; HIViewFindByID(root, cid, &pane[i]); cUPP[i] = NewEventHandlerUPP(MultiCartPaneEventHandler); err = InstallControlEventHandler(pane[i], cUPP[i], GetEventTypeCount(cEvent), cEvent, (void *) &index[i], &cRef[i]); err = SetControlDragTrackingEnabled(pane[i], true); cid.signature = 'MNAM'; HIViewFindByID(root, cid, &ctl); SetStaticTextTrunc(ctl, truncEnd, false); if (multiCartPath[i]) { CFStringRef str; CFURLRef url; url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, multiCartPath[i], kCFURLPOSIXPathStyle, false); str = CFURLCopyLastPathComponent(url); SetStaticTextCFString(ctl, str, false); CFRelease(str); CFRelease(url); } else SetStaticTextCFString(ctl, CFSTR(""), false); } MoveWindowPosition(window, kWindowMultiCart, false); ShowWindow(window); err = RunAppModalLoopForWindow(window); HideWindow(window); SaveWindowPosition(window, kWindowMultiCart); for (int i = 0; i < 2; i++) { err = RemoveEventHandler(cRef[i]); DisposeEventHandlerUPP(cUPP[i]); } err = RemoveEventHandler(wRef); DisposeEventHandlerUPP(wUPP); CFRelease(window); } DisposeNibReference(nibRef); } return (multiCartDialogResult); }
static int do_keychain_import( SecKeychainRef kcRef, CFDataRef inData, SecExternalFormat externFormat, SecExternalItemType itemType, SecAccessRef access, Boolean nonExtractable, const char *passphrase, const char *fileName, char **attrNames, char **attrValues, unsigned numExtendedAttributes) { SecKeyImportExportParameters keyParams; OSStatus ortn; CFStringRef fileStr; CFArrayRef outArray = NULL; int result = 0; int numCerts = 0; int numKeys = 0; int numIdentities = 0; int tryCount = 0; CFIndex dex; CFIndex numItems = 0; CFStringRef passStr = NULL; CFStringRef promptStr = NULL; CFStringRef retryStr = NULL; /* * Specify some kind of passphrase in case caller doesn't know this * is a wrapped object */ memset(&keyParams, 0, sizeof(SecKeyImportExportParameters)); keyParams.version = SEC_KEY_IMPORT_EXPORT_PARAMS_VERSION; if(passphrase != NULL) { passStr = CFStringCreateWithCString(NULL, passphrase, kCFStringEncodingASCII); keyParams.passphrase = passStr; } else { keyParams.flags = kSecKeySecurePassphrase; } if(nonExtractable) { // explicitly set the key attributes, omitting the CSSM_KEYATTR_EXTRACTABLE bit keyParams.keyAttributes = CSSM_KEYATTR_PERMANENT | CSSM_KEYATTR_SENSITIVE; } keyParams.accessRef = access; fileStr = CFStringCreateWithCString(NULL, fileName, kCFStringEncodingUTF8); if (fileStr) { CFURLRef fileURL = CFURLCreateWithFileSystemPath(NULL, fileStr, kCFURLPOSIXPathStyle, FALSE); if (fileURL) { CFStringRef nameStr = CFURLCopyLastPathComponent(fileURL); if (nameStr) { safe_CFRelease(&fileStr); fileStr = nameStr; } safe_CFRelease(&fileURL); } } promptStr = CFStringCreateWithFormat(NULL, NULL, KC_IMPORT_KEY_PASSWORD_MESSAGE, fileStr); retryStr = CFStringCreateWithFormat(NULL, NULL, KC_IMPORT_KEY_PASSWORD_RETRYMESSAGE, fileStr); while (TRUE) { keyParams.alertPrompt = (tryCount == 0) ? promptStr : retryStr; ortn = SecKeychainItemImport(inData, fileStr, &externFormat, &itemType, 0, /* flags not used (yet) */ &keyParams, kcRef, &outArray); if(ortn) { if (ortn == errSecPkcs12VerifyFailure && ++tryCount < 3) { continue; } sec_perror("SecKeychainItemImport", ortn); result = 1; goto cleanup; } break; } /* * Parse returned items & report to user */ if(outArray == NULL) { sec_error("No keychain items found"); result = 1; goto cleanup; } numItems = CFArrayGetCount(outArray); for(dex=0; dex<numItems; dex++) { CFTypeRef item = CFArrayGetValueAtIndex(outArray, dex); CFTypeID itemType = CFGetTypeID(item); if(itemType == SecIdentityGetTypeID()) { numIdentities++; } else if(itemType == SecCertificateGetTypeID()) { numCerts++; } else if(itemType == SecKeyGetTypeID()) { numKeys++; } else { sec_error("Unexpected item type returned from SecKeychainItemImport"); result = 1; goto cleanup; } } if(numIdentities) { char *str; if(numIdentities > 1) { str = "identities"; } else { str = "identity"; } fprintf(stdout, "%d %s imported.\n", numIdentities, str); } if(numKeys) { char *str; if(numKeys > 1) { str = "keys"; } else { str = "key"; } fprintf(stdout, "%d %s imported.\n", numKeys, str); } if(numCerts) { char *str; if(numCerts > 1) { str = "certificates"; } else { str = "certificate"; } fprintf(stdout, "%d %s imported.\n", numCerts, str); } /* optionally apply extended attributes */ if(numExtendedAttributes) { unsigned attrDex; for(attrDex=0; attrDex<numExtendedAttributes; attrDex++) { CFStringRef attrNameStr = CFStringCreateWithCString(NULL, attrNames[attrDex], kCFStringEncodingASCII); CFDataRef attrValueData = CFDataCreate(NULL, (const UInt8 *)attrValues[attrDex], strlen(attrValues[attrDex])); for(dex=0; dex<numItems; dex++) { SecKeychainItemRef itemRef = (SecKeychainItemRef)CFArrayGetValueAtIndex(outArray, dex); ortn = SecKeychainItemSetExtendedAttribute(itemRef, attrNameStr, attrValueData); if(ortn) { cssmPerror("SecKeychainItemSetExtendedAttribute", ortn); result = 1; break; } } /* for each imported item */ CFRelease(attrNameStr); CFRelease(attrValueData); if(result) { break; } } /* for each extended attribute */ } cleanup: safe_CFRelease(&fileStr); safe_CFRelease(&outArray); safe_CFRelease(&passStr); safe_CFRelease(&promptStr); safe_CFRelease(&retryStr); return result; }
static pascal OSStatus MultiCartEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; WindowRef window = (WindowRef) inUserData; static int index = -1; switch (GetEventClass(inEvent)) { case kEventClassCommand: { switch (GetEventKind(inEvent)) { HICommand tHICommand; case kEventCommandUpdateStatus: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr && tHICommand.commandID == 'clos') { UpdateMenuCommandStatus(false); result = noErr; } break; } case kEventCommandProcess: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &tHICommand); if (err == noErr) { HIViewRef ctl, root; HIViewID cid; FSRef ref; bool8 r; root = HIViewGetRoot(window); switch (tHICommand.commandID) { case 'Cho0': case 'Cho1': { index = (tHICommand.commandID & 0xFF) - '0'; r = NavBeginOpenROMImageSheet(window, NULL); result = noErr; break; } case 'NvDn': { r = NavEndOpenROMImageSheet(&ref); if (r) { CFStringRef str; CFURLRef url; url = CFURLCreateFromFSRef(kCFAllocatorDefault, &ref); str = CFURLCopyLastPathComponent(url); cid.signature = 'MNAM'; cid.id = index; HIViewFindByID(root, cid, &ctl); SetStaticTextCFString(ctl, str, true); CFRelease(str); str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); if (multiCartPath[index]) CFRelease(multiCartPath[index]); multiCartPath[index] = str; CFRelease(url); } index = -1; result = noErr; break; } case 'Cle0': case 'Cle1': { index = (tHICommand.commandID & 0xFF) - '0'; cid.signature = 'MNAM'; cid.id = index; HIViewFindByID(root, cid, &ctl); SetStaticTextCFString(ctl, CFSTR(""), true); if (multiCartPath[index]) { CFRelease(multiCartPath[index]); multiCartPath[index] = NULL; } index = -1; result = noErr; break; } case 'SWAP': { CFStringRef str; CFURLRef url; str = multiCartPath[0]; multiCartPath[0] = multiCartPath[1]; multiCartPath[1] = str; cid.signature = 'MNAM'; for (int i = 0; i < 2; i++) { cid.id = i; HIViewFindByID(root, cid, &ctl); if (multiCartPath[i]) { url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, multiCartPath[i], kCFURLPOSIXPathStyle, false); str = CFURLCopyLastPathComponent(url); SetStaticTextCFString(ctl, str, true); CFRelease(str); CFRelease(url); } else SetStaticTextCFString(ctl, CFSTR(""), true); } result = noErr; break; } case 'ok ': { QuitAppModalLoopForWindow(window); multiCartDialogResult = true; result = noErr; break; } case 'not!': { QuitAppModalLoopForWindow(window); multiCartDialogResult = false; result = noErr; break; } } } } } } } return (result); }