SFB::InputSource::unique_ptr SFB::InputSource::CreateForURL(CFURLRef url, int flags, CFErrorRef *error) { if(nullptr == url) return nullptr; // If there is no scheme the URL is invalid SFB::CFString scheme = CFURLCopyScheme(url); if(!scheme) { if(error) *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, EINVAL, nullptr); return nullptr; } if(kCFCompareEqualTo == CFStringCompare(CFSTR("file"), scheme, kCFCompareCaseInsensitive)) { if(InputSource::MemoryMapFiles & flags) return unique_ptr(new MemoryMappedFileInputSource(url)); else if(InputSource::LoadFilesInMemory & flags) return unique_ptr(new InMemoryFileInputSource(url)); else return unique_ptr(new FileInputSource(url)); } else if(kCFCompareEqualTo == CFStringCompare(CFSTR("http"), scheme, kCFCompareCaseInsensitive)) return unique_ptr(new HTTPInputSource(url)); return nullptr; }
CFURLRequestRef ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest(CFURLRequestRef cfRequest, CFURLResponseRef originalRedirectResponse) { // If the protocols of the new request and the current request match, this is not an HSTS redirect and we don't need to synthesize a redirect response. if (!originalRedirectResponse) { RetainPtr<CFStringRef> newScheme = adoptCF(CFURLCopyScheme(CFURLRequestGetURL(cfRequest))); if (CFStringCompare(newScheme.get(), m_originalScheme.get(), kCFCompareCaseInsensitive) == kCFCompareEqualTo) { CFRetain(cfRequest); return cfRequest; } } ASSERT(!isMainThread()); // FIXME: The block implicitly copies protector object, which is wasteful. We should just call ref(), // capture "this" by pointer value, and use a C++ lambda to prevent other unintentional capturing. RefPtr<ResourceHandleCFURLConnectionDelegateWithOperationQueue> protectedThis(this); dispatch_async(dispatch_get_main_queue(), ^{ if (!protectedThis->hasHandle()) { continueWillSendRequest(nullptr); return; } LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest(handle=%p) (%s)", m_handle, m_handle->firstRequest().url().string().utf8().data()); RetainPtr<CFURLResponseRef> redirectResponse = synthesizeRedirectResponseIfNecessary(cfRequest, originalRedirectResponse); ASSERT(redirectResponse); ResourceRequest request = createResourceRequest(cfRequest, redirectResponse.get()); m_handle->willSendRequest(request, redirectResponse.get()); });
void ResourceHandleCFURLConnectionDelegateWithOperationQueue::setupRequest(CFMutableURLRequestRef request) { CFURLRef requestURL = CFURLRequestGetURL(request); if (!requestURL) return; m_originalScheme = adoptCF(CFURLCopyScheme(requestURL)); }
CFURLRequestRef ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest(CFURLRequestRef cfRequest, CFURLResponseRef originalRedirectResponse) { // If the protocols of the new request and the current request match, this is not an HSTS redirect and we don't need to synthesize a redirect response. if (!originalRedirectResponse) { RetainPtr<CFStringRef> newScheme = adoptCF(CFURLCopyScheme(CFURLRequestGetURL(cfRequest))); if (CFStringCompare(newScheme.get(), m_originalScheme.get(), kCFCompareCaseInsensitive) == kCFCompareEqualTo) { CFRetain(cfRequest); return cfRequest; } } RefPtr<ResourceHandleCFURLConnectionDelegateWithOperationQueue> protector(this); dispatch_async(dispatch_get_main_queue(), ^{ if (!protector->hasHandle()) { continueWillSendRequest(nullptr); return; } LOG(Network, "CFNet - ResourceHandleCFURLConnectionDelegateWithOperationQueue::willSendRequest(handle=%p) (%s)", m_handle, m_handle->firstRequest().url().string().utf8().data()); RetainPtr<CFURLResponseRef> redirectResponse = synthesizeRedirectResponseIfNecessary(cfRequest, originalRedirectResponse); ASSERT(redirectResponse); ResourceRequest request = createResourceRequest(cfRequest, redirectResponse.get()); m_handle->willSendRequest(request, redirectResponse.get()); });
static bool SecCAIssuerRequestIssue(SecCAIssuerRequestRef request) { while (request->issuerIX < CFArrayGetCount(request->issuers)) { CFURLRef issuer = CFArrayGetValueAtIndex(request->issuers, request->issuerIX++); CFStringRef scheme = CFURLCopyScheme(issuer); if (scheme) { if (CFEqual(CFSTR("http"), scheme)) { CFHTTPMessageRef msg = CFHTTPMessageCreateRequest(kCFAllocatorDefault, CFSTR("GET"), issuer, kCFHTTPVersion1_1); if (msg) { secdebug("caissuer", "%@", msg); bool done = asynchttp_request(msg, &request->http); CFRelease(msg); if (done == false) { CFRelease(scheme); return done; } } secdebug("caissuer", "failed to get %@", issuer); } else { secdebug("caissuer", "skipping unsupported uri %@", issuer); } CFRelease(scheme); } } /* No more issuers left to try, we're done. */ secdebug("caissuer", "no request issued"); request->callback(request->context, NULL); SecCAIssuerRequestRelease(request); return true; }
InputSource * InputSource::CreateInputSourceForURL(CFURLRef url, int flags, CFErrorRef *error) { if(nullptr == url) return nullptr; InputSource *inputSource = nullptr; CFStringRef scheme = CFURLCopyScheme(url); // If there is no scheme the URL is invalid if(nullptr == scheme) { if(error) *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, EINVAL, nullptr); return nullptr; } if(kCFCompareEqualTo == CFStringCompare(CFSTR("file"), scheme, kCFCompareCaseInsensitive)) { if(InputSourceFlagMemoryMapFiles & flags) inputSource = new MemoryMappedFileInputSource(url); else if(InputSourceFlagLoadFilesInMemory & flags) inputSource = new InMemoryFileInputSource(url); else inputSource = new FileInputSource(url); } else if(kCFCompareEqualTo == CFStringCompare(CFSTR("http"), scheme, kCFCompareCaseInsensitive)) inputSource = new HTTPInputSource(url); CFRelease(scheme), scheme = nullptr; return inputSource; }
void ResourceHandleCFURLConnectionDelegateWithOperationQueue::setupRequest(CFMutableURLRequestRef request) { #if PLATFORM(IOS) CFURLRequestSetShouldStartSynchronously(request, 1); #endif CFURLRef requestURL = CFURLRequestGetURL(request); if (!requestURL) return; m_originalScheme = adoptCF(CFURLCopyScheme(requestURL)); }
SFB::Audio::Metadata::unique_ptr SFB::Audio::Metadata::CreateMetadataForURL(CFURLRef url, CFErrorRef *error) { if(nullptr == url) return nullptr; // If this is a file URL, use the extension-based resolvers SFB::CFString scheme = CFURLCopyScheme(url); // If there is no scheme the URL is invalid if(!scheme) { if(error) *error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainPOSIX, EINVAL, nullptr); return nullptr; } if(kCFCompareEqualTo == CFStringCompare(CFSTR("file"), scheme, kCFCompareCaseInsensitive)) { // Verify the file exists SInt32 errorCode = noErr; SFB::CFBoolean fileExists = (CFBooleanRef)CFURLCreatePropertyFromResource(kCFAllocatorDefault, url, kCFURLFileExists, &errorCode); if(fileExists) { if(CFBooleanGetValue(fileExists)) { SFB::CFString pathExtension = CFURLCopyPathExtension(url); if(pathExtension) { // Some extensions (.oga for example) support multiple audio codecs (Vorbis, FLAC, Speex) for(auto subclassInfo : sRegisteredSubclasses) { if(subclassInfo.mHandlesFilesWithExtension(pathExtension)) { unique_ptr metadata(subclassInfo.mCreateMetadata(url)); if(metadata->ReadMetadata(error)) return metadata; } } } } else { LOGGER_WARNING("org.sbooth.AudioEngine.Metadata", "The requested URL doesn't exist"); if(error) { SFB::CFString description = CFCopyLocalizedString(CFSTR("The file “%@” does not exist."), ""); SFB::CFString failureReason = CFCopyLocalizedString(CFSTR("File not found"), ""); SFB::CFString recoverySuggestion = CFCopyLocalizedString(CFSTR("The file may exist on removable media or may have been deleted."), ""); *error = CreateErrorForURL(Metadata::ErrorDomain, Metadata::InputOutputError, description, url, failureReason, recoverySuggestion); } } } else LOGGER_WARNING("org.sbooth.AudioEngine.Metadata", "CFURLCreatePropertyFromResource failed: " << errorCode); } return nullptr; }
static struct _CFStream *_CFStreamCreateWithFile(CFAllocatorRef alloc, CFURLRef fileURL, Boolean forReading) { _CFFileStreamContext fileContext; CFStringRef scheme = fileURL ? CFURLCopyScheme(fileURL) : NULL; if (!scheme || !CFEqual(scheme, CFSTR("file"))) { if (scheme) CFRelease(scheme); return NULL; } CFRelease(scheme); fileContext.url = fileURL; fileContext.fd = -1; return _CFStreamCreateWithConstantCallbacks(alloc, &fileContext, (struct _CFStreamCallBacks *)(&fileCallBacks), forReading); }
void QuartzBitmap_Output(QuartzDesc_t dev, QuartzBitmapDevice *qbd) { if(qbd->path && qbd->uti) { /* On 10.4+ we can employ the CGImageDestination API to create a variety of different bitmap formats */ #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4 char buf[PATH_MAX+1]; snprintf(buf, PATH_MAX, qbd->path, qbd->page); buf[PATH_MAX] = '\0'; CFStringRef pathString = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8*) buf, strlen(buf), kCFStringEncodingUTF8, FALSE); CFURLRef path; if(CFStringFind(pathString, CFSTR("://"), 0).location != kCFNotFound) { CFStringRef pathEscaped = CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault, pathString, NULL, NULL, kCFStringEncodingUTF8); path = CFURLCreateWithString(kCFAllocatorDefault, pathEscaped, NULL); CFRelease(pathEscaped); } else { path = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8*) buf, strlen(buf), FALSE); } CFRelease(pathString); CFStringRef scheme = CFURLCopyScheme(path); CFStringRef type = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8*) qbd->uti, strlen(qbd->uti), kCFStringEncodingUTF8, FALSE); CGImageRef image = CGBitmapContextCreateImage(qbd->bitmap); if(CFStringCompare(scheme,CFSTR("file"), 0) == 0) { /* file output */ CGImageDestinationRef dest = CGImageDestinationCreateWithURL(path, type, 1, NULL); if(dest) { CGImageDestinationAddImage(dest, image, NULL); CGImageDestinationFinalize(dest); CFRelease(dest); } else error(_("QuartzBitmap_Output - unable to open file '%s'"), buf); } else if(CFStringCompare(scheme, CFSTR("clipboard"), 0) == 0) { /* clipboard output */ CFMutableDataRef data = CFDataCreateMutable(kCFAllocatorDefault, 0); CGImageDestinationRef dest = CGImageDestinationCreateWithData(data, type, 1, NULL); CGImageDestinationAddImage(dest, image, NULL); CGImageDestinationFinalize(dest); CFRelease(dest); PasteboardRef pb = NULL; if(PasteboardCreate(kPasteboardClipboard, &pb) == noErr) { PasteboardClear(pb); PasteboardSynchronize(pb); PasteboardPutItemFlavor(pb, (PasteboardItemID) 1, type, data, 0); } CFRelease(data); } else warning(_("not a supported scheme, no image data written")); CFRelease(scheme); CFRelease(type); CFRelease(path); CFRelease(image); #endif } }
/* * See if this is a cifs or smb scheme * * RETURN VALUES: * 0 - No Scheme, could still be our scheme * 4 - SMB scheme, also the length of smb scheme field. * 5 - CIFS scheme, also the length of cifs scheme field. * -1 - Unknown scheme, should be treated as an error. */ static int SMBSchemeLength(CFURLRef url) { int len = 0; CFStringRef scheme = CFURLCopyScheme (url); if (scheme == NULL) return 0; if ( kCFCompareEqualTo == CFStringCompare (scheme, CFSTR("smb"), kCFCompareCaseInsensitive) ) len = SMB_SCHEME_LEN; /* Length of "smb:" */ else if ( kCFCompareEqualTo == CFStringCompare (scheme, CFSTR("cifs"), kCFCompareCaseInsensitive) ) len = CIFS_SCHEME_LEN; /* Length of "cifs:" */ else len = -1; CFRelease(scheme); return len; }
CFNetDiagnosticRef CFNetDiagnosticCreateWithURL(CFAllocatorRef allocator, CFURLRef url) { CFMutableDictionaryRef retval; SInt32 port = 0; retval = CFDictionaryCreateMutable(allocator, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if(retval != NULL && CFURLCanBeDecomposed(url)) { port = CFURLGetPortNumber(url); _CFNetDiagnosticSetDictionaryKeyIfNotNull(_CFNetDiagnosticNameKey, CFBundleGetValueForInfoDictionaryKey(CFBundleGetMainBundle(), kCFBundleNameKey), retval); _CFNetDiagnosticSetDictionaryKeyIfNotNull(_CFNetDiagnosticBundleKey, CFBundleGetIdentifier( CFBundleGetMainBundle() ), retval); _CFNetDiagnosticSetDictionaryKeyAndReleaseIfNotNull(_CFNetDiagnosticRemoteHostKey, CFURLCopyHostName(url), retval); _CFNetDiagnosticSetDictionaryKeyAndReleaseIfNotNull(_CFNetDiagnosticProtocolKey, CFURLCopyScheme(url), retval); _CFNetDiagnosticSetDictionaryKeyAndReleaseIfNotNull(_CFNetDiagnosticPortKey, CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &port), retval); _CFNetDiagnosticSetDictionaryKeyIfNotNull(_CFNetDiagnosticMethodKey, CFSTR("CFNetDiagnosticCreateWithURL"), retval); } return (CFNetDiagnosticRef)retval; }
CF::String URL::GetScheme( void ) { CF::String str; CFStringRef cfStr; if( this->_cfObject == NULL ) { return str; } cfStr = CFURLCopyScheme( this->_cfObject ); if( cfStr != NULL ) { str = cfStr; CFRelease( cfStr ); } return str; }
bool HTTP_Stream::canHandleUrl(CFURLRef url) { if (!url) { return false; } CFStringRef scheme = CFURLCopyScheme(url); if (scheme) { if (CFStringCompare(scheme, CFSTR("file"), 0) == kCFCompareEqualTo) { CFRelease(scheme); // The only scheme we claim not to handle are local files. return false; } CFRelease(scheme); } return true; }
bool Caching_Stream::canHandleUrl(CFURLRef url) { if (!url) { return false; } CFStringRef scheme = CFURLCopyScheme(url); if (scheme) { if (CFStringCompare(scheme, CFSTR("http"), 0) == kCFCompareEqualTo) { CFRelease(scheme); // Using cache makes only sense for HTTP return true; } CFRelease(scheme); } // Nothing else to server return false; }
static CFArrayRef SecCAIssuerRequestCacheCopyParents(SecCertificateRef cert, CFArrayRef issuers) { CFIndex ix = 0, ex = CFArrayGetCount(issuers); for (;ix < ex; ++ix) { CFURLRef issuer = CFArrayGetValueAtIndex(issuers, ix); CFStringRef scheme = CFURLCopyScheme(issuer); if (scheme) { if (CFEqual(CFSTR("http"), scheme)) { CFArrayRef parents = SecCAIssuerConvertToParents(cert, SecCAIssuerCacheCopyMatching(issuer)); if (parents) { secdebug("caissuer", "cache hit, for %@ no request issued", issuer); CFRelease(scheme); return parents; } } CFRelease(scheme); } } return NULL; }
RetainPtr<CFURLResponseRef> ResourceHandleCFURLConnectionDelegate::synthesizeRedirectResponseIfNecessary(CFURLRequestRef newRequest, CFURLResponseRef cfRedirectResponse) { if (cfRedirectResponse) return cfRedirectResponse; CFURLRef newURL = CFURLRequestGetURL(newRequest); RetainPtr<CFStringRef> newScheme = adoptCF(CFURLCopyScheme(newURL)); // If the protocols of the new request and the current request match, this is not an HSTS redirect and we shouldn't synthesize a redirect response. const ResourceRequest& currentRequest = m_handle->currentRequest(); if (currentRequest.url().protocol() == String(newScheme.get())) return nullptr; RetainPtr<CFURLRef> currentURL = currentRequest.url().createCFURL(); RetainPtr<CFHTTPMessageRef> responseMessage = adoptCF(CFHTTPMessageCreateResponse(0, 302, 0, kCFHTTPVersion1_1)); RetainPtr<CFURLRef> newAbsoluteURL = adoptCF(CFURLCopyAbsoluteURL(newURL)); CFHTTPMessageSetHeaderFieldValue(responseMessage.get(), CFSTR("Location"), CFURLGetString(newAbsoluteURL.get())); CFHTTPMessageSetHeaderFieldValue(responseMessage.get(), CFSTR("Cache-Control"), CFSTR("no-store")); RetainPtr<CFURLResponseRef> newResponse = adoptCF(CFURLResponseCreateWithHTTPResponse(0, currentURL.get(), responseMessage.get(), kCFURLCacheStorageNotAllowed)); return newResponse; }
OSStatus SecureDownloadCopyTicketLocation (CFURLRef url, CFURLRef *ticketLocation) { API_BEGIN Required (ticketLocation); Required (url); // copy the resource specifier CFStringRef resourceSpecifier = CFURLCopyResourceSpecifier (url); if (resourceSpecifier == NULL) { CFError::throwMe (); } // make a new URL from the resource specifier *ticketLocation = CFURLCreateWithString (NULL, resourceSpecifier, NULL); if (*ticketLocation == NULL) { CFError::throwMe (); } // check the scheme to make sure that it isn't a file url CFStringRef scheme = CFURLCopyScheme (*ticketLocation); if (scheme != NULL) { CFComparisonResult equal = CFStringCompare (scheme, CFSTR("file"), kCFCompareCaseInsensitive); CFRelease (scheme); if (equal == kCFCompareEqualTo) { CFRelease (*ticketLocation); *ticketLocation = NULL; MacOSError::throwMe (errSecureDownloadInvalidDownload); } } CFRelease (resourceSpecifier); API_END }
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; }
Boolean IOURLCreateDataAndPropertiesFromResource(CFAllocatorRef alloc, CFURLRef url, CFDataRef *fetchedData, CFDictionaryRef *fetchedProperties, CFArrayRef desiredProperties, SInt32 *errorCode) { CFStringRef scheme = CFURLCopyScheme(url); if (!scheme) { if (errorCode) *errorCode = kIOURLImproperArgumentsError; if (fetchedData) *fetchedData = NULL; if (fetchedProperties) *fetchedProperties = NULL; return FALSE; } else { Boolean result; if (CFStringCompare(scheme, CFSTR("file"), 0) == kCFCompareEqualTo) { result = _IOFileURLCreateDataAndPropertiesFromResource(alloc, url, fetchedData, desiredProperties, fetchedProperties, errorCode); } else { if (fetchedData) *fetchedData = NULL; if (fetchedProperties) *fetchedProperties = NULL; if (errorCode) *errorCode = kIOURLUnknownSchemeError; result = FALSE; } CFRelease(scheme); return result; } }
Boolean IOURLWriteDataAndPropertiesToResource(CFURLRef url, CFDataRef data, CFDictionaryRef propertyDict, SInt32 *errorCode) { CFStringRef scheme = CFURLCopyScheme(url); if (!scheme) { if (errorCode) *errorCode = kIOURLImproperArgumentsError; return FALSE; } else if (CFStringCompare(scheme, CFSTR("file"), 0) == kCFCompareEqualTo) { Boolean success = TRUE; CFRelease(scheme); if (errorCode) *errorCode = 0; if (data) { char cPath[CFMaxPathSize]; if (!CFURLGetFileSystemRepresentation(url, TRUE, cPath, CFMaxPathSize)) { if (errorCode) *errorCode = kIOURLImproperArgumentsError; success = FALSE; } else if (CFURLHasDirectoryPath(url)) { // Create a directory success = !mkdir(cPath, 0777); if (!success && errorCode) *errorCode = kIOURLUnknownError; } else { // Write data SInt32 length = CFDataGetLength(data); const void *bytes = (0 == length) ? (const void *)"" : CFDataGetBytePtr(data); success = _IOWriteBytesToFile(cPath, bytes, length); if (!success && errorCode) *errorCode = kIOURLUnknownError; } } if (propertyDict) { if (!_IOFileURLWritePropertiesToResource(url, propertyDict, errorCode)) success = FALSE; } return success; } else { if (errorCode) *errorCode = kIOURLUnknownSchemeError; return FALSE; } }
CFDictionaryRef createDockDescriptionForURL(CFURLRef url) { if (!url) { NSLog(CFSTR("%@"), CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: Cannot copy Dock description for a NULL URL")); return NULL; } //return NULL for non-file: URLs. CFStringRef scheme = CFURLCopyScheme(url); Boolean isFileURL = (CFStringCompare(scheme, CFSTR("file"), kCFCompareCaseInsensitive) == kCFCompareEqualTo); CFRelease(scheme); if (!isFileURL) return NULL; CFDictionaryRef dict = NULL; CFStringRef path = NULL; CFDataRef aliasData = NULL; FSRef fsref; if (CFURLGetFSRef(url, &fsref)) { AliasHandle alias = NULL; OSStatus err = FSNewAlias(/*fromFile*/ NULL, &fsref, &alias); if (err != noErr) { NSLog(CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: FSNewAlias for %@ returned %li"), url, (long)err); } else { HLock((Handle)alias); err = FSCopyAliasInfo(alias, /*targetName*/ NULL, /*volumeName*/ NULL, (CFStringRef *)&path, /*whichInfo*/ NULL, /*info*/ NULL); if (err != noErr) { NSLog(CFSTR("in copyDockDescriptionForURL in CFGrowlAdditions: FSCopyAliasInfo for %@ returned %li"), url, (long)err); } aliasData = CFDataCreate(kCFAllocatorDefault, (UInt8 *)*alias, GetHandleSize((Handle)alias)); HUnlock((Handle)alias); DisposeHandle((Handle)alias); } } if (!path) { path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); } if (path || aliasData) { CFMutableDictionaryRef temp = CFDictionaryCreateMutable(kCFAllocatorDefault, /*capacity*/ 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (path) { CFDictionarySetValue(temp, _CFURLStringKey, path); CFRelease(path); int pathStyle = kCFURLPOSIXPathStyle; CFNumberRef pathStyleNum = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &pathStyle); CFDictionarySetValue(temp, _CFURLStringTypeKey, pathStyleNum); CFRelease(pathStyleNum); } if (aliasData) { CFDictionarySetValue(temp, _CFURLAliasDataKey, aliasData); CFRelease(aliasData); } dict = temp; } return dict; }
string URL::scheme() const { return mkstr(CFURLCopyScheme(ref)); }
static netfsError ParseURL9P(CFURLRef url, CFDictionaryRef * params) { CFMutableDictionaryRef dict; CFStringRef str; SInt32 port; int e; TRACE(); if (url == NULL || params == NULL || !CFURLCanBeDecomposed(url)) return EINVAL; DEBUG("url=%s", NetFSCFStringtoCString(CFURLGetString(url))); *params = dict = CreateDict9P(); if (dict == NULL) return ENOMEM; /* mandatory */ str = CFURLCopyScheme(url); if (str == NULL) goto error; CFDictionarySetValue(dict, kNetFSSchemeKey, str); CFRelease(str); str = CFURLCopyHostName(url); if (str == NULL) goto error; CFDictionarySetValue(dict, kNetFSHostKey, str); CFRelease(str); /* optional */ port = CFURLGetPortNumber(url); if (port != -1) { str = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%d"), (int)port); if (str == NULL) goto error; CFDictionarySetValue(dict, kNetFSAlternatePortKey, str); CFRelease(str); } str = CFURLCopyUserName(url); if (str != NULL) { CFDictionarySetValue(dict, kNetFSUserNameKey, str); CFRelease(str); } str = CFURLCopyPassword(url); if (str != NULL) { CFDictionarySetValue(dict, kNetFSPasswordKey, str); CFRelease(str); } /* str = CFURLCopyPath(url); if (str != NULL) { CFDictionarySetValue(dict, kNetFSPathKey, str); CFRelease(str); } */ return 0; error: e = errno; *params = NULL; CFRelease(dict); return e; }
// domain should already be locked. static Boolean _writeXMLFile(CFURLRef url, CFMutableDictionaryRef dict, Boolean isWorldReadable, Boolean *tryAgain) { Boolean success = false; CFAllocatorRef alloc = __CFPreferencesAllocator(); *tryAgain = false; if (CFDictionaryGetCount(dict) == 0) { // Destroy the file CFBooleanRef val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, url, kCFURLFileExists, NULL); if (val && CFBooleanGetValue(val)) { success = CFURLDestroyResource(url, NULL); } else { success = true; } if (val) CFRelease(val); } else { CFPropertyListFormat desiredFormat = __CFPreferencesShouldWriteXML() ? kCFPropertyListXMLFormat_v1_0 : kCFPropertyListBinaryFormat_v1_0; CFDataRef data = CFPropertyListCreateData(alloc, dict, desiredFormat, 0, NULL); if (data) { SInt32 mode; #if TARGET_OS_OSX || TARGET_OS_LINUX mode = isWorldReadable ? S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH : S_IRUSR|S_IWUSR; #else mode = 0666; #endif #if TARGET_OS_OSX { // Try quick atomic way first, then fallback to slower ways and error cases CFStringRef scheme = CFURLCopyScheme(url); if (!scheme) { *tryAgain = false; CFRelease(data); return false; } else if (CFStringCompare(scheme, CFSTR("file"), 0) == kCFCompareEqualTo) { SInt32 length = CFDataGetLength(data); const void *bytes = (0 == length) ? (const void *)"" : CFDataGetBytePtr(data); Boolean atomicWriteSuccess = __CFWriteBytesToFileWithAtomicity(url, bytes, length, mode, true); if (atomicWriteSuccess) { CFRelease(scheme); *tryAgain = false; CFRelease(data); return true; } if (!atomicWriteSuccess && thread_errno() == ENOSPC) { CFRelease(scheme); *tryAgain = false; CFRelease(data); return false; } } CFRelease(scheme); } #endif success = CFURLWriteDataAndPropertiesToResource(url, data, URLPropertyDictForPOSIXMode(mode), NULL); URLPropertyDictRelease(); if (success) { CFDataRef readData; if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &readData, NULL, NULL, NULL) || !CFEqual(readData, data)) { success = false; *tryAgain = true; } if (readData) CFRelease(readData); } else { CFBooleanRef val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, url, kCFURLFileExists, NULL); if (!val || !CFBooleanGetValue(val)) { CFURLRef tmpURL = CFURLCreateWithFileSystemPathRelativeToBase(alloc, CFSTR("."), kCFURLPOSIXPathStyle, true, url); // Just "." because url is not a directory URL CFURLRef parentURL = tmpURL ? CFURLCopyAbsoluteURL(tmpURL) : NULL; if (tmpURL) CFRelease(tmpURL); if (val) CFRelease(val); val = (CFBooleanRef) CFURLCreatePropertyFromResource(alloc, parentURL, kCFURLFileExists, NULL); if ((!val || !CFBooleanGetValue(val)) && _createDirectory(parentURL, isWorldReadable)) { // parent directory didn't exist; now it does; try again to write success = CFURLWriteDataAndPropertiesToResource(url, data, URLPropertyDictForPOSIXMode(mode), NULL); URLPropertyDictRelease(); if (success) { CFDataRef rdData; if (!CFURLCreateDataAndPropertiesFromResource(alloc, url, &rdData, NULL, NULL, NULL) || !CFEqual(rdData, data)) { success = false; *tryAgain = true; } if (rdData) CFRelease(rdData); } } if (parentURL) CFRelease(parentURL); } if (val) CFRelease(val); } CFRelease(data); } else { // ??? This should never happen CFLog(__kCFLogAssertion, CFSTR("Could not generate XML data for property list")); success = false; } } return success; }