sqInt dir_Create(char *pathString, sqInt 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
}
Boolean path_exists(CFTypeRef path) {
if (CFGetTypeID(path) == CFStringGetTypeID()) {
CFURLRef url = CFURLCreateWithFileSystemPath(NULL, path, kCFURLPOSIXPathStyle, true);
Boolean result = CFURLResourceIsReachable(url, NULL);
CFRelease(url);
return result;
} else if (CFGetTypeID(path) == CFURLGetTypeID()) {
return CFURLResourceIsReachable(path, NULL);
} else {
return false;
}
}
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;
}
//static
QString QFileSystemEngine::bundleName(const QFileSystemEntry &entry)
{
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, QCFString(entry.filePath()),
kCFURLPOSIXPathStyle, true);
if (QCFType<CFDictionaryRef> dict = CFBundleCopyInfoDictionaryForURL(url)) {
if (CFTypeRef name = (CFTypeRef)CFDictionaryGetValue(dict, kCFBundleNameKey)) {
if (CFGetTypeID(name) == CFStringGetTypeID())
return QCFString::toQString((CFStringRef)name);
}
}
return QString();
}
void decideDestinationWithSuggestedObjectNameCallback(CFURLDownloadRef cfURLDownloadRef, CFStringRef objectName, const void* clientInfo)
{
Download* download = downloadFromClientInfo(clientInfo);
bool allowOverwrite;
String destination = download->decideDestinationWithSuggestedFilename(objectName, allowOverwrite);
if (destination.isNull())
return;
RetainPtr<CFStringRef> cfPath(AdoptCF, CFStringCreateWithCharactersNoCopy(0, reinterpret_cast<const UniChar*>(destination.characters()), destination.length(), kCFAllocatorNull));
RetainPtr<CFURLRef> pathURL(AdoptCF, CFURLCreateWithFileSystemPath(0, cfPath.get(), kCFURLWindowsPathStyle, false));
CFURLDownloadSetDestination(cfURLDownloadRef, pathURL.get(), allowOverwrite);
}
CFDataRef copyIconDataForPath(CFStringRef path) {
CFDataRef data = NULL;
//false is probably safest, and is harmless when the object really is a directory.
CFURLRef URL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path, kCFURLPOSIXPathStyle, /*isDirectory*/ false);
if (URL) {
data = copyIconDataForURL(URL);
CFRelease(URL);
}
return data;
}
wxMetafileRefData::wxMetafileRefData( const wxString& filename )
{
Init();
if ( !filename.empty() )
{
wxCFRef<CFMutableStringRef> cfMutableString(CFStringCreateMutableCopy(NULL, 0, wxCFStringRef(filename)));
CFStringNormalize(cfMutableString,kCFStringNormalizationFormD);
wxCFRef<CFURLRef> url(CFURLCreateWithFileSystemPath(kCFAllocatorDefault, cfMutableString , kCFURLPOSIXPathStyle, false));
m_pdfDoc.reset(CGPDFDocumentCreateWithURL(url));
}
}
void QStorageInfoPrivate::retrieveUrlProperties(bool initRootPath)
{
static const void *rootPathKeys[] = { kCFURLVolumeURLKey };
static const void *propertyKeys[] = {
// kCFURLVolumeNameKey, // 10.7
// kCFURLVolumeLocalizedNameKey, // 10.7
kCFURLVolumeTotalCapacityKey,
kCFURLVolumeAvailableCapacityKey,
// kCFURLVolumeIsReadOnlyKey // 10.7
};
size_t size = (initRootPath ? sizeof(rootPathKeys) : sizeof(propertyKeys)) / sizeof(void*);
QCFType<CFArrayRef> keys = CFArrayCreate(kCFAllocatorDefault,
initRootPath ? rootPathKeys : propertyKeys,
size,
Q_NULLPTR);
if (!keys)
return;
const QCFString cfPath = rootPath;
if (initRootPath)
rootPath.clear();
QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
cfPath,
kCFURLPOSIXPathStyle,
true);
if (!url)
return;
CFErrorRef error;
QCFType<CFDictionaryRef> map = CFURLCopyResourcePropertiesForKeys(url, keys, &error);
if (!map)
return;
if (initRootPath) {
const CFURLRef rootUrl = (CFURLRef)CFDictionaryGetValue(map, kCFURLVolumeURLKey);
if (!rootUrl)
return;
rootPath = QCFString(CFURLCopyFileSystemPath(rootUrl, kCFURLPOSIXPathStyle));
valid = true;
ready = true;
return;
}
bytesTotal = CFDictionaryGetInt64(map, kCFURLVolumeTotalCapacityKey);
bytesAvailable = CFDictionaryGetInt64(map, kCFURLVolumeAvailableCapacityKey);
bytesFree = bytesAvailable;
}
// static
bool Sandbox::createSecurityToken(const QString& canonicalPath,
bool isDirectory) {
if (sDebug) {
qDebug() << "createSecurityToken" << canonicalPath << isDirectory;
}
if (!enabled()) {
return false;
}
QMutexLocker locker(&s_mutex);
if (s_pSandboxPermissions == NULL) {
return false;
}
#ifdef Q_OS_MAC
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
CFURLRef url = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault, QStringToCFString(canonicalPath),
kCFURLPOSIXPathStyle, isDirectory);
if (url) {
CFErrorRef error = NULL;
CFDataRef bookmark = CFURLCreateBookmarkData(
kCFAllocatorDefault, url,
kCFURLBookmarkCreationWithSecurityScope, nil, nil, &error);
CFRelease(url);
if (bookmark) {
QByteArray bookmarkBA = QByteArray(
reinterpret_cast<const char*>(CFDataGetBytePtr(bookmark)),
CFDataGetLength(bookmark));
QString bookmarkBase64 = QString(bookmarkBA.toBase64());
s_pSandboxPermissions->set(keyForCanonicalPath(canonicalPath),
bookmarkBase64);
CFRelease(bookmark);
return true;
} else {
if (sDebug) {
qDebug() << "Failed to create security-scoped bookmark for" << canonicalPath;
if (error != NULL) {
qDebug() << "Error:" << CFStringToQString(CFErrorCopyDescription(error));
}
}
}
} else {
if (sDebug) {
qDebug() << "Failed to create security-scoped bookmark URL for" << canonicalPath;
}
}
#endif
#endif
return false;
}
uint32_t UtilCG::Texture::LoadTexture(const char *const aPath)
{
CFStringRef Path = CFStringCreateWithCString(kCFAllocatorDefault, aPath, kCFStringEncodingASCII);
CFURLRef Url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, Path, kCFURLPOSIXPathStyle, false);
CGImageSourceRef Source = CGImageSourceCreateWithURL(Url, NULL);
CGImageRef pImage = CGImageSourceCreateImageAtIndex(Source, 0, NULL);
if ( !pImage )
{
CFRelease(Url);
CFRelease(Path);
CFRelease(Source);
return INVALID_HANDLE;
}
CGDataProviderRef pDataProvider = CGImageGetDataProvider(pImage);
if ( pDataProvider )
{
size_t width = CGImageGetWidth(pImage);
size_t height = CGImageGetHeight(pImage);
//size_t bytesPerRow = CGImageGetBytesPerRow(pImage);
//size_t bitsPerPixel = CGImageGetBitsPerPixel(pImage);
//size_t bitsPerComponent = CGImageGetBitsPerComponent(pImage);
CFDataRef DataRef = CGDataProviderCopyData(pDataProvider);
const UInt8* pData = CFDataGetBytePtr(DataRef);
uint32_t hTexID = 0;
glGenTextures(1, &hTexID);
glBindTexture(GL_TEXTURE_2D, hTexID);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, (GLint)width, (GLint)height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pData);
glBindTexture(GL_TEXTURE_2D, 0);
CFRelease(Url);
CFRelease(Path);
CFRelease(Source);
CGImageRelease(pImage);
// CGDataProviderRelease(pDataProvider);
return hTexID;
}
CFRelease(Url);
CFRelease(Path);
CFRelease(Source);
CGImageRelease(pImage);
CGDataProviderRelease(pDataProvider);
return INVALID_HANDLE;
}
void* AppleCMIODPSampleNewPlugIn(CFAllocatorRef allocator, CFUUIDRef requestedTypeUUID)
{
if (not CFEqual(requestedTypeUUID, kCMIOHardwarePlugInTypeID))
return 0;
try
{
// Before going any further, make sure the SampleAssistant process is registerred with Mach's bootstrap service. Normally, this would be done by having an appropriately
// configured plist in /Library/LaunchDaemons, but if that is done then the process will be owned by root, thus complicating the debugging process. Therefore, in the event that the
// plist is missing (as would be the case for most debugging efforts) attempt to register the SampleAssistant now. It will fail gracefully if allready registered.
mach_port_t assistantServicePort;
name_t assistantServiceName = "com.apple.cmio.DPA.Sample";
kern_return_t err = bootstrap_look_up(bootstrap_port, assistantServiceName, &assistantServicePort);
if (BOOTSTRAP_SUCCESS != err)
{
// Create an URL to SampleAssistant that resides at "/Library/CoreMediaIO/Plug-Ins/DAL/Sample.plugin/Contents/Resources/SampleAssistant"
CACFURL assistantURL(CFURLCreateWithFileSystemPath(NULL, CFSTR("/Library/CoreMediaIO/Plug-Ins/DAL/Sample.plugin/Contents/Resources/SampleAssistant"), kCFURLPOSIXPathStyle, false));
ThrowIf(not assistantURL.IsValid(), CAException(-1), "AppleCMIODPSampleNewPlugIn: unable to create URL for the SampleAssistant");
// Get the maximum size of the of the file system representation of the SampleAssistant's absolute path
CFIndex length = CFStringGetMaximumSizeOfFileSystemRepresentation(CACFString(CFURLCopyFileSystemPath(CACFURL(CFURLCopyAbsoluteURL(assistantURL.GetCFObject())).GetCFObject(), kCFURLPOSIXPathStyle)).GetCFString());
// Get the file system representation
CAAutoFree<char> path(length);
(void) CFURLGetFileSystemRepresentation(assistantURL.GetCFObject(), true, reinterpret_cast<UInt8*>(path.get()), length);
mach_port_t assistantServerPort;
err = bootstrap_create_server(bootstrap_port, path, getuid(), true, &assistantServerPort);
ThrowIf(BOOTSTRAP_SUCCESS != err, CAException(err), "AppleCMIODPSampleNewPlugIn: couldn't create server");
err = bootstrap_check_in(assistantServerPort, assistantServiceName, &assistantServicePort);
// The server port is no longer needed so get rid of it
(void) mach_port_deallocate(mach_task_self(), assistantServerPort);
// Make sure the call to bootstrap_create_service() succeeded
ThrowIf(BOOTSTRAP_SUCCESS != err, CAException(err), "AppleCMIODPSampleNewPlugIn: couldn't create SampleAssistant service port");
}
// The service port is not longer needed so get rid of it
(void) mach_port_deallocate(mach_task_self(), assistantServicePort);
CMIO::DP::Sample::PlugIn* plugIn = new CMIO::DP::Sample::PlugIn(requestedTypeUUID);
plugIn->Retain();
return plugIn->GetInterface();
}
catch (...)
{
return NULL;
}
}
AudioFileReader::AudioFileReader(const char* filePath)
: m_data(0)
, m_dataSize(0)
, m_audioFileID(0)
, m_extAudioFileRef(0)
{
RetainPtr<CFStringRef> filePathString = adoptCF(CFStringCreateWithCString(kCFAllocatorDefault, filePath, kCFStringEncodingUTF8));
RetainPtr<CFURLRef> url = adoptCF(CFURLCreateWithFileSystemPath(kCFAllocatorDefault, filePathString.get(), kCFURLPOSIXPathStyle, false));
if (!url)
return;
ExtAudioFileOpenURL(url.get(), &m_extAudioFileRef);
}
bool QMacPrintEngine::begin(QPaintDevice *dev)
{
Q_D(QMacPrintEngine);
if (d->state == QPrinter::Idle && d->session == 0) // Need to reinitialize
d->initialize();
d->paintEngine->state = state;
d->paintEngine->begin(dev);
Q_ASSERT_X(d->state == QPrinter::Idle, "QMacPrintEngine", "printer already active");
if (PMSessionValidatePrintSettings(d->session, d->settings, kPMDontWantBoolean) != noErr
|| PMSessionValidatePageFormat(d->session, d->format, kPMDontWantBoolean) != noErr) {
d->state = QPrinter::Error;
return false;
}
if (!d->outputFilename.isEmpty()) {
QCFType<CFURLRef> outFile = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault,
QCFString(d->outputFilename),
kCFURLPOSIXPathStyle,
false);
if (PMSessionSetDestination(d->session, d->settings, kPMDestinationFile,
kPMDocumentFormatPDF, outFile) != noErr) {
qWarning("QMacPrintEngine::begin: Problem setting file [%s]", d->outputFilename.toUtf8().constData());
return false;
}
}
OSStatus status = noErr;
#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)
if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
status = d->shouldSuppressStatus() ? PMSessionBeginCGDocumentNoDialog(d->session, d->settings, d->format)
: PMSessionBeginCGDocument(d->session, d->settings, d->format);
} else
#endif
{
#ifndef Q_OS_MAC64
status = d->shouldSuppressStatus() ? PMSessionBeginDocumentNoDialog(d->session, d->settings, d->format)
: PMSessionBeginDocument(d->session, d->settings, d->format);
#endif
}
if (status != noErr) {
d->state = QPrinter::Error;
return false;
}
d->state = QPrinter::Active;
setActive(true);
d->newPage_helper();
return true;
}
bool PluginPackage::load()
{
if (m_isLoaded) {
m_loadCount++;
return true;
}
WTF::RetainPtr<CFStringRef> path(AdoptCF, m_path.createCFString());
WTF::RetainPtr<CFURLRef> url(AdoptCF, CFURLCreateWithFileSystemPath(kCFAllocatorDefault, path.get(),
kCFURLPOSIXPathStyle, false));
m_module = CFBundleCreate(NULL, url.get());
if (!m_module || !CFBundleLoadExecutable(m_module)) {
LOG(Plugins, "%s not loaded", m_path.utf8().data());
return false;
}
m_isLoaded = true;
NP_GetEntryPointsFuncPtr NP_GetEntryPoints = 0;
NP_InitializeFuncPtr NP_Initialize;
NPError npErr;
NP_Initialize = (NP_InitializeFuncPtr)CFBundleGetFunctionPointerForName(m_module, CFSTR("NP_Initialize"));
NP_GetEntryPoints = (NP_GetEntryPointsFuncPtr)CFBundleGetFunctionPointerForName(m_module, CFSTR("NP_GetEntryPoints"));
m_NPP_Shutdown = (NPP_ShutdownProcPtr)CFBundleGetFunctionPointerForName(m_module, CFSTR("NP_Shutdown"));
if (!NP_Initialize || !NP_GetEntryPoints || !m_NPP_Shutdown)
goto abort;
memset(&m_pluginFuncs, 0, sizeof(m_pluginFuncs));
m_pluginFuncs.size = sizeof(m_pluginFuncs);
initializeBrowserFuncs();
npErr = NP_Initialize(&m_browserFuncs);
LOG_NPERROR(npErr);
if (npErr != NPERR_NO_ERROR)
goto abort;
npErr = NP_GetEntryPoints(&m_pluginFuncs);
LOG_NPERROR(npErr);
if (npErr != NPERR_NO_ERROR)
goto abort;
m_loadCount++;
return true;
abort:
unloadWithoutShutdown();
return false;
}
//-----------------------------------------------------------------------------
CFURLEnumeratorRef CreateDirectoryEnumerator(CFStringRef dirPath)
{
CFURLRef dirUrl = NULL;
CFURLEnumeratorRef dirEnum = NULL;
dirUrl = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, dirPath, kCFURLPOSIXPathStyle, true);
if (dirUrl ) {
dirEnum = CFURLEnumeratorCreateForDirectoryURL(kCFAllocatorDefault, dirUrl, kCFURLEnumeratorDefaultBehavior, NULL);
}
if (dirUrl) {
CFRelease(dirUrl);
}
return dirEnum;
}
/*
** Returns a CFBundleRef if the FSSpec refers to a Mac OS X bundle directory.
** The caller is responsible for calling CFRelease() to deallocate.
*/
static CFBundleRef getPluginBundle(const char* path)
{
CFBundleRef bundle = NULL;
CFStringRef pathRef = CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8);
if (pathRef) {
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(NULL, pathRef, kCFURLPOSIXPathStyle, true);
if (bundleURL != NULL) {
bundle = CFBundleCreate(NULL, bundleURL);
CFRelease(bundleURL);
}
CFRelease(pathRef);
}
return bundle;
}
CFURLRef copy_device_app_url(AMDeviceRef device, CFStringRef identifier) {
CFDictionaryRef result;
assert(AMDeviceLookupApplications(device, 0, &result) == 0);
CFDictionaryRef app_dict = CFDictionaryGetValue(result, identifier);
assert(app_dict != NULL);
CFStringRef app_path = CFDictionaryGetValue(app_dict, CFSTR("Path"));
assert(app_path != NULL);
CFURLRef url = CFURLCreateWithFileSystemPath(NULL, app_path, kCFURLPOSIXPathStyle, true);
CFRelease(result);
return url;
}
void Download::didDecideDestination(const String& destination, bool allowOverwrite)
{
ASSERT(!destination.isEmpty());
if (destination.isEmpty())
return;
m_allowOverwrite = allowOverwrite;
m_destination = destination;
m_bundlePath = destination + DownloadBundle::fileExtension();
RetainPtr<CFStringRef> bundlePath(AdoptCF, CFStringCreateWithCharactersNoCopy(0, reinterpret_cast<const UniChar*>(m_bundlePath.characters()), m_bundlePath.length(), kCFAllocatorNull));
RetainPtr<CFURLRef> bundlePathURL(AdoptCF, CFURLCreateWithFileSystemPath(0, bundlePath.get(), kCFURLWindowsPathStyle, false));
CFURLDownloadSetDestination(m_download.get(), bundlePathURL.get(), allowOverwrite);
}
/* PsychInitializePsychHID()
*
* Master init routine - Called at module load time / first time init.
*
*/
void PsychInitializePsychHID(void)
{
int i;
// Initialize the generic USB tracker to "all off" state:
for (i = 0; i < PSYCH_HID_MAX_GENERIC_USB_DEVICES; i++) {
usbDeviceRecordBank[i].valid = 0;
}
// Setup event ringbuffers:
for (i = 0; i < PSYCH_HID_MAX_DEVICES; i++) {
hidEventBuffer[i] = NULL;
hidEventBufferCapacity[i] = 10000; // Initial capacity of event buffer.
hidEventBufferReadPos[i] = 0;
hidEventBufferWritePos[i] = 0;
}
#if PSYCH_SYSTEM == PSYCH_OSX
for (i = 0; i < MAXDEVICEINDEXS; i++) deviceInterfaces[i] = NULL;
// Try to load all bundles from Psychtoolbox/PsychHardware/
// This loads the HID_Utilities.framework bundle if it is present. The whole point of it is
// to allow our statically compiled-in version of the library to find the location of
// the XML file with the database of (vendorId, productId) -> (VendorName, ProductName) and
// (usagePage, usage) -> (usageName) mappings.
//
// In practice, the XML file only serves as a fallback, and one that doesn't contain much
// useful info for mainstream products, only for a few niche products. Given its limited
// value, i think we can refrain from shipping the framework as part of Psychtoolbox and
// just provide the option to use it (== its XML file) if users decide to install it themselves.
char tmpString[1024];
sprintf(tmpString, "%sPsychHardware/", PsychRuntimeGetPsychtoolboxRoot(FALSE));
CFStringRef urlString = CFStringCreateWithCString(kCFAllocatorDefault, tmpString, kCFStringEncodingASCII);
CFURLRef directoryURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, urlString, kCFURLPOSIXPathStyle, false);
CFRelease(urlString);
CFArrayRef bundleArray = CFBundleCreateBundlesFromDirectory(kCFAllocatorDefault, directoryURL, NULL);
CFRelease(directoryURL);
CFRelease(bundleArray);
#endif
// Initialize OS specific interfaces and routines:
PsychHIDInitializeHIDStandardInterfaces();
// This sets up data structures for HID report reception inside PsychHIDReceiveReports.c:
PsychHIDReleaseAllReportMemory();
return;
}
OSCodeFragment::OSCodeFragment(const char* inPath)
: fFragmentP(NULL)
{
#if defined(HPUX) || defined(HPUX10)
shl_t handle;
fFragmentP = shl_load(inPath, BIND_IMMEDIATE|BIND_VERBOSE|BIND_NOSTART, 0L);
#elif defined(OSF1) ||\
(defined(__FreeBSD_version) && (__FreeBSD_version >= 220000))
fFragmentP = dlopen((char *)inPath, RTLD_NOW | RTLD_GLOBAL);
#elif defined(__FreeBSD__)
fFragmentP = dlopen(inPath, RTLD_NOW);
#elif defined(__sgi__)
fFragmentP = dlopen(inPath, RTLD_NOW); // not sure this should be either RTLD_NOW or RTLD_LAZY
#elif defined(__Win32__)
fFragmentP = ::LoadLibrary(inPath);
#elif defined(__MacOSX__)
CFStringRef theString = CFStringCreateWithCString( kCFAllocatorDefault, inPath, kCFStringEncodingASCII);
//
// In MacOSX, our "fragments" are CF bundles, which are really
// directories, so our paths are paths to a directory
CFURLRef bundleURL = CFURLCreateWithFileSystemPath( kCFAllocatorDefault,
theString,
kCFURLPOSIXPathStyle,
true);
//
// I figure CF is safe about having NULL passed
// into its functions (if fBundle failed to get created).
// So, I won't worry about error checking myself
fFragmentP = CFBundleCreate( kCFAllocatorDefault, bundleURL );
Boolean success = false;
if (fFragmentP != NULL)
success = CFBundleLoadExecutable( fFragmentP );
if (!success && fFragmentP != NULL)
{
CFRelease( fFragmentP );
fFragmentP = NULL;
}
CFRelease(bundleURL);
CFRelease(theString);
#else
fFragmentP = dlopen(inPath, RTLD_NOW | RTLD_GLOBAL);
//fprintf (stderr, "%s\n", dlerror());
#endif
}
int
fuse_kext_load(void)
{
int ret = 0;
char *path = NULL;
ret = fuse_kext_get_path(&path);
if (ret) {
return ret;
}
CFStringRef km_path = CFStringCreateWithCString(kCFAllocatorDefault,
path,
kCFStringEncodingUTF8);
CFURLRef km_url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
km_path,
kCFURLPOSIXPathStyle,
true);
ret = KextManagerLoadKextWithURL(km_url, NULL);
if (ret == kOSReturnSuccess) {
ret = 0;
} else if (ret == kOSKextReturnNotFound) {
ret = ENOENT;
} else {
ret = -1;
}
CFRelease(km_path);
CFRelease(km_url);
free(path);
if (ret) {
return ret;
}
/*
* Now do any kext-load-time settings that need to be done as root
*/
struct group *admin_group = getgrnam(MACOSX_ADMIN_GROUP_NAME);
if (admin_group) {
int admin_gid = admin_group->gr_gid;
(void)sysctlbyname(OSXFUSE_SYSCTL_TUNABLES_ADMIN, NULL, NULL,
&admin_gid, sizeof(admin_gid));
}
return ret;
}
static void InitBMDSwitcherAPI_v4_0 (void)
{
CFURLRef bundleURL;
bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR(kBMDSwitcherAPI_BundlePath), kCFURLPOSIXPathStyle, true);
if (bundleURL != NULL)
{
gBundleRef = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (gBundleRef != NULL)
{
gCreateDiscoveryFunc = (CreateDiscoveryFunc)CFBundleGetFunctionPointerForName(gBundleRef, CFSTR("GetBMDSwitcherDiscoveryInstance_0000"));
}
CFRelease(bundleURL);
}
}
void StoreDictionaryInPlist(CFPropertyListRef propListRef, CFStringRef stringPlist, SInt32 *errorCode)
{
CFErrorRef errorRef;
CFURLRef fileURLRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,stringPlist,kCFURLPOSIXPathStyle,false);
CFDataRef dataRef = CFPropertyListCreateData(kCFAllocatorDefault, propListRef, kCFPropertyListXMLFormat_v1_0, 0, &errorRef);
// Write the plist to the file.
Boolean status = CFURLWriteDataAndPropertiesToResource(fileURLRef, dataRef, NULL, errorCode);
if (!status) {
//error
}
CFRelease(fileURLRef);
CFRelease(dataRef);
}
CFDataRef copyIconData(CFStringRef path)
{
CFDataRef data = NULL;
CFURLRef URL = CFURLCreateWithFileSystemPath( kCFAllocatorDefault,
path, // file path name
kCFURLPOSIXPathStyle, // interpret as POSIX path
false ); // is it a directory?
if (URL) {
FSRef ref;
if (CFURLGetFSRef(URL, &ref)) {
IconRef icon = NULL;
SInt16 label_noOneCares;
OSStatus err = GetIconRefFromFileInfo(&ref,
/*inFileNameLength*/ 0U, /*inFileName*/ NULL,
kFSCatInfoNone, /*inCatalogInfo*/ NULL,
kIconServicesNoBadgeFlag | kIconServicesUpdateIfNeededFlag,
&icon,
&label_noOneCares);
if (err != noErr) {
printf("Could not get icon\n");
} else {
IconFamilyHandle fam = NULL;
// err = IconRefToIconFamily(icon, kSelectorAllAvailableData, &fam);
err = ReadIconFromFSRef(&ref, &fam);
if (err != noErr) {
printf("Could not get icon\n");
} else {
HLock((Handle)fam);
data = CFDataCreate(kCFAllocatorDefault, (const UInt8 *)*(Handle)fam, GetHandleSize((Handle)fam));
HUnlock((Handle)fam);
DisposeHandle((Handle)fam);
}
ReleaseIconRef(icon);
}
}
}
CFSafeRelease(URL);
return data;
}
STATIC SecTrustedApplicationRef
create_trusted_app_from_bundle_resource(CFStringRef bundle_path,
CFStringRef resource_path)
{
CFBundleRef bundle;
CFURLRef bundle_url;
CFURLRef eapolclient_url = NULL;
char path[MAXPATHLEN];
Boolean success = FALSE;
SecTrustedApplicationRef trusted_app = NULL;
bundle_url = CFURLCreateWithFileSystemPath(NULL,
bundle_path,
kCFURLPOSIXPathStyle, FALSE);
if (bundle_url == NULL) {
goto done;
}
bundle = CFBundleCreate(NULL, bundle_url);
CFRelease(bundle_url);
if (bundle == NULL) {
goto done;
}
eapolclient_url
= CFBundleCopyResourceURL(bundle, CFSTR(keapolclientPath),
NULL, NULL);
CFRelease(bundle);
if (eapolclient_url == NULL) {
goto done;
}
success = CFURLGetFileSystemRepresentation(eapolclient_url,
TRUE,
(UInt8 *)path, sizeof(path));
CFRelease(eapolclient_url);
if (success) {
OSStatus status;
status = SecTrustedApplicationCreateFromPath(path,
&trusted_app);
if (status != noErr) {
fprintf(stderr,
"SecTrustedApplicationCreateFromPath(%s) failed, %d\n",
path, (int)status);
}
}
done:
return (trusted_app);
}
static CFStringRef _CFCopyLocalizedVersionKey(CFBundleRef *bundlePtr, CFStringRef nonLocalized) {
CFStringRef localized = NULL;
CFBundleRef locBundle = bundlePtr ? *bundlePtr : NULL;
if (!locBundle) {
CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, CFSTR("/System/Library/CoreServices/SystemVersion.bundle"), kCFURLPOSIXPathStyle, false);
if (url) {
locBundle = CFBundleCreate(kCFAllocatorSystemDefault, url);
CFRelease(url);
}
}
if (locBundle) {
localized = CFBundleCopyLocalizedString(locBundle, nonLocalized, nonLocalized, CFSTR("SystemVersion"));
if (bundlePtr) *bundlePtr = locBundle; else CFRelease(locBundle);
}
return localized ? localized : (CFStringRef)CFRetain(nonLocalized);
}
CFDictionaryRef CreateDictionaryFromPlist(CFStringRef stringPlist, SInt32 *errorCode)
{
CFDataRef dataRef;
CFStringRef errorStringRef;
CFURLRef fileURLRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,stringPlist,kCFURLPOSIXPathStyle,false);
Boolean status = CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault,fileURLRef,&dataRef,NULL,NULL,errorCode);
if (!status) {
//error
}
CFDictionaryRef dictRef = CFPropertyListCreateFromXMLData(kCFAllocatorDefault,dataRef,
kCFPropertyListMutableContainersAndLeaves,&errorStringRef);
CFRelease(fileURLRef);
CFRelease(dataRef);
return dictRef;
}
static CFURLRef _preferencesDirectoryForUserHostSafetyLevel(CFStringRef userName, CFStringRef hostName, unsigned long safeLevel) {
CFAllocatorRef alloc = __CFPreferencesAllocator();
#if TARGET_OS_WIN32
CFURLRef url = NULL;
CFMutableStringRef completePath = _CFCreateApplicationRepositoryPath(alloc, CSIDL_APPDATA);
if (completePath) {
// append "Preferences\" and make the CFURL
CFStringAppend(completePath, CFSTR("Preferences\\"));
url = CFURLCreateWithFileSystemPath(alloc, completePath, kCFURLWindowsPathStyle, true);
CFRelease(completePath);
}
// Can't find a better place? Home directory then?
if (url == NULL)
url = CFCopyHomeDirectoryURLForUser((userName == kCFPreferencesCurrentUser) ? NULL : userName);
return url;
#else
CFURLRef location = NULL;
CFKnownLocationUser user;
if (userName == kCFPreferencesAnyUser) {
user = _kCFKnownLocationUserAny;
} else if (userName == kCFPreferencesCurrentUser) {
user = _kCFKnownLocationUserCurrent;
} else {
user = _kCFKnownLocationUserByName;
}
CFURLRef base = _CFKnownLocationCreatePreferencesURLForUser(user, userName);
if (hostName == kCFPreferencesCurrentHost) {
location = CFURLCreateWithFileSystemPathRelativeToBase(kCFAllocatorSystemDefault, CFSTR("ByHost"), kCFURLPOSIXPathStyle, true, base);
} else {
assert(hostName == kCFPreferencesAnyHost);
location = CFRetain(base);
}
CFRelease(base);
return location;
#endif
}
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 InitBMDStreamingAPI(void)
{
CFURLRef bundleURL;
bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR(kBMDStreamingAPI_BundlePath), kCFURLPOSIXPathStyle, true);
if (bundleURL != NULL)
{
gBMDStreamingAPIBundleRef = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (gBMDStreamingAPIBundleRef != NULL)
{
gCreateDiscoveryFunc = (CreateDiscoveryFunc)CFBundleGetFunctionPointerForName(gBMDStreamingAPIBundleRef, CFSTR("CreateBMDStreamingDiscoveryInstance_0002"));
gCreateNALParserFunc = (CreateNALParserFunc)CFBundleGetFunctionPointerForName(gBMDStreamingAPIBundleRef, CFSTR("CreateBMDStreamingH264NALParser_0001"));
}
CFRelease(bundleURL);
}
}
