void *CFBundleGetFunctionPointerForName(CFBundleRef bundle, CFStringRef funcName) {
void *tvp = NULL;
// Load if necessary
if (!bundle->_isLoaded) {
if (!CFBundleLoadExecutable(bundle)) return NULL;
}
switch (bundle->_binaryType) {
#if defined(BINARY_SUPPORT_DYLD)
case __CFBundleDYLDBundleBinary:
case __CFBundleDYLDFrameworkBinary:
case __CFBundleDYLDExecutableBinary:
#if defined(BINARY_SUPPORT_DLFCN)
if (bundle->_handleCookie) return _CFBundleDlfcnGetSymbolByName(bundle, funcName);
#else /* BINARY_SUPPORT_DLFCN */
return _CFBundleDYLDGetSymbolByName(bundle, funcName);
#endif /* BINARY_SUPPORT_DLFCN */
break;
#endif /* BINARY_SUPPORT_DYLD */
#if defined(BINARY_SUPPORT_DLL)
case __CFBundleDLLBinary:
tvp = _CFBundleDLLGetSymbolByName(bundle, funcName);
break;
#endif /* BINARY_SUPPORT_DLL */
default:
#if defined(BINARY_SUPPORT_DLFCN)
if (bundle->_handleCookie) return _CFBundleDlfcnGetSymbolByName(bundle, funcName);
#endif /* BINARY_SUPPORT_DLFCN */
break;
}
return tvp;
}
void *_CFBundleGetCFMFunctionPointerForName(CFBundleRef bundle, CFStringRef funcName) {
void *fp = NULL;
// Load if necessary
if (!bundle->_isLoaded) {
if (!CFBundleLoadExecutable(bundle)) return NULL;
}
#if defined (BINARY_SUPPORT_DYLD) || defined (BINARY_SUPPORT_DLFCN)
switch (bundle->_binaryType) {
#if defined(BINARY_SUPPORT_DYLD)
case __CFBundleDYLDBundleBinary:
case __CFBundleDYLDFrameworkBinary:
case __CFBundleDYLDExecutableBinary:
#if defined(BINARY_SUPPORT_DLFCN)
if (bundle->_handleCookie) fp = _CFBundleDlfcnGetSymbolByNameWithSearch(bundle, funcName, true);
#else /* BINARY_SUPPORT_DLFCN */
fp = _CFBundleDYLDGetSymbolByNameWithSearch(bundle, funcName, true);
#endif /* BINARY_SUPPORT_DLFCN */
break;
#endif /* BINARY_SUPPORT_DYLD */
default:
#if defined(BINARY_SUPPORT_DLFCN)
if (bundle->_handleCookie) fp = _CFBundleDlfcnGetSymbolByNameWithSearch(bundle, funcName, true);
#endif /* BINARY_SUPPORT_DLFCN */
break;
}
#endif /* BINARY_SUPPORT_DYLD || BINARY_SUPPORT_DLFCN */
return fp;
}
CFBundleRef LoadBundle(const char *tpath)
{
OSErr theErr;
CFBundleRef theBundle = NULL;
FSSpec fspec;
if ((theErr = MCS_path2FSSpec(tpath, &fspec)) != noErr)
return NULL;
FSRef theRef;
CFURLRef theBundleURL;
theErr = FSpMakeFSRef(&fspec, &theRef);
theBundleURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &theRef);
if (theBundleURL != NULL)
{
/* Turn the CFURL into a bundle reference */
theBundle = CFBundleCreate(kCFAllocatorSystemDefault, theBundleURL);
CFRelease(theBundleURL);
}
if (theErr != noErr || theBundle == NULL)
return NULL;
Boolean isLoaded = CFBundleLoadExecutable(theBundle);
if (!isLoaded)
{
CFRelease(theBundle);
return NULL;
}
return theBundle;
}
void *CFBundleGetDataPointerForName(CFBundleRef bundle, CFStringRef symbolName) {
void *dp = NULL;
// Load if necessary
if (!bundle->_isLoaded && !CFBundleLoadExecutable(bundle)) return NULL;
switch (bundle->_binaryType) {
#if defined(BINARY_SUPPORT_DYLD)
case __CFBundleDYLDBundleBinary:
case __CFBundleDYLDFrameworkBinary:
case __CFBundleDYLDExecutableBinary:
#if defined(BINARY_SUPPORT_DLFCN)
if (bundle->_handleCookie) dp = _CFBundleDlfcnGetSymbolByName(bundle, symbolName);
#else /* BINARY_SUPPORT_DLFCN */
dp = _CFBundleDYLDGetSymbolByName(bundle, symbolName);
#endif /* BINARY_SUPPORT_DLFCN */
break;
#endif /* BINARY_SUPPORT_DYLD */
#if defined(BINARY_SUPPORT_DLL)
case __CFBundleDLLBinary:
/* MF:!!! Handle this someday */
break;
#endif /* BINARY_SUPPORT_DLL */
default:
#if defined(BINARY_SUPPORT_DLFCN)
if (bundle->_handleCookie) dp = _CFBundleDlfcnGetSymbolByName(bundle, symbolName);
#endif /* BINARY_SUPPORT_DLFCN */
break;
}
return dp;
}
OSStatus LoadFrameworkBundle(CFStringRef framework, CFBundleRef
*bundlePtr)
{
OSStatus err;
FSRef frameworksFolderRef;
CFURLRef baseURL;
CFURLRef bundleURL;
if ( bundlePtr == nil ) return( -1 );
*bundlePtr = nil;
baseURL = nil;
bundleURL = nil;
err = FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, true,
&frameworksFolderRef);
if (err == noErr) {
baseURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault,
&frameworksFolderRef);
if (baseURL == nil) {
err = coreFoundationUnknownErr;
}
}
if (err == noErr) {
bundleURL =
CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL,
framework, false);
if (bundleURL == nil) {
err = coreFoundationUnknownErr;
}
}
if (err == noErr) {
*bundlePtr = CFBundleCreate(kCFAllocatorSystemDefault, bundleURL);
if (*bundlePtr == nil) {
err = coreFoundationUnknownErr;
}
}
if (err == noErr) {
if ( ! CFBundleLoadExecutable( *bundlePtr ) ) {
err = coreFoundationUnknownErr;
}
}
// Clean up.
if (err != noErr && *bundlePtr != nil) {
CFRelease(*bundlePtr);
*bundlePtr = nil;
}
if (bundleURL != nil) {
CFRelease(bundleURL);
}
if (baseURL != nil) {
CFRelease(baseURL);
}
return err;
}
extern pascal OSStatus CFQBundleCreateFromFrameworkName(CFStringRef frameworkName,
CFBundleRef *bundlePtr)
// See comment in header.
{
OSStatus err;
FSRef frameworksFolderRef;
CFURLRef baseURL;
CFURLRef bundleURL;
assert(frameworkName != NULL);
assert( bundlePtr != NULL);
assert(*bundlePtr == NULL);
*bundlePtr = NULL;
baseURL = NULL;
bundleURL = NULL;
// Find the frameworks folder and create a URL for it.
err = FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, true, &frameworksFolderRef);
if (err == noErr) {
baseURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &frameworksFolderRef);
err = CFQError(baseURL);
}
// Append the name of the framework to the URL.
if (err == noErr) {
bundleURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, frameworkName, false);
err = CFQError(bundleURL);
}
// Create a bundle based on that URL and load the bundle into memory.
if (err == noErr) {
*bundlePtr = CFBundleCreate(kCFAllocatorSystemDefault, bundleURL);
err = CFQError(*bundlePtr);
}
if (err == noErr) {
err = CFQErrorBoolean( CFBundleLoadExecutable( *bundlePtr ) );
}
// Clean up.
if (err != noErr) {
CFQRelease(*bundlePtr);
*bundlePtr = NULL;
}
CFQRelease(bundleURL);
CFQRelease(baseURL);
assert( (err == noErr) == (*bundlePtr != NULL) );
return err;
}
OSStatus LoadFrameworkBundle(SInt16 folderLocation,CFStringRef framework, CFBundleRef *bundlePtr)
{
OSStatus err;
FSRef frameworksFolderRef;
CFURLRef baseURL;
CFURLRef bundleURL;
*bundlePtr = nil;
baseURL = nil;
bundleURL = nil;
err = FSFindFolder(folderLocation, kFrameworksFolderType, true, &frameworksFolderRef);
if (err == noErr) {
baseURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &frameworksFolderRef);
if (baseURL == nil) {
err = coreFoundationUnknownErr;
}
}
if (err == noErr) {
bundleURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, framework, false);
if (bundleURL == nil) {
err = coreFoundationUnknownErr;
}
}
if (err == noErr) {
*bundlePtr = CFBundleCreate(kCFAllocatorSystemDefault, bundleURL);
if (*bundlePtr == nil) {
err = coreFoundationUnknownErr;
}
}
if (err == noErr) {
if ( ! CFBundleLoadExecutable( *bundlePtr ) ) {
err = coreFoundationUnknownErr;
}
}
// Clean up.
if (err != noErr && *bundlePtr != nil) {
CFRelease(*bundlePtr);
*bundlePtr = nil;
}
if (bundleURL != nil) {
CFRelease(bundleURL);
}
if (baseURL != nil) {
CFRelease(baseURL);
}
#ifdef JMMDEBUG
fprintf(stderr,"\nsystem location %i error %i",folderLocation,err);
#endif
return err;
}
/*
* QuartzLoadDisplayBundle
* Try to load the appropriate bundle containing the back end display code.
*/
Bool QuartzLoadDisplayBundle(
const char *dpyBundleName)
{
CFBundleRef mainBundle;
CFStringRef bundleName;
CFURLRef bundleURL;
CFBundleRef dpyBundle;
QuartzModeBundleInitPtr bundleInit;
// Get the main bundle for the application
mainBundle = CFBundleGetMainBundle();
// Make CFString from bundle name
bundleName = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault,
dpyBundleName,
kCFStringEncodingASCII,
kCFAllocatorNull);
// Look for the appropriate bundle in the main bundle
bundleURL = CFBundleCopyResourceURL(mainBundle, bundleName,
NULL, NULL);
if (!bundleURL) {
ErrorF("Could not find display mode bundle %s.\n", dpyBundleName);
return FALSE;
}
// Make a bundle instance using the URLRef
dpyBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (!CFBundleLoadExecutable(dpyBundle)) {
ErrorF("Could not load display mode bundle %s.\n", dpyBundleName);
return FALSE;
}
// Lookup the bundle initialization function
bundleInit = (void *)
CFBundleGetFunctionPointerForName(dpyBundle,
CFSTR("QuartzModeBundleInit"));
if (!bundleInit) {
ErrorF("Could not initialize display mode bundle %s.\n",
dpyBundleName);
return FALSE;
}
if (!bundleInit())
return FALSE;
// Release the CF objects
CFRelease(bundleName);
CFRelease(bundleURL);
return TRUE;
}
void CFPlugInSetLoadOnDemand(CFPlugInRef plugIn, Boolean flag) {
if (__CFBundleGetPlugInData(plugIn)->_isPlugIn) {
__CFBundleGetPlugInData(plugIn)->_loadOnDemand = flag;
if (__CFBundleGetPlugInData(plugIn)->_loadOnDemand && !__CFBundleGetPlugInData(plugIn)->_isDoingDynamicRegistration && __CFBundleGetPlugInData(plugIn)->_instanceCount == 0) {
/* Unload now if we can/should. */
/* If we are doing dynamic registration currently, do not unload. The unloading will happen when dynamic registration is done, if necessary. */
CFBundleUnloadExecutable(plugIn);
} else if (!__CFBundleGetPlugInData(plugIn)->_loadOnDemand) {
/* Make sure we're loaded now. */
CFBundleLoadExecutable(plugIn);
}
}
}
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;
}
/*
* LoadGlxBundle
* The Quartz mode X server needs to dynamically load the appropriate
* bundle before initializing GLX.
*/
static void LoadGlxBundle(void)
{
CFBundleRef mainBundle;
CFStringRef bundleName;
CFURLRef bundleURL;
CFBundleRef glxBundle;
// Get the main bundle for the application
mainBundle = CFBundleGetMainBundle();
// Choose the bundle to load
ErrorF("Loading GLX bundle ");
if (quartzUseAGL) {
bundleName = CFSTR("glxAGL.bundle");
ErrorF("glxAGL.bundle (using Apple's OpenGL)\n");
} else {
bundleName = CFSTR("glxMesa.bundle");
ErrorF("glxMesa.bundle (using Mesa)\n");
}
// Look for the appropriate GLX bundle in the main bundle by name
bundleURL = CFBundleCopyResourceURL(mainBundle, bundleName,
NULL, NULL);
if (!bundleURL) {
FatalError("Could not find GLX bundle.");
}
// Make a bundle instance using the URLRef
glxBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (!CFBundleLoadExecutable(glxBundle)) {
FatalError("Could not load GLX bundle.");
}
// Find the GLX init functions
GlxExtensionInit = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxExtensionInit"));
GlxWrapInitVisuals = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxWrapInitVisuals"));
if (!GlxExtensionInit || !GlxWrapInitVisuals) {
FatalError("Could not initialize GLX bundle.");
}
// Release the CF objects
CFRelease(mainBundle);
CFRelease(bundleURL);
}
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
}
CFragConnectionID LoadLibViaPathInDomain(char *libName,SInt16 domain) {
CFragConnectionID libHandle = 0;
CFURLRef theURLRef;
CFBundleRef theBundle;
OSStatus err;
CFStringRef libNameCFString;
FSRef frameworksFolderRef;
CFURLRef baseURL;
err = FSFindFolder(domain, kInternetPlugInFolderType, false,&frameworksFolderRef);
if (err != noErr) {
return nil;
}
baseURL = CFURLCreateFromFSRef(kCFAllocatorSystemDefault,&frameworksFolderRef);
if (baseURL == nil) {
return nil;
}
libNameCFString = CFStringCreateWithCString(kCFAllocatorDefault,libName,kCFStringEncodingMacRoman);
if (libNameCFString == nil) {
CFRelease(baseURL);
return nil;
}
theURLRef = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL,libNameCFString, false);
CFRelease(libNameCFString);
CFRelease(baseURL);
if (theURLRef == nil) {
return nil;
}
theBundle = CFBundleCreate(kCFAllocatorSystemDefault,theURLRef);
CFRelease(theURLRef);
if (theBundle == nil) {
return nil;
}
if (!CFBundleLoadExecutable(theBundle)) {
CFRelease(theBundle);
return nil;
}
libHandle = (CFragConnectionID) theBundle;
return libHandle;
}
// Utility routine to get a bundle from the system folder by file name....typically used to find OpenGL to get extension functions.
int load_bundle_by_filename (const char * in_filename, CFBundleRef * io_bundle_ref)
{
OSStatus err = noErr;
FSRef framework_fs;
CFURLRef framework_url = NULL;
CFURLRef bundle_url = NULL;
CFStringRef bundle_name = NULL;
CFBundleRef bundle_ref = NULL;
bundle_name = CFStringCreateWithCString(kCFAllocatorDefault, in_filename, kCFStringEncodingUTF8);
if (bundle_name == NULL) {
err = paramErr;
goto bail; }
err = FSFindFolder(kSystemDomain, kFrameworksFolderType, false, &framework_fs);
if (noErr != err) {
err = dirNFErr;
goto bail; }
// create URL to folder
framework_url = CFURLCreateFromFSRef (kCFAllocatorDefault, &framework_fs);
if(framework_url == NULL) {
err = ioErr;
goto bail; }
bundle_url = CFURLCreateWithFileSystemPathRelativeToBase(kCFAllocatorDefault, bundle_name, kCFURLPOSIXPathStyle, false, framework_url);
if(bundle_url == NULL) {
err = fnfErr;
goto bail; }
bundle_ref = CFBundleCreate (kCFAllocatorDefault, bundle_url);
if(bundle_ref == NULL) {
err = permErr;
goto bail; }
if (!CFBundleLoadExecutable (bundle_ref)) {
err = bdNamErr;
goto bail;
}
if (io_bundle_ref) { *io_bundle_ref = bundle_ref; bundle_ref = NULL; }
bail:
if(bundle_ref) CFRelease(bundle_ref);
if(bundle_name) CFRelease(bundle_name);
if(bundle_url) CFRelease(bundle_url);
if(framework_url) CFRelease(framework_url);
return err;
}
CFBundleRef mac_loadExeBundle(const char *name)
{
CFBundleRef baseBundle = CFBundleGetBundleWithIdentifier(CFSTR("org.demi3d.Demi"));
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFStringRef nameRef = CFStringCreateWithCString(NULL, name, kCFStringEncodingASCII);
CFURLRef bundleURL = 0; //URL of bundle to load
CFBundleRef bundle = 0; //bundle to load
//cut off .bundle if present
if (CFStringHasSuffix(nameRef, CFSTR(".bundle")))
{
CFStringRef nameTempRef = nameRef;
int end = CFStringGetLength(nameTempRef) - CFStringGetLength(CFSTR(".bundle"));
nameRef = CFStringCreateWithSubstring(NULL, nameTempRef, CFRangeMake(0, end));
CFRelease(nameTempRef);
}
//assume relative to Resources/ directory of Main bundle
bundleURL = CFBundleCopyResourceURL(mainBundle, nameRef, CFSTR("bundle"), NULL);
if (bundleURL)
{
bundle = CFBundleCreate(NULL, bundleURL);
CFRelease(bundleURL);
}
//otherwise, try Resources/ directory of Ogre Framework bundle
if (!bundle)
{
bundleURL = CFBundleCopyResourceURL(baseBundle, nameRef, CFSTR("bundle"), NULL);
if (bundleURL)
{
bundle = CFBundleCreate(NULL, bundleURL);
CFRelease(bundleURL);
}
}
CFRelease(nameRef);
if (bundle)
{
if (CFBundleLoadExecutable(bundle))
return bundle;
else
CFRelease(bundle);
}
return 0;
}
/*
* / Load a module (if needed)
*/
int DYN_LoadLibrary(void **pvLHandle, char *pcLibrary)
{
CFStringRef bundlePath;
CFURLRef bundleURL;
CFBundleRef bundle;
*pvLHandle = 0;
/*
* @@@ kCFStringEncodingMacRoman might be wrong on non US systems.
*/
bundlePath = CFStringCreateWithCString(NULL, pcLibrary,
kCFStringEncodingMacRoman);
if (bundlePath == NULL)
return SCARD_E_NO_MEMORY;
bundleURL = CFURLCreateWithFileSystemPath(NULL, bundlePath,
kCFURLPOSIXPathStyle, TRUE);
CFRelease(bundlePath);
if (bundleURL == NULL)
return SCARD_E_NO_MEMORY;
bundle = CFBundleCreate(NULL, bundleURL);
CFRelease(bundleURL);
if (bundle == NULL)
{
Log1(PCSC_LOG_ERROR, "CFBundleCreate");
return SCARD_F_UNKNOWN_ERROR;
}
if (!CFBundleLoadExecutable(bundle))
{
Log1(PCSC_LOG_ERROR, "CFBundleLoadExecutable");
CFRelease(bundle);
return SCARD_F_UNKNOWN_ERROR;
}
*pvLHandle = (void *) bundle;
return SCARD_S_SUCCESS;
}
bool loadLibrary (const char* fileName)
{
#if _WIN32
module = LoadLibrary (fileName);
#elif TARGET_API_MAC_CARBON
CFStringRef fileNameString = CFStringCreateWithCString (NULL, fileName, kCFStringEncodingUTF8);
if (fileNameString == 0)
return false;
CFURLRef url = CFURLCreateWithFileSystemPath (NULL, fileNameString, kCFURLPOSIXPathStyle, false);
CFRelease (fileNameString);
if (url == 0)
return false;
module = CFBundleCreate (NULL, url);
CFRelease (url);
if (module && CFBundleLoadExecutable ((CFBundleRef)module) == false)
return false;
#endif
return module != 0;
}
bool InjectedBundle::load(APIObject* initializationUserData)
{
if (m_sandboxExtension) {
if (!m_sandboxExtension->consume()) {
fprintf(stderr, "InjectedBundle::load failed - Could not consume bundle sandbox extension for [%s].\n", m_path.utf8().data());
return false;
}
m_sandboxExtension = 0;
}
RetainPtr<CFStringRef> injectedBundlePathStr(AdoptCF, CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar*>(m_path.characters()), m_path.length()));
if (!injectedBundlePathStr) {
fprintf(stderr, "InjectedBundle::load failed - Could not create the path string.\n");
return false;
}
RetainPtr<CFURLRef> bundleURL(AdoptCF, CFURLCreateWithFileSystemPath(0, injectedBundlePathStr.get(), kCFURLPOSIXPathStyle, false));
if (!bundleURL) {
fprintf(stderr, "InjectedBundle::load failed - Could not create the url from the path string.\n");
return false;
}
m_platformBundle = CFBundleCreate(0, bundleURL.get());
if (!m_platformBundle) {
fprintf(stderr, "InjectedBundle::load failed - Could not create the bundle.\n");
return false;
}
if (!CFBundleLoadExecutable(m_platformBundle)) {
fprintf(stderr, "InjectedBundle::load failed - Could not load the executable from the bundle.\n");
return false;
}
WKBundleInitializeFunctionPtr initializeFunction = reinterpret_cast<WKBundleInitializeFunctionPtr>(CFBundleGetFunctionPointerForName(m_platformBundle, CFSTR("WKBundleInitialize")));
if (!initializeFunction) {
fprintf(stderr, "InjectedBundle::load failed - Could not find the initialize function in the bundle executable.\n");
return false;
}
initializeFunction(toAPI(this), toAPI(initializationUserData));
return true;
}
static CFBundleRef
_glitz_agl_get_bundle (const char *name)
{
CFBundleRef bundle = 0;
FSRefParam ref_param;
char framework_name[256];
framework_name[0] = strlen (name);
strcpy (&framework_name[1], name);
memset (&ref_param, 0, sizeof (ref_param));
if (FindFolder (kSystemDomain,
kFrameworksFolderType,
kDontCreateFolder,
&ref_param.ioVRefNum,
&ref_param.ioDirID) == noErr) {
FSRef ref;
memset (&ref, 0, sizeof (ref));
ref_param.ioNamePtr = (unsigned char *) framework_name;
ref_param.newRef = &ref;
if (PBMakeFSRefSync (&ref_param) == noErr) {
CFURLRef url;
url = CFURLCreateFromFSRef (kCFAllocatorDefault, &ref);
if (url) {
bundle = CFBundleCreate (kCFAllocatorDefault, url);
CFRelease (url);
if (!CFBundleLoadExecutable (bundle)) {
CFRelease (bundle);
return (CFBundleRef) 0;
}
}
}
}
return bundle;
}
static void InitializeIO()
{
if (sfwRefCount++) {
return;
}
// race condition, infinitesimal risk
FSRef theRef;
if (FSFindFolder(kOnAppropriateDisk, kFrameworksFolderType, false, &theRef)
== noErr) {
CFURLRef fw = CFURLCreateFromFSRef(kCFAllocatorSystemDefault, &theRef);
if (fw) {
CFURLRef bd = CFURLCreateCopyAppendingPathComponent
(kCFAllocatorSystemDefault, fw, CFSTR("System.framework"), false);
CFRelease(fw);
if (bd) {
systemFramework = CFBundleCreate(kCFAllocatorSystemDefault, bd);
CFRelease(bd);
}
}
if (!systemFramework || !CFBundleLoadExecutable(systemFramework)) {
return;
}
#define F(x) CFBundleGetFunctionPointerForName(systemFramework, CFSTR(#x))
my_fopen = (FILE * (*)(const char *, const char *))F(fopen);
my_fclose = (int(*)(FILE *))F(fclose);
my_ftell = (long(*)(FILE *))F(ftell);
my_fseek = (int(*)(FILE *, long, int))F(fseek);
my_fread = (t4_u32(*)(void *ptr, t4_u32, t4_u32, FILE *))F(fread);
my_fwrite = (t4_u32(*)(const void *ptr, t4_u32, t4_u32, FILE *))F(fwrite);
my_ferror = (int(*)(FILE *))F(ferror);
my_fflush = (int(*)(FILE *))F(fflush);
my_fileno = (int(*)(FILE *))F(fileno);
my_mmap = (char *(*)(char *, t4_u32, int, int, int, long long))F(mmap);
my_munmap = (int(*)(char *, t4_u32))F(munmap);
#undef F
d4_assert(my_fopen && my_fclose && my_ftell && my_fseek && my_fread &&
my_fwrite && my_ferror && my_fflush && my_fileno && my_mmap && my_munmap);
}
}
short InstallConsole(short fd)
{
#pragma unused (fd)
OSErr theErr;
short theResult;
theResult = -1;
/* Start with no bundle */
__msl_os_x.isLoaded = false;
__msl_os_x.theBundle = NULL;
__msl_os_x.theRead = NULL;
__msl_os_x.theWrite = NULL;
/* Create a bundle reference based on its name */
theErr = __msl_CreateFrameworkBundleFromName(CFSTR("System.framework"),
&__msl_os_x.theBundle);
if ((theErr == noErr) && (__msl_os_x.theBundle != NULL))
{
theResult = 0;
__msl_os_x.isLoaded = CFBundleLoadExecutable(__msl_os_x.theBundle);
if (__msl_os_x.isLoaded)
{
/* Lookup the functions in the bundle by name */
__msl_os_x.theRead = (ReadPtr)
CFBundleGetFunctionPointerForName(__msl_os_x.theBundle, CFSTR("read"));
__msl_os_x.theWrite = (WritePtr)
CFBundleGetFunctionPointerForName(__msl_os_x.theBundle, CFSTR("write"));
}
}
return theResult;
}
/*
* LoadGlxBundle
* The Quartz mode X server needs to dynamically load the appropriate
* bundle before initializing GLX.
*/
static void LoadGlxBundle(void)
{
CFBundleRef mainBundle;
CFStringRef bundleName;
CFURLRef bundleURL;
CFBundleRef glxBundle;
// Get the main bundle for the application
mainBundle = CFBundleGetMainBundle();
// Choose the bundle to load
ErrorF("Loading GLX bundle ");
if (/*quartzUseAGL*/0) {
bundleName = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault,
quartzOpenGLBundle,
kCFStringEncodingASCII,
kCFAllocatorNull);
ErrorF("%s (using Apple's OpenGL)\n", quartzOpenGLBundle);
} else {
bundleName = CFSTR("glxMesa.bundle");
CFRetain(bundleName); // so we can release later
ErrorF("glxMesa.bundle (using Mesa)\n");
}
// Look for the appropriate GLX bundle in the main bundle by name
bundleURL = CFBundleCopyResourceURL(mainBundle, bundleName,
NULL, NULL);
if (!bundleURL) {
FatalError("Could not find GLX bundle.");
}
// Make a bundle instance using the URLRef
glxBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
if (!CFBundleLoadExecutable(glxBundle)) {
FatalError("Could not load GLX bundle.");
}
// Find the GLX init functions
__DarwinglXMesaProvider = (void *) CFBundleGetDataPointerForName(
glxBundle, CFSTR("__glXMesaProvider"));
GlxPushProvider = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxPushProvider"));
GlxExtensionInit = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxExtensionInit"));
GlxWrapInitVisuals = (void *) CFBundleGetFunctionPointerForName(
glxBundle, CFSTR("GlxWrapInitVisuals"));
if (!GlxExtensionInit || !GlxWrapInitVisuals) {
FatalError("Could not initialize GLX bundle.");
}
// Release the CF objects
CFRelease(bundleName);
CFRelease(bundleURL);
}
static CFBundleRef findMe()
{
CFURLRef bundleURL;
CFBundleRef myBundle;
Boolean didLoad = false;
// Make a CFURLRef from the CFString representation of the
// bundle's path. See the Core Foundation URL Services chapter
// for details.
bundleURL = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault,
CFSTR("/System/Library/Extensions/DVFamily.bundle"),
kCFURLPOSIXPathStyle,
true );
printf("Bundle URL: %p\n", bundleURL);
// Make a bundle instance using the URLRef.
myBundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );
printf("Bundle: %p\n", myBundle);
// Try to load the executable from my bundle.
didLoad = CFBundleLoadExecutable( myBundle );
printf("loaded? %d\n", didLoad);
sDVFuncs.fDVCountDevices = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVCountDevices") );
sDVFuncs.fDVGetIndDevice = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVGetIndDevice") );
sDVFuncs.fDVSetDeviceName = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVSetDeviceName") );
sDVFuncs.fDVGetDeviceName = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVGetDeviceName") );
sDVFuncs.fDVOpenDriver = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVOpenDriver") );
sDVFuncs.fDVCloseDriver = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVCloseDriver") );
// AVC Stuff
sDVFuncs.fDVDoAVCTransaction = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVDoAVCTransaction") );
sDVFuncs.fDVIsEnabled = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVIsEnabled") );
sDVFuncs.fDVGetDeviceStandard = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVGetDeviceStandard") );
// Isoch I/O
sDVFuncs.fDVEnableRead = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVEnableRead") );
sDVFuncs.fDVDisableRead = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVDisableRead") );
sDVFuncs.fDVReadFrame = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVReadFrame") );
sDVFuncs.fDVReleaseFrame = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVReleaseFrame") );
sDVFuncs.fDVEnableWrite = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVEnableWrite") );
sDVFuncs.fDVDisableWrite = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVDisableWrite") );
sDVFuncs.fDVGetEmptyFrame = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVGetEmptyFrame") );
sDVFuncs.fDVWriteFrame = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVWriteFrame") );
// Notifications
sDVFuncs.fDVNewNotification = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVNewNotification") );
sDVFuncs.fDVNotifyMeWhen = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVNotifyMeWhen") );
sDVFuncs.fDVCancelNotification = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVCancelNotification") );
sDVFuncs.fDVDisposeNotification = CFBundleGetFunctionPointerForName(
myBundle, CFSTR("DVDisposeNotification") );
// Any CF objects returned from functions with "create" or
// "copy" in their names must be released by us!
CFRelease( bundleURL );
return myBundle;
}
// ---------------------------------------------------------------------------
// Constructeur
// ------------
bStdExtLib::bStdExtLib(CFBundleRef bndl,
bGenericMacMapApp* gapp){
_bTrace_("bStdExtLib::bStdExtLib",false);
char path[PATH_MAX];
UInt32 lsign=_kNULLSign_;
_status=_bStdExtLibNoErr_;
_bndl=bndl;
_family=_kNULLSign_;
_creator=_kNULLSign_;
_version=NULL;
_name=NULL;
_sign=_kNULLSign_;
_mmvers=NULL;
_init=NULL;
_destroy=NULL;
_inst=NULL;
for(;;){
CFBundleGetPackageInfo(_bndl,&_family,&_creator);
_version=(CFStringRef)CFBundleGetValueForInfoDictionaryKey(_bndl,CFSTR("CFBundleVersion"));
_name=(CFStringRef)CFBundleGetValueForInfoDictionaryKey(_bndl,CFSTR("CFBundleName"));
CFStringRef cfs;
cfs=(CFStringRef)CFBundleGetValueForInfoDictionaryKey(_bndl,CFSTR("MacMapLibSign"));
_sign=(cfs)?(*((int*)CFStringGetCStringPtr(cfs,0))):_kNULLSign_;
_mmvers=(CFStringRef)CFBundleGetValueForInfoDictionaryKey(_bndl,CFSTR("MacMapMinVers"));
CFURLRef url=CFBundleCopyBundleURL(_bndl);
cfs=CFURLCopyFileSystemPath(url,kCFURLPOSIXPathStyle);
CFStringGetCString(cfs,path,PATH_MAX,kCFStringEncodingUTF8);
CFRelease(cfs);
if(_family==_kNULLSign_){
_status=_bStdExtLibNoFamilyErr_;
break;
}
if(_creator==_kNULLSign_){
_status=_bStdExtLibNoCreatorErr_;
break;
}
if(_version==NULL){
_status=_bStdExtLibNoVersErr_;
break;
}
if(_name==NULL){
break;
}
if(_sign==_kNULLSign_){
_status=_bStdExtLibNoSignatureErr_;
break;
}
if(_mmvers==NULL){
_status=_bStdExtLibNoMacMapVersErr_;
break;
}
if(CFBundleIsExecutableLoaded(_bndl)){
_status=_bStdExtLibBundleAlreadyLoadedErr_;
break;
}
if(!CFBundleLoadExecutable(_bndl)){
_status=_bStdExtLibBundleLoadErr_;
break;
}
_init=(initPtr)CFBundleGetFunctionPointerForName(bndl,CFSTR("init"));
if(!_init){
_status=_bStdExtLibNoInitProcErr_;
break;
}
_destroy=(destroyPtr)CFBundleGetFunctionPointerForName(bndl,CFSTR("destroy"));
if(!_destroy){
_status=_bStdExtLibNoDestroyProcErr_;
break;
}
_init(&_inst,gapp,_bndl);
if(!_inst){
_status=_bStdExtLibNoInstanceErr_;
break;
}
break;
}
if(_status){
_status+=_bStdExtLibRootErr_;
_te_("bStdExtLib::bStdExtLib returns "+_status);
}
else{
char c[256];
name(c);
(void)bSplashWd::instance(false,gapp)->set_progress(c);
// DEBUG<
MacRoman2UTF8(c,256);
lsign=_sign;
#ifdef __LITTLE_ENDIAN__
LBSwapWord(&lsign,sizeof(int));
#endif
_tm_(c+" "+(unsigned int*)(&_family)+"\t"+(unsigned int*)(&lsign)+" loaded");
// DEBUG>
}
}
// hdll, pluginmain and audiomaster are set here
// must be NULL beforehand!
bool VSTPlugin::NewPlugin(const char *plugname)
{
FLEXT_ASSERT(!pluginmain && !audiomaster);
dllname = plugname;
#if FLEXT_OS == FLEXT_OS_WIN
hdll = LoadLibraryEx(dllname.c_str(),NULL,0 /*DONT_RESOLVE_DLL_REFERENCES*/);
/*
char buf[255],*c;
strcpy(buf,dllname.c_str());
for(c = buf; *c; ++c)
if(*c == '/')
*c = '\\';
char *sl = strrchr(buf,'\\');
if(sl) *sl = 0;
SetCurrentDirectory(buf);
hdll = LoadLibrary(dllname.c_str());
*/
if(hdll) pluginmain = (PVSTMAIN)GetProcAddress(hdll,"main");
audiomaster = Master;
#elif FLEXT_OS == FLEXT_OS_MAC
#if 1
CFStringRef fileNameString = CFStringCreateWithCString(NULL, fileName, kCFStringEncodingUTF8);
if(fileNameString == 0) goto bail;
CFURLRef url = CFURLCreateWithFileSystemPath(NULL, fileNameString, kCFURLPOSIXPathStyle, false);
CFRelease(fileNameString);
if(url == 0) goto bail;
hdll = CFBundleCreate(NULL, url);
CFRelease (url);
if(hdll && !CFBundleLoadExecutable(hdll)) goto bail;
PVSTMAIN mainaddr = PluginEntryProc)CFBundleGetFunctionPointerForName(hdll, CFSTR("VSTPluginMain"));
if(!mainaddr)
mainaddr = (PluginEntryProc)CFBundleGetFunctionPointerForName(hdll, CFSTR("main_macho"));
#ifdef __CFM__
pluginmain = (PVSTMAIN)NewMachOFromCFM(mainaddr);
audiomaster = NewCFMFromMachO(Master);
#else
pluginmain = (PVSTMAIN)mainaddr;
audiomaster = Master;
#endif
#else
short resFileID;
FSSpec spec;
OSErr err;
err = FSPathMakeFSSpec(dllname.c_str(),&spec,NULL);
resFileID = FSpOpenResFile(&spec, fsRdPerm);
short cResCB = Count1Resources('aEff');
for(int i = 0; i < cResCB; i++) {
Handle codeH;
CFragConnectionID connID;
Ptr mainAddr;
Str255 errName;
Str255 fragName;
char fragNameCStr[256];
short resID;
OSType resType;
codeH = Get1IndResource('aEff', short(i+1));
if(!codeH) continue;
GetResInfo(codeH, &resID, &resType, fragName);
DetachResource(codeH);
HLock(codeH);
err = GetMemFragment(*codeH,
GetHandleSize(codeH),
fragName,
kPrivateCFragCopy,
&connID, (Ptr *) & mainAddr, errName);
if(!err) {
#ifdef __CFM__
pluginmain = (PVSTMAIN)NewMachOFromCFM(mainAddr);
#else
pluginmain = (PVSTMAIN)mainAddr;
#endif
}
}
CloseResFile(resFileID);
audiomaster =
#ifdef __CFM__
NewCFMFromMachO(Master);
#else
Master;
#endif
#endif
#else
#error Platform not supported
#endif
bail:
if(pluginmain && audiomaster)
return true;
else {
FreePlugin();
return false;
}
}
CFragConnectionID LoadLibViaPath(char *libName, char *pluginDirPath) {
char tempDirPath[DOCUMENT_NAME_SIZE+1];
char cFileName[DOCUMENT_NAME_SIZE+1];
CFragConnectionID libHandle = 0;
CFStringRef filePath;
CFURLRef theURLRef;
CFBundleRef theBundle;
OSStatus err;
strncpy(tempDirPath,pluginDirPath,DOCUMENT_NAME_SIZE);
if (tempDirPath[strlen(tempDirPath)-1] != DELIMITERInt)
strcat(tempDirPath,DELIMITER);
if ((strlen(tempDirPath) + strlen(libName) + 7) > DOCUMENT_NAME_SIZE)
return nil;
strcat(tempDirPath,libName);
strcat(tempDirPath,".bundle");
//Watch out for the bundle suffix, not a normal thing in squeak plugins
/* copy the file name into a null-terminated C string */
sqFilenameFromStringOpen(cFileName, (int) &tempDirPath, strlen(tempDirPath));
#ifdef JMMDEBUG
fprintf(stderr,"\nLoadLibViaPath file %s",cFileName);
#endif
filePath = CFStringCreateWithBytes(kCFAllocatorDefault,(UInt8 *)cFileName,strlen(cFileName),kCFStringEncodingUTF8,false);
theURLRef = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,filePath,kCFURLPOSIXPathStyle,false);
CFRelease(filePath);
if (theURLRef == nil) {
#ifdef JMMDEBUG
fprintf(stderr,"\ntheURLRef was nil so bail");
#endif
return nil;
}
theBundle = CFBundleCreate(NULL,theURLRef);
CFRelease(theURLRef);
if (theBundle == nil) {
CFStringRef libNameCFString;
#ifdef JMMDEBUG
fprintf(stderr,"\nbundle was nil, trying to load from other system locations");
#endif
libNameCFString = CFStringCreateWithCString(kCFAllocatorDefault,libName,gCurrentVMEncoding);
err = LoadFrameworkBundle(kUserDomain,libNameCFString, &theBundle);
if (err != noErr)
err = LoadFrameworkBundle(kNetworkDomain,libNameCFString, &theBundle);
if (err != noErr)
err = LoadFrameworkBundle(kLocalDomain,libNameCFString, &theBundle);
if (err != noErr)
err = LoadFrameworkBundle(kSystemDomain,libNameCFString, &theBundle);
CFRelease(libNameCFString);
if (err != noErr) {
#ifdef JMMDEBUG
fprintf(stderr,"\nno bundle so bail, last error %i",err);
#endif
return nil;
}
}
if (theBundle == nil) {
#ifdef JMMDEBUG
fprintf(stderr,"\nno bundle so bail");
#endif
return nil;
}
if (!CFBundleLoadExecutable(theBundle)) {
#ifdef JMMDEBUG
fprintf(stderr,"\nBundle found but failed CFBundleLoadExecutable");
#endif
CFRelease(theBundle);
return nil;
}
libHandle = (CFragConnectionID) theBundle;
#ifdef JMMDEBUG
fprintf(stderr,"\nFound Bundle %i",libHandle);
#endif
return libHandle;
}
void CVST2KSPIModule::DoScanDirectory(const std::string& sPathName)
{
// Scan the system for plug-ins
CAutoDelete<IFileSearch> pFileSearch(IFileSearch::Create());
pFileSearch->Init(sPathName.c_str());
tchar pszName[256];
tbool bDirectory;
while (pFileSearch->GetNext(pszName, bDirectory)) {
std::string sPlugInPath = sPathName;
std::string sName(pszName);
#ifdef WIN32
if (bDirectory) {
#else // WIN32
std::string sEnding = sName.substr(sName.size() - 4);
if (sEnding != ".vst" && sEnding != ".VST" && sName.size() > 4) {
#endif
sPlugInPath += sName;
sPlugInPath += ":";
DoScanDirectory(sPlugInPath);
continue;
}
std::string sPathName = sPlugInPath + sName;
#ifdef WIN32
// Load the plug-in to get info
{
HMODULE hDLL;
std::string sEnding = sName.substr(sName.size() - 4);
if (sEnding != ".dll" && sEnding != ".DLL" && sEnding != ".Dll" && sName.size() > 4) {
continue;
}
// Load plug-in
std::string s2 = sPathName;
ModifyPathName(s2);
hDLL = LoadLibrary(s2.c_str());
if (hDLL == NULL) {
continue;
}
VSTMainFunc mainFunc = (VSTMainFunc)(void*)GetProcAddress(hDLL, "VSTPluginMain");
// VSTMainFunc mainFunc = (VSTMainFunc)CFBundleGetFunctionPointerForName(BundleRef, CFSTR("main") );
if (mainFunc == NULL) {
continue;
}
AEffect* pEffect = NULL;
try {
pEffect = mainFunc(audioMasterCallbackModule);
// Note: Call setSampleRate and setBlockSize also (part of initialization sequence).
pEffect->dispatcher(pEffect, effOpen, 0, 0, 0, 0.0);
// We don't really need the name now, but we want to just try something to see if it crashes. Would be better to get some info about VST version and required host VST version.
char pszProductName[1042];
pEffect->dispatcher(pEffect, effGetEffectName, 0, 0, pszProductName, 0.0);
}
catch(...) {
// Plug-in crashed
// CFBundleUnloadExecutable(BundleRef);
// CFRelease(BundleRef);
continue;
}
// Effect appears ok, put it in list
msEffectPathNames.push_back(sPathName);
// Unload it
pEffect->dispatcher(pEffect, effClose, 0, 0, 0, 0.0);
// CFBundleUnloadExecutable(BundleRef);
// CFRelease(BundleRef);
}
#else // WIN32
// Load the plug-in to get info
{
CFBundleRef BundleRef;
// Make a CFURLRef from the CFString representation of the bundle's path.
tchar pszPathName[1024];
strcpy(pszPathName, sPathName.c_str());
ToUnix(pszPathName);
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault,
__CFStringMakeConstantString(pszPathName),
kCFURLPOSIXPathStyle,
true );
if ( !bundleURL ) continue;
// Make a bundle instance using the URLRef.
BundleRef = CFBundleCreate( kCFAllocatorDefault, bundleURL );
// We don't need the URL anymore
CFRelease( bundleURL );
if ( !BundleRef ) {
continue;
}
if ( !CFBundleLoadExecutable( BundleRef ) )
{
CFRelease( BundleRef );
BundleRef = NULL;
continue;
}
VSTMainFunc mainFunc = (VSTMainFunc)CFBundleGetFunctionPointerForName(BundleRef, CFSTR("VSTPluginMain") );
// VSTMainFunc mainFunc = (VSTMainFunc)CFBundleGetFunctionPointerForName(BundleRef, CFSTR("main") );
if (mainFunc == NULL) {
continue;
}
AEffect* pEffect = NULL;
try {
pEffect = mainFunc(audioMasterCallbackModule);
// Note: Call setSampleRate and setBlockSize also (part of initialization sequence).
pEffect->dispatcher(pEffect, effOpen, 0, 0, 0, 0.0);
// We don't really need the name now, but we want to just try something to see if it crashes. Would be better to get some info about VST version and required host VST version.
char pszProductName[1042];
pEffect->dispatcher(pEffect, effGetEffectName, 0, 0, pszProductName, 0.0);
}
catch(...) {
// Plug-in crashed
// CFBundleUnloadExecutable(BundleRef);
// CFRelease(BundleRef);
continue;
}
// Effect appears ok, put it in list
msEffectPathNames.push_back(sPathName);
// Unload it
pEffect->dispatcher(pEffect, effClose, 0, 0, 0, 0.0);
// CFBundleUnloadExecutable(BundleRef);
// CFRelease(BundleRef);
}
#endif // WIN32 / else
}
}
void CVST2KSPIModule::Init()
{
/* short sVolRef;
long lDirID;
tchar pszPlugInPath[1024];
::FindFolder(kOnSystemDisk, kVolumeRootFolderType, kDontCreateFolder, &sVolRef, &lDirID);
PathNameFromDirID(lDirID, sVolRef, (char*)pszPlugInPath);
std::string sPlugInPath(pszPlugInPath);
sPlugInPath += std::string("Library:Audio:Plug-Ins:VST:");*/
// Note: This is hardcoded, and needs to change
#ifdef WIN32
std::string sPlugInPath(":C:VSTPlugIns:");
DoScanDirectory(sPlugInPath);
#else // WIN32
// std::string sPlugInPath(":Macintosh HD:Library:Audio:Plug-Ins:VST:");
tchar pszPath[1024];
IFile::GetSystemDirectory(IFile::SystemDirLibrary, pszPath);
strcat(pszPath, "Audio:Plug-Ins:VST:");
std::string sPlugInPath(pszPath);
DoScanDirectory(sPlugInPath);
IFile::GetSystemDirectory(IFile::SystemDirUser, pszPath);
strcat(pszPath, "Library:Audio:Plug-Ins:VST:");
sPlugInPath = std::string(pszPath);
DoScanDirectory(sPlugInPath);
#endif // WIN32 / else
}
CVST2KSPIPlugIn::CVST2KSPIPlugIn(CVST2KSPIModule* pModule, const std::string& sEffectPathName)
: CBasePlugIn(dynamic_cast<CBaseModule*>(pModule), giAudioMaxBufferSize, dynamic_cast<CBaseDSPEngine*>(new CEcho()), 0, COMPANY_NAME, PRODUCT_NAME),
mbUpdateGUISettings(true),
mbBypass(false), mbShowDemoExpiredDialog(false),
mbRegistered(false),
miNoiseMode(0), miNoiseCounter(0),
msEffectPathName(sEffectPathName),
mpVSTEffect(NULL)
{
dynamic_cast<CEcho*>(mpDSPEngine)->SetChannels(2);
mpDezipper->SetCallback(dynamic_cast<IBaseDezipperCallback*>(this));
mbCanProcess = true;
muiTimeWhenStarted = ITime::GetTimeMS();
miRandom = 0x123456;
#ifdef WIN32
{
HMODULE hDLL;
// Load plug-in
std::string s2 = msEffectPathName;
ModifyPathName(s2);
hDLL = LoadLibrary(s2.c_str());
if (hDLL == NULL) {
}
VSTMainFunc mainFunc = (VSTMainFunc)(void*)GetProcAddress(hDLL, "VSTPluginMain");
if (mainFunc == NULL) {
}
try {
mpVSTEffect = mainFunc(audioMasterCallbackPlugIn);
mpVSTEffect->dispatcher(mpVSTEffect, effOpen, 0, 0, 0, 0.0);
mpVSTEffect->dispatcher(mpVSTEffect, effSetSampleRate, 0, 0, 0, 44100.0f);
mpVSTEffect->dispatcher(mpVSTEffect, effSetBlockSize, 0, 32, 0, 0.0);
}
catch(...) {
// Plug-in crashed
mpVSTEffect = NULL;
}
}
#else // WIN32
{
CFBundleRef BundleRef;
// Make a CFURLRef from the CFString representation of the bundle's path.
tchar pszPathName[1024];
strcpy(pszPathName, msEffectPathName.c_str());
ToUnix(pszPathName);
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault,
__CFStringMakeConstantString(pszPathName),
kCFURLPOSIXPathStyle,
true );
if ( !bundleURL ) {
}
// Make a bundle instance using the URLRef.
BundleRef = CFBundleCreate( kCFAllocatorDefault, bundleURL );
// We don't need the URL anymore
CFRelease( bundleURL );
if ( !BundleRef ) {
}
if ( !CFBundleLoadExecutable( BundleRef ) )
{
CFRelease( BundleRef );
BundleRef = NULL;
}
VSTMainFunc mainFunc = (VSTMainFunc)CFBundleGetFunctionPointerForName(
BundleRef, CFSTR("VSTPluginMain") );
if (mainFunc == NULL) {
}
try {
mpVSTEffect = mainFunc(audioMasterCallbackPlugIn);
mpVSTEffect->dispatcher(mpVSTEffect, effOpen, 0, 0, 0, 0.0);
mpVSTEffect->dispatcher(mpVSTEffect, effSetSampleRate, 0, 0, 0, 44100.0f);
mpVSTEffect->dispatcher(mpVSTEffect, effSetBlockSize, 0, 32, 0, 0.0);
}
catch(...) {
// Plug-in crashed
mpVSTEffect = NULL;
}
}
#endif // WIN32 / else
}
//
// Load management for a loadable bundle
//
void LoadableBundle::load()
{
if (!CFBundleLoadExecutable(cfBundle()))
CFError::throwMe();
secdebug("bundle", "%p (%s) loaded", this, path().c_str());
}
/*ARGSUSED2*/
long KRB5_CALLCONV
krb5int_open_plugin (const char *filepath, struct plugin_file_handle **h, struct errinfo *ep)
{
long err = 0;
struct stat statbuf;
struct plugin_file_handle *htmp = NULL;
int got_plugin = 0;
if (!err) {
if (stat (filepath, &statbuf) < 0) {
Tprintf ("stat(%s): %s\n", filepath, strerror (errno));
err = errno;
}
}
if (!err) {
htmp = calloc (1, sizeof (*htmp)); /* calloc initializes ptrs to NULL */
if (htmp == NULL) { err = errno; }
}
#if USE_DLOPEN
if (!err && (statbuf.st_mode & S_IFMT) == S_IFREG) {
void *handle = NULL;
#ifdef RTLD_GROUP
#define PLUGIN_DLOPEN_FLAGS (RTLD_NOW | RTLD_LOCAL | RTLD_GROUP)
#else
#define PLUGIN_DLOPEN_FLAGS (RTLD_NOW | RTLD_LOCAL)
#endif
if (!err) {
handle = dlopen(filepath, PLUGIN_DLOPEN_FLAGS);
if (handle == NULL) {
const char *e = dlerror();
Tprintf ("dlopen(%s): %s\n", filepath, e);
err = ENOENT; /* XXX */
krb5int_set_error (ep, err, "%s", e);
}
}
if (!err) {
got_plugin = 1;
htmp->dlhandle = handle;
handle = NULL;
}
if (handle != NULL) { dlclose (handle); }
}
#endif
#if USE_CFBUNDLE
if (!err && (statbuf.st_mode & S_IFMT) == S_IFDIR) {
CFStringRef pluginPath = NULL;
CFURLRef pluginURL = NULL;
CFBundleRef pluginBundle = NULL;
if (!err) {
pluginPath = CFStringCreateWithCString (kCFAllocatorDefault, filepath,
kCFStringEncodingASCII);
if (pluginPath == NULL) { err = ENOMEM; }
}
if (!err) {
pluginURL = CFURLCreateWithFileSystemPath (kCFAllocatorDefault, pluginPath,
kCFURLPOSIXPathStyle, true);
if (pluginURL == NULL) { err = ENOMEM; }
}
if (!err) {
pluginBundle = CFBundleCreate (kCFAllocatorDefault, pluginURL);
if (pluginBundle == NULL) { err = ENOENT; } /* XXX need better error */
}
if (!err) {
if (!CFBundleIsExecutableLoaded (pluginBundle)) {
int loaded = CFBundleLoadExecutable (pluginBundle);
if (!loaded) { err = ENOENT; } /* XXX need better error */
}
}
if (!err) {
got_plugin = 1;
htmp->bundle = pluginBundle;
pluginBundle = NULL; /* htmp->bundle takes ownership */
}
if (pluginBundle != NULL) { CFRelease (pluginBundle); }
if (pluginURL != NULL) { CFRelease (pluginURL); }
if (pluginPath != NULL) { CFRelease (pluginPath); }
}
#endif
if (!err && !got_plugin) {
err = ENOENT; /* no plugin or no way to load plugins */
}
if (!err) {
*h = htmp;
htmp = NULL; /* h takes ownership */
}
if (htmp != NULL) { free (htmp); }
return err;
}
