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;
}
