/*
* Test to see if we have the same url string
*/
int isUrlStringEqual(CFURLRef url1, CFURLRef url2)
{
if ((url1 == NULL) || (url2 == NULL)) {
return FALSE; /* Never match null URLs */
}
if (CFStringCompare(CFURLGetString(url1), CFURLGetString(url1),
kCFCompareCaseInsensitive) == kCFCompareEqualTo) {
return TRUE;
}
return FALSE;
}
//-----------------------------------------------------------------------------
// InitializeCustomToolbarItem
//-----------------------------------------------------------------------------
// This is called after our item has been constructed. We are called here so
// that we can pull parameters out of the Carbon Event that is passed into the
// HIObjectCreate call.
//
static OSStatus
InitializeCustomToolbarItem( CustomToolbarItem* inItem, EventRef inEvent )
{
CFTypeRef data;
IconRef iconRef;
if ( GetEventParameter( inEvent, kEventParamToolbarItemConfigData, typeCFTypeRef, NULL,
sizeof( CFTypeRef ), NULL, &data ) == noErr )
{
if ( CFGetTypeID( data ) == CFStringGetTypeID() )
inItem->url = CFURLCreateWithString( NULL, (CFStringRef)data, NULL );
else
inItem->url = (CFURLRef)CFRetain( data );
}
else
{
inItem->url = CFURLCreateWithString( NULL, CFSTR( "http://www.apple.com" ), NULL );
}
HIToolbarItemSetLabel( inItem->toolbarItem, CFSTR( "URL Item" ) );
if ( GetIconRef( kOnSystemDisk, kSystemIconsCreator, kGenericURLIcon, &iconRef ) == noErr )
{
HIToolbarItemSetIconRef( inItem->toolbarItem, iconRef );
ReleaseIconRef( iconRef );
}
HIToolbarItemSetHelpText( inItem->toolbarItem, CFURLGetString( inItem->url ), NULL );
return noErr;
}
OSStatus GeneratePreviewForURL(void *thisInterface, QLPreviewRequestRef preview, CFURLRef url, CFStringRef contentTypeUTI, CFDictionaryRef options)
{
state = initState(1);
//printf("displaying %d structures \n", state->noOfStructs);
CFStringRef filepath = CFURLGetString(url);
state->coords[0] = pdb_read(CFStringGetCStringPtr(filepath, 0), "1xxx", '_');
//glutInit(&argc, argv);
//glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH | GLUT_MULTISAMPLE);
//glutInitWindowSize (kWindowWidth, kWindowHeight);
//glutInitWindowPosition (100, 100);
//glutCreateWindow ("WURST-o-Visison");
InitGL();
//setShader();
glutDisplayFunc(callback_display);
glutReshapeFunc(ReSizeGLScene);
glutMouseFunc(mouse);
glutKeyboardFunc(keyboard);
glutMotionFunc(motion);
// glutMouseFunc(callback_mouse);
// glutMotionFunc(callback_motion);
//glutIdleFunc(DrawGLScene);
glutMainLoop();
return noErr;
}
static void appendExternalID(CFMutableStringRef str, CFXMLExternalID *extID) {
if (extID->publicID) {
CFStringAppendCString(str, " PUBLIC ", kCFStringEncodingASCII);
appendQuotedString(str, extID->publicID);
if (extID->systemID) {
// Technically, for externalIDs, systemID must not be NULL. However, by testing for a NULL systemID, we can use this to emit publicIDs, too. REW, 2/15/2000
CFStringAppendCString(str, " ", kCFStringEncodingASCII);
appendQuotedString(str, CFURLGetString(extID->systemID));
}
} else if (extID->systemID) {
CFStringAppendCString(str, " SYSTEM ", kCFStringEncodingASCII);
appendQuotedString(str, CFURLGetString(extID->systemID));
} else {
// Should never get here
}
}
/* do a [NSString stringByDeletingPathExtension] equivalent */
CFStringRef impExpImportDeleteExtension(
CFStringRef fileStr)
{
CFDataRef fileStrData = CFStringCreateExternalRepresentation(NULL, fileStr,
kCFStringEncodingUTF8, 0);
if(fileStrData == NULL) {
return NULL;
}
CFURLRef urlRef = CFURLCreateFromFileSystemRepresentation(NULL,
CFDataGetBytePtr(fileStrData), CFDataGetLength(fileStrData), false);
if(urlRef == NULL) {
CFRelease(fileStrData);
return NULL;
}
CFURLRef rtnUrl = CFURLCreateCopyDeletingPathExtension(NULL, urlRef);
CFStringRef rtnStr = NULL;
CFRelease(urlRef);
if(rtnUrl) {
rtnStr = CFURLGetString(rtnUrl);
CFRetain(rtnStr);
CFRelease(rtnUrl);
}
CFRelease(fileStrData);
return rtnStr;
}
std::ostream& operator<<(std::ostream& out, CFURLRef u)
{
if(nullptr == u) {
out << "(null)";
return out;
}
CFStringRef s = CFURLGetString(u);
#if !TARGET_OS_IPHONE
if(CFStringHasPrefix(s, CFSTR("file:"))) {
CFStringRef displayName = nullptr;
OSStatus result = LSCopyDisplayNameForURL(u, &displayName);
if(noErr == result && nullptr != displayName) {
out << displayName;
CFRelease(displayName);
displayName = nullptr;
}
}
else
#endif
out << s;
return out;
}
JSValue *UserObjectImp::toPrimitive(ExecState *exec, JSType preferredType) const
{
JSValue *result = jsUndefined();
JSUserObject* jsObjPtr = KJSValueToJSObject(toObject(exec), exec);
CFTypeRef cfValue = jsObjPtr ? jsObjPtr->CopyCFValue() : 0;
if (cfValue) {
CFTypeID cfType = CFGetTypeID(cfValue); // toPrimitive
if (cfValue == GetCFNull()) {
result = jsNull();
}
else if (cfType == CFBooleanGetTypeID()) {
if (cfValue == kCFBooleanTrue) {
result = jsBoolean(true);
} else {
result = jsBoolean(false);
}
} else if (cfType == CFStringGetTypeID()) {
result = jsString(CFStringToUString((CFStringRef)cfValue));
} else if (cfType == CFNumberGetTypeID()) {
double d = 0.0;
CFNumberGetValue((CFNumberRef)cfValue, kCFNumberDoubleType, &d);
result = jsNumber(d);
} else if (cfType == CFURLGetTypeID()) {
CFURLRef absURL = CFURLCopyAbsoluteURL((CFURLRef)cfValue);
if (absURL) {
result = jsString(CFStringToUString(CFURLGetString(absURL)));
ReleaseCFType(absURL);
}
}
ReleaseCFType(cfValue);
}
if (jsObjPtr)
jsObjPtr->Release();
return result;
}
String WebInspectorProxy::inspectorPageURL() const
{
RetainPtr<CFURLRef> htmlURLRef(AdoptCF, CFBundleCopyResourceURL(CFBundleGetBundleWithIdentifier(CFSTR("com.apple.WebKit")), CFSTR("inspector"), CFSTR("html"), CFSTR("inspector")));
if (!htmlURLRef)
return String();
return String(CFURLGetString(htmlURLRef.get()));
}
String WebInspectorProxy::inspectorPageURL() const
{
RetainPtr<CFURLRef> htmlURLRef(AdoptCF, CFBundleCopyResourceURL(webKitBundle(), CFSTR("inspector"), CFSTR("html"), CFSTR("inspector")));
if (!htmlURLRef)
return String();
return String(CFURLGetString(htmlURLRef.get()));
}
Status parseApplicationAliasData(const std::string& data, std::string& result) {
std::string decoded_data = base64Decode(data);
if (decoded_data.empty()) {
return Status(1, "Failed to base64 decode data");
}
CFDataRef resourceData = CFDataCreate(
nullptr,
static_cast<const UInt8*>(static_cast<const void*>(decoded_data.c_str())),
decoded_data.length());
if (resourceData == nullptr) {
return Status(1, "Failed to allocate resource data");
}
auto alias = (CFDataRef)CFPropertyListCreateWithData(kCFAllocatorDefault,
resourceData,
kCFPropertyListImmutable,
nullptr,
nullptr);
CFRelease(resourceData);
if (alias == nullptr) {
return Status(1, "Failed to allocate alias data");
}
auto bookmark =
CFURLCreateBookmarkDataFromAliasRecord(kCFAllocatorDefault, alias);
CFRelease(alias);
if (bookmark == nullptr) {
return Status(1, "Alias data is not a bookmark");
}
auto url = CFURLCreateByResolvingBookmarkData(
kCFAllocatorDefault, bookmark, 0, nullptr, nullptr, nullptr, nullptr);
CFRelease(bookmark);
if (url == nullptr) {
return Status(1, "Alias data is not a URL bookmark");
}
auto replaced = CFURLCreateStringByReplacingPercentEscapes(
kCFAllocatorDefault, CFURLGetString(url), CFSTR(""));
CFRelease(url);
if (replaced == nullptr) {
return Status(1, "Failed to replace percent escapes.");
}
// Get the URL-formatted path.
result = stringFromCFString(replaced);
CFRelease(replaced);
if (result.empty()) {
return Status(1, "Return result is zero size");
}
if (result.length() > 6 && result.substr(0, 7) == "file://") {
result = result.substr(7);
}
return Status(0, "OK");
}
String WebInspectorProxy::inspectorBaseURL() const
{
// Web Inspector uses localized strings, so it's not contained within inspector directory.
RetainPtr<CFURLRef> htmlURLRef(AdoptCF, CFBundleCopyResourcesDirectoryURL(webKitBundle()));
if (!htmlURLRef)
return String();
return String(CFURLGetString(htmlURLRef.get()));
}
void encode(ArgumentEncoder* encoder, CFURLRef url)
{
CFURLRef baseURL = CFURLGetBaseURL(url);
encoder->encodeBool(baseURL);
if (baseURL)
encode(encoder, baseURL);
encode(encoder, CFURLGetString(url));
}
/* -----------------------------------------------------------------------------
plugin entry point, called by pppd
----------------------------------------------------------------------------- */
int start(CFBundleRef ref)
{
CFStringRef strref;
CFURLRef urlref;
bundle = ref;
CFRetain(bundle);
url = CFBundleCopyBundleURL(bundle);
// hookup our handlers
old_check_options = the_channel->check_options;
the_channel->check_options = serial_check_options;
old_connect = the_channel->connect;
the_channel->connect = serial_connect;
old_process_extra_options = the_channel->process_extra_options;
the_channel->process_extra_options = serial_process_extra_options;
add_notifier(&connect_fail_notify, serial_connect_notifier, 0);
add_notifier(&lcp_lowerdown_notify, serial_lcpdown_notifier, 0);
cancelstrref = CFBundleCopyLocalizedString(bundle, CFSTR("Cancel"), CFSTR("Cancel"), NULL);
if (cancelstrref == 0) return 1;
CFStringGetCString(cancelstrref, (char*)cancelstr, sizeof(cancelstr), kCFStringEncodingUTF8);
icstrref = CFBundleCopyLocalizedString(bundle, CFSTR("Network Connection"), CFSTR("Network Connection"), NULL);
if (icstrref == 0) return 1;
CFStringGetCString(icstrref, (char*)icstr, sizeof(icstr), kCFStringEncodingUTF8);
urlref = CFBundleCopyResourceURL(bundle, CFSTR("NetworkConnect.icns"), NULL, NULL);
if (urlref == 0 || ((strref = CFURLGetString(urlref)) == 0)) {
if (urlref)
CFRelease(urlref);
return 1;
}
CFStringGetCString(strref, (char*)iconstr, sizeof(iconstr), kCFStringEncodingUTF8);
iconstrref = CFStringCreateCopy(NULL, strref);
CFRelease(urlref);
urlref = CFBundleCopyBuiltInPlugInsURL(bundle);
if (urlref == 0 || ((CFURLGetFileSystemRepresentation(urlref, TRUE, pathccl, sizeof(pathccl))) == FALSE)) {
if (urlref)
CFRelease(urlref);
return 1;
}
strlcat((char*)pathccl, SUFFIX_CCLENGINE, sizeof(pathccl));
CFRelease(urlref);
// add the socket specific options
add_options(serial_options);
return 0;
}
const String application_path() {
cf::Url url(CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()));
cf::String url_string(CFStringCreateCopy(NULL, CFURLGetString(url.c_obj())));
char path_buffer[PATH_MAX];
if (!CFURLGetFileSystemRepresentation(
url.c_obj(), true, reinterpret_cast<UInt8*>(path_buffer), PATH_MAX)) {
throw Exception("couldn't get application_path()");
}
return String(utf8::decode(path_buffer));
}
bool Utility::hasLaunchOnStartup(const QString &appName)
{
#if defined(Q_OS_WIN)
QString runPath = QLatin1String(runPathC);
QSettings settings(runPath, QSettings::NativeFormat);
return settings.contains(appName);
#elif defined(Q_OS_MAC)
// this is quite some duplicate code with setLaunchOnStartup, at some point we should fix this FIXME.
bool returnValue = false;
QString filePath = QDir(QCoreApplication::applicationDirPath()+QLatin1String("/../..")).absolutePath();
CFStringRef folderCFStr = CFStringCreateWithCString(0, filePath.toUtf8().data(), kCFStringEncodingUTF8);
CFURLRef urlRef = CFURLCreateWithFileSystemPath (0, folderCFStr, kCFURLPOSIXPathStyle, true);
LSSharedFileListRef loginItems = LSSharedFileListCreate(0, kLSSharedFileListSessionLoginItems, 0);
if (loginItems) {
// We need to iterate over the items and check which one is "ours".
UInt32 seedValue;
CFArrayRef itemsArray = LSSharedFileListCopySnapshot(loginItems, &seedValue);
CFStringRef appUrlRefString = CFURLGetString(urlRef); // no need for release
for (int i = 0; i < CFArrayGetCount(itemsArray); i++) {
LSSharedFileListItemRef item = (LSSharedFileListItemRef)CFArrayGetValueAtIndex(itemsArray, i);
CFURLRef itemUrlRef = NULL;
if (LSSharedFileListItemResolve(item, 0, &itemUrlRef, NULL) == noErr) {
CFStringRef itemUrlString = CFURLGetString(itemUrlRef);
if (CFStringCompare(itemUrlString,appUrlRefString,0) == kCFCompareEqualTo) {
returnValue = true;
}
CFRelease(itemUrlRef);
}
}
CFRelease(itemsArray);
}
CFRelease(loginItems);
CFRelease(folderCFStr);
CFRelease(urlRef);
return returnValue;
#elif defined(Q_OS_UNIX)
QString userAutoStartPath = QDir::homePath()+QLatin1String("/.config/autostart/");
QString desktopFileLocation = userAutoStartPath+appName+QLatin1String(".desktop");
return QFile::exists(desktopFileLocation);
#endif
}
static netfsError
OpenSession9P(CFURLRef url, void *v, CFDictionaryRef opts,
CFDictionaryRef * info)
{
CFMutableDictionaryRef dict;
Context9P *ctx;
int useGuest, e;
TRACE();
ctx = v;
if (ctx == NULL || url == NULL || info == NULL
|| !CFURLCanBeDecomposed(url))
return EINVAL;
DEBUG("url=%s opts=%s", NetFSCFStringtoCString(CFURLGetString(url)),
NetFSCFStringtoCString(CFCopyDescription(opts)));
*info = dict = CreateDict9P();
if (dict == NULL)
return ENOMEM;
useGuest = FALSE;
if (opts != NULL) {
CFBooleanRef boolean =
CFDictionaryGetValue(opts, kNetFSUseGuestKey);
if (boolean != NULL)
useGuest = CFBooleanGetValue(boolean);
}
if (useGuest)
CFDictionarySetValue(dict, kNetFSMountedByGuestKey,
kCFBooleanTrue);
else {
ctx->user = CFURLCopyUserName(url);
ctx->pass = CFURLCopyPassword(url);
if (ctx->user == NULL || ctx->pass == NULL) {
if (ctx->user)
CFRelease(ctx->user);
if (ctx->pass)
CFRelease(ctx->pass);
ctx->user = ctx->pass = NULL;
goto error;
}
DEBUG("user=%s pass=%s", NetFSCFStringtoCString(ctx->user),
NetFSCFStringtoCString(ctx->pass));
CFDictionarySetValue(dict, kNetFSMountedByUserKey, ctx->user);
}
return 0;
error:
e = errno;
*info = NULL;
CFRelease(dict);
return e;
}
OSStatus LSOpenCFURLRef(CFURLRef inURL, CFURLRef *outLaunchedURL)
{
// TODO: use 'xdg-mime query' and 'xdg-mime default' to determine the app?
const char *str = CFStringGetCStringPtr(CFURLGetString(inURL),CFStringGetSystemEncoding());
std::vector<std::string> args;
args.push_back(str);
launchApp(g_scXdgOpenPath,args);
outLaunchedURL = nullptr;
return unimpErr;
}
//-----------------------------------------------------------------------------
// CreateCustomToolbarItemPersistentData
//-----------------------------------------------------------------------------
// This is called when the toolbar is about to write the config for this item
// to preferences. It is your chance to save any extra data with the item. You
// must make sure the data is something that can be saved to XML.
//
static CFTypeRef
CreateCustomToolbarItemPersistentData( CustomToolbarItem* inItem )
{
CFTypeRef result = NULL;
if ( inItem->url )
{
return (CFTypeRef)CFStringCreateCopy( NULL, CFURLGetString( inItem->url ) );
}
return result;
}
static bool urlFromPath(CFStringRef path, String& url)
{
if (!path)
return false;
RetainPtr<CFURLRef> cfURL(AdoptCF, CFURLCreateWithFileSystemPath(0, path, kCFURLWindowsPathStyle, false));
if (!cfURL)
return false;
url = String(CFURLGetString(cfURL.get()));
return true;
}
URL::operator std::string ()
{
CF::String str;
if( this->_cfObject == NULL )
{
return str.GetValue();
}
str = CFURLGetString( this->_cfObject );
return str.GetValue();
}
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;
}
CFStringRef Resources::getResourcesPathFromBundleId() { //@@TODO
char buffer[PATH_MAX];
CFBundleRef bundle = CFBundleGetBundleWithIdentifier(CFSTR("SuperColldierAU") );
if (bundle == NULL) return NULL;
CFURLRef bundleURL = CFBundleCopyBundleURL(bundle);
CFURLGetFileSystemRepresentation(bundleURL, TRUE, (UInt8*)buffer,PATH_MAX);
CFStringRef bundlePath = CFStringCreateWithCString(NULL,buffer, kCFStringEncodingUTF8);
CFURLRef bundleResourcesURL = CFBundleCopyResourcesDirectoryURL(bundle);
CFStringRef resourcesRelativePath = CFURLGetString(bundleResourcesURL);
CFMutableStringRef resourcesPath = CFStringCreateMutable(NULL,0);
CFStringAppend(resourcesPath,bundlePath);
CFStringAppend(resourcesPath,resourcesRelativePath);
return resourcesPath;
}
void ResourceError::platformLazyInit()
{
if (m_dataIsUpToDate)
return;
if (!m_platformError)
return;
CFStringRef domain = CFErrorGetDomain(m_platformError.get());
if (domain == kCFErrorDomainMach || domain == kCFErrorDomainCocoa)
m_domain ="NSCustomErrorDomain";
else if (domain == kCFErrorDomainCFNetwork)
m_domain = "CFURLErrorDomain";
else if (domain == kCFErrorDomainPOSIX)
m_domain = "NSPOSIXErrorDomain";
else if (domain == kCFErrorDomainOSStatus)
m_domain = "NSOSStatusErrorDomain";
else if (domain == kCFErrorDomainWinSock)
m_domain = "kCFErrorDomainWinSock";
else
m_domain = domain;
m_errorCode = CFErrorGetCode(m_platformError.get());
RetainPtr<CFDictionaryRef> userInfo = adoptCF(CFErrorCopyUserInfo(m_platformError.get()));
if (userInfo.get()) {
CFStringRef failingURLString = (CFStringRef) CFDictionaryGetValue(userInfo.get(), failingURLStringKey);
if (failingURLString)
m_failingURL = String(failingURLString);
else {
CFURLRef failingURL = (CFURLRef) CFDictionaryGetValue(userInfo.get(), failingURLKey);
if (failingURL) {
RetainPtr<CFURLRef> absoluteURLRef = adoptCF(CFURLCopyAbsoluteURL(failingURL));
if (absoluteURLRef.get()) {
// FIXME: CFURLGetString returns a normalized URL which is different from what is actually used by CFNetwork.
// We should use CFURLGetBytes instead.
failingURLString = CFURLGetString(absoluteURLRef.get());
m_failingURL = String(failingURLString);
}
}
}
m_localizedDescription = (CFStringRef) CFDictionaryGetValue(userInfo.get(), kCFErrorLocalizedDescriptionKey);
#if PLATFORM(WIN)
m_certificate = wkGetSSLPeerCertificateData(userInfo.get());
#endif
}
m_dataIsUpToDate = true;
}
void extractQuarantineProperty(const std::string &table_key_name,
CFTypeRef property,
const std::string &path,
QueryData &results) {
std::string value;
if (CFGetTypeID(property) == CFStringGetTypeID()) {
value = stringFromCFString((CFStringRef)property);
} else if (CFGetTypeID(property) == CFDateGetTypeID()) {
auto unix_time = CFDateGetAbsoluteTime((CFDateRef)property) +
kCFAbsoluteTimeIntervalSince1970;
value = INTEGER(std::llround(unix_time));
} else if (CFGetTypeID(property) == CFURLGetTypeID()) {
value = stringFromCFString(CFURLGetString((CFURLRef)property));
}
setRow(results, path, table_key_name, value);
}
Notificator::Notificator(const QString &programName, QSystemTrayIcon *trayicon, QWidget *parent):
QObject(parent),
parent(parent),
programName(programName),
mode(None),
trayIcon(trayicon)
#ifdef USE_DBUS
,interface(0)
#endif
{
if(trayicon && trayicon->supportsMessages())
{
mode = QSystemTray;
}
#ifdef USE_DBUS
interface = new QDBusInterface("org.freedesktop.Notifications",
"/org/freedesktop/Notifications", "org.freedesktop.Notifications");
if(interface->isValid())
{
mode = Freedesktop;
}
#endif
#ifdef Q_OS_MAC
printf("notification::begin\n");
// check if users OS has support for NSUserNotification
if( MacNotificationHandler::instance()->hasUserNotificationCenterSupport()) {
printf("notification::has\n");
mode = UserNotificationCenter;
} else {
printf("notification::no\n");
// Check if Growl is installed (based on Qt's tray icon implementation)
CFURLRef cfurl;
OSStatus status = LSGetApplicationForInfo(kLSUnknownType, kLSUnknownCreator, CFSTR("growlTicket"), kLSRolesAll, 0, &cfurl);
if (status != kLSApplicationNotFoundErr) {
CFBundleRef bundle = CFBundleCreate(0, cfurl);
if (CFStringCompare(CFBundleGetIdentifier(bundle), CFSTR("com.Growl.GrowlHelperApp"), kCFCompareCaseInsensitive | kCFCompareBackwards) == kCFCompareEqualTo) {
if (CFStringHasSuffix(CFURLGetString(cfurl), CFSTR("/Growl.app/")))
mode = Growl13;
else
mode = Growl12;
}
CFRelease(cfurl);
CFRelease(bundle);
}
}
#endif
}
/* Create a URI suitable for use in an http GET request, will return NULL if
the length would exceed 255 bytes. */
static CFURLRef createGetURL(CFURLRef responder, CFDataRef request) {
CFURLRef getURL = NULL;
CFMutableDataRef base64Request = NULL;
CFStringRef base64RequestString = NULL;
CFStringRef peRequest = NULL;
CFIndex base64Len;
base64Len = SecBase64Encode(NULL, CFDataGetLength(request), NULL, 0);
/* Don't bother doing all the work below if we know the end result will
exceed 255 bytes (minus one for the '/' separator makes 254). */
if (base64Len + CFURLGetBytes(responder, NULL, 0) > 254)
return NULL;
require(base64Request = CFDataCreateMutable(kCFAllocatorDefault,
base64Len), errOut);
CFDataSetLength(base64Request, base64Len);
SecBase64Encode(CFDataGetBytePtr(request), CFDataGetLength(request),
(char *)CFDataGetMutableBytePtr(base64Request), base64Len);
require(base64RequestString = CFStringCreateWithBytes(kCFAllocatorDefault,
CFDataGetBytePtr(base64Request), base64Len, kCFStringEncodingUTF8,
false), errOut);
require(peRequest = CFURLCreateStringByAddingPercentEscapes(
kCFAllocatorDefault, base64RequestString, NULL, CFSTR("+/="),
kCFStringEncodingUTF8), errOut);
#if 1
CFStringRef urlString = CFURLGetString(responder);
CFStringRef fullURL;
if (CFStringHasSuffix(urlString, CFSTR("/"))) {
fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%@%@"), urlString, peRequest);
} else {
fullURL = CFStringCreateWithFormat(kCFAllocatorDefault, NULL,
CFSTR("%@/%@"), urlString, peRequest);
}
getURL = CFURLCreateWithString(kCFAllocatorDefault, fullURL, NULL);
CFRelease(fullURL);
#else
getURL = CFURLCreateWithString(kCFAllocatorDefault, peRequest, responder);
#endif
errOut:
CFReleaseSafe(base64Request);
CFReleaseSafe(base64RequestString);
CFReleaseSafe(peRequest);
return getURL;
}
void ResourceError::platformLazyInit()
{
if (m_dataIsUpToDate)
return;
if (!m_platformError)
return;
CFStringRef domain = CFErrorGetDomain(m_platformError.get());
if (domain == kCFErrorDomainMach || domain == kCFErrorDomainCocoa)
m_domain ="NSCustomErrorDomain";
else if (domain == kCFErrorDomainCFNetwork)
m_domain = "CFURLErrorDomain";
else if (domain == kCFErrorDomainPOSIX)
m_domain = "NSPOSIXErrorDomain";
else if (domain == kCFErrorDomainOSStatus)
m_domain = "NSOSStatusErrorDomain";
else if (domain == kCFErrorDomainWinSock)
m_domain = "kCFErrorDomainWinSock";
m_errorCode = CFErrorGetCode(m_platformError.get());
RetainPtr<CFDictionaryRef> userInfo(AdoptCF, CFErrorCopyUserInfo(m_platformError.get()));
if (userInfo.get()) {
CFStringRef failingURLString = (CFStringRef) CFDictionaryGetValue(userInfo.get(), failingURLStringKey);
if (failingURLString)
m_failingURL = String(failingURLString);
else {
CFURLRef failingURL = (CFURLRef) CFDictionaryGetValue(userInfo.get(), failingURLKey);
if (failingURL) {
RetainPtr<CFURLRef> absoluteURLRef(AdoptCF, CFURLCopyAbsoluteURL(failingURL));
if (absoluteURLRef.get()) {
failingURLString = CFURLGetString(absoluteURLRef.get());
m_failingURL = String(failingURLString);
}
}
}
m_localizedDescription = (CFStringRef) CFDictionaryGetValue(userInfo.get(), kCFErrorLocalizedDescriptionKey);
#if PLATFORM(WIN)
m_certificate = wkGetSSLPeerCertificateData(userInfo.get());
#endif
}
m_dataIsUpToDate = true;
}
static bool urlFromPath(CFStringRef path, String& url)
{
if (!path)
return false;
RetainPtr<CFURLRef> cfURL(AdoptCF, CFURLCreateWithFileSystemPath(0, path, kCFURLWindowsPathStyle, false));
if (!cfURL)
return false;
url = CFURLGetString(cfURL.get());
// Work around <rdar://problem/6708300>, where CFURLCreateWithFileSystemPath makes URLs with "localhost".
if (url.startsWith("file://localhost/"))
url.remove(7, 9);
return true;
}
void MDSAttrParser::logFileError(
const char *op,
CFURLRef fileUrl,
CFStringRef errStr, // optional if you have it
SInt32 *errNo) // optional if you have it
{
const char *cerrStr = NULL;
CFStringRef urlStr = CFURLGetString(fileUrl);
const char *cUrlStr = CFStringGetCStringPtr(urlStr, kCFStringEncodingUTF8);
if(errStr) {
cerrStr = CFStringGetCStringPtr(errStr, kCFStringEncodingUTF8);
Syslog::alert("MDS: %s: bundle %s url %s: error %s",
op, mPath, cUrlStr, cerrStr);
}
else {
Syslog::alert("MDS: %s: bundle %s url %s: error %d",
op, mPath, cUrlStr, errNo ? *errNo : 0);
}
}
/// Parse a Login Items Plist Alias data for bin path
Status parseAliasData(const std::string& data, std::string& result) {
auto decoded = base64Decode(data);
if (decoded.size() == 0) {
// Base64 encoded data (from plist parsing) failed to decode.
return Status(1, "Failed base64 decode");
}
auto alias = CFDataCreate(
kCFAllocatorDefault, (const UInt8*)decoded.c_str(), decoded.size());
if (alias == nullptr) {
// Failed to create CFData object.
return Status(2, "CFData allocation failed");
}
auto bookmark =
CFURLCreateBookmarkDataFromAliasRecord(kCFAllocatorDefault, alias);
if (bookmark == nullptr) {
CFRelease(alias);
return Status(1, "Alias data is not a bookmark");
}
auto url = CFURLCreateByResolvingBookmarkData(
kCFAllocatorDefault, bookmark, 0, nullptr, nullptr, nullptr, nullptr);
if (url == nullptr) {
CFRelease(alias);
CFRelease(bookmark);
return Status(1, "Alias data is not a URL bookmark");
}
// Get the URL-formatted path.
result = stringFromCFString(CFURLGetString(url));
if (result.substr(0, 7) == "file://") {
result = result.substr(7);
}
CFRelease(alias);
CFRelease(bookmark);
CFRelease(url);
return Status(0, "OK");
}
