IPlugin* load(const char* path) override
{
g_log_info.log("plugins") << "loading plugin " << path;
typedef IPlugin* (*PluginCreator)(Engine&);
auto* lib = loadLibrary(path);
if (lib)
{
PluginCreator creator = (PluginCreator)getLibrarySymbol(lib, "createPlugin");
if (creator)
{
IPlugin* plugin = creator(m_engine);
if (!plugin || !plugin->create())
{
LUMIX_DELETE(m_engine.getAllocator(), plugin);
ASSERT(false);
return nullptr;
}
m_plugins.push(plugin);
m_libraries.push(lib);
m_library_loaded.invoke(lib);
g_log_info.log("plugins") << "plugin loaded";
return plugin;
}
}
unloadLibrary(lib);
return 0;
}
bool OsmAnd::CoreResourcesEmbeddedBundle_P::loadFromCurrentExecutable()
{
#if defined(OSMAND_TARGET_OS_windows)
_bundleLibraryNeedsClose = false;
_bundleLibrary = GetModuleHandleA(NULL);
if (_bundleLibrary == NULL)
{
LogPrintf(LogSeverityLevel::Error,
"Failed to open main program executable as library");
return false;
}
#else
_bundleLibraryNeedsClose = true;
_bundleLibrary = dlopen(NULL, RTLD_NOW | RTLD_GLOBAL);
if (_bundleLibrary == NULL)
{
const auto error = dlerror();
LogPrintf(LogSeverityLevel::Error,
"Failed to open main program executable as library: %s", error ? error : "unknown");
return false;
}
#endif
if (!loadResources())
{
unloadLibrary();
return false;
}
return true;
}
void
SharedLibrary::loadLibary()
{
unloadLibrary();
RString nstr = _library->convertToNative();
_libReference = (void*)LoadLibrary(ACDK_API_CONSTCHARPTR(nstr->native_c_str()));
}
bool SharedLibrary::unload() {
if (mHandle == NULL)
return true;
bool success=unloadLibrary(mHandle);
mHandle=NULL;
return success;
}
bool OsmAnd::CoreResourcesEmbeddedBundle_P::loadFromLibrary(const QString& libraryNameOrFilename)
{
#if defined(OSMAND_TARGET_OS_windows)
_bundleLibraryNeedsClose = true;
_bundleLibrary = LoadLibraryA(qPrintable(libraryNameOrFilename));
if (_bundleLibrary == NULL)
{
LogPrintf(LogSeverityLevel::Error,
"Failed to load library from '%s'", qPrintable(libraryNameOrFilename));
return false;
}
#else
_bundleLibraryNeedsClose = true;
_bundleLibrary = dlopen(qPrintable(libraryNameOrFilename), RTLD_NOW | RTLD_GLOBAL);
if (_bundleLibrary == NULL)
{
const auto error = dlerror();
LogPrintf(LogSeverityLevel::Error,
"Failed to load library from '%s': %s",
qPrintable(libraryNameOrFilename),
error ? error : "unknown");
return false;
}
#endif
if (!loadResources())
{
unloadLibrary();
return false;
}
return true;
}
void
PluginLoader::Impl::pluginDeleted(PluginDeletionNotifyAdapter *adapter)
{
void *handle = m_pluginLibraryHandleMap[adapter];
if (handle) unloadLibrary(handle);
m_pluginLibraryHandleMap.erase(adapter);
}
void onGameModeToggled(bool is_starting)
{
if (is_starting)
{
if (!m_library)
{
m_library = Library::create(m_library_path, m_allocator);
if (!m_library->load())
{
g_log_error.log("script") << "Could not load " << m_library_path.c_str();
Library::destroy(m_library);
m_library = NULL;
return;
}
m_update_function = (UpdateFunction)m_library->resolve("update");
m_done_function = (DoneFunction)m_library->resolve("done");
m_serialize_function = (SerializeFunction)m_library->resolve("serialize");
m_deserialize_function = (DeserializeFunction)m_library->resolve("deserialize");
InitFunction init_function = (InitFunction)m_library->resolve("init");
if (!m_update_function || !init_function)
{
g_log_error.log("script") << "Script interface in " << m_library_path.c_str() << " is not complete";
}
if (init_function)
{
init_function(this);
}
}
}
else
{
unloadLibrary();
}
}
void Foam::codedBase::updateLibrary
(
const word& name
) const
{
const dictionary& dict = this->codeDict();
dynamicCode::checkSecurity
(
"codedBase::updateLibrary()",
dict
);
dynamicCodeContext context(dict);
// codeName: name + _<sha1>
// codeDir : name
dynamicCode dynCode
(
name + context.sha1().str(true),
name
);
const fileName libPath = dynCode.libPath();
// the correct library was already loaded => we are done
if (libs().findLibrary(libPath))
{
return;
}
Info<< "Using dynamicCode for " << this->description().c_str()
<< " at line " << dict.startLineNumber()
<< " in " << dict.name() << endl;
// remove instantiation of fvPatchField provided by library
this->clearRedirect();
// may need to unload old library
unloadLibrary
(
oldLibPath_,
dynamicCode::libraryBaseName(oldLibPath_),
context.dict()
);
// try loading an existing library (avoid compilation when possible)
if (!loadLibrary(libPath, dynCode.codeName(), context.dict()))
{
createLibrary(dynCode, context);
loadLibrary(libPath, dynCode.codeName(), context.dict());
}
// retain for future reference
oldLibPath_ = libPath;
}
IPlugin* load(const char* path) override
{
char path_with_ext[MAX_PATH_LENGTH];
copyString(path_with_ext, path);
const char* ext =
#ifdef _WIN32
".dll";
#elif defined __linux__
".so";
#else
#error Unknown platform
#endif
if (!PathUtils::hasExtension(path, ext + 1)) catString(path_with_ext, ext);
g_log_info.log("Core") << "loading plugin " << path_with_ext;
typedef IPlugin* (*PluginCreator)(Engine&);
auto* lib = loadLibrary(path_with_ext);
if (lib)
{
PluginCreator creator = (PluginCreator)getLibrarySymbol(lib, "createPlugin");
if (creator)
{
IPlugin* plugin = creator(m_engine);
if (!plugin)
{
g_log_error.log("Core") << "createPlugin failed.";
LUMIX_DELETE(m_engine.getAllocator(), plugin);
ASSERT(false);
}
else
{
addPlugin(plugin);
m_libraries.push(lib);
m_library_loaded.invoke(lib);
g_log_info.log("Core") << "Plugin loaded.";
Debug::StackTree::refreshModuleList();
return plugin;
}
}
else
{
g_log_error.log("Core") << "No createPlugin function in plugin.";
}
unloadLibrary(lib);
}
else
{
auto* plugin = StaticPluginRegister::create(path, m_engine);
if (plugin)
{
g_log_info.log("Core") << "Plugin loaded.";
addPlugin(plugin);
return plugin;
}
g_log_warning.log("Core") << "Failed to load plugin.";
}
return nullptr;
}
void unload(IPlugin* plugin) override
{
int idx = m_plugins.indexOf(plugin);
ASSERT(idx >= 0);
LUMIX_DELETE(m_engine.getAllocator(), m_plugins[idx]);
unloadLibrary(m_libraries[idx]);
m_libraries.erase(idx);
m_plugins.erase(idx);
}
PluginManager::~PluginManager()
{
// Note: The plugins do not need to (and must not) be destroyed, because this is done
// inside the plugin library, when deinitialize() is called.
// Unload plugin libraries
for (const std::pair<std::string, PluginLibrary *> & it : m_librariesByFilePath) {
unloadLibrary(it.second);
}
}
int EffectUnloadLibrary(int handle)
{
int ret = init();
if (ret < 0) {
return ret;
}
ret = unloadLibrary(handle);
updateNumEffects();
return ret;
}
void Foam::codedFunctionObject::updateLibrary() const
{
dynamicCode::checkSecurity
(
"codedFunctionObject::updateLibrary()",
dict_
);
dynamicCodeContext context(dict_);
// codeName: redirectType + _<sha1>
// codeDir : redirectType
dynamicCode dynCode
(
redirectType_ + context.sha1().str(true),
redirectType_
);
const fileName libPath = dynCode.libPath();
// the correct library was already loaded => we are done
if (const_cast<Time&>(time_).libs().findLibrary(libPath))
{
return;
}
Info<< "Using dynamicCode for functionObject " << name()
<< " at line " << dict_.startLineNumber()
<< " in " << dict_.name() << endl;
// remove instantiation of fvPatchField provided by library
redirectFunctionObjectPtr_.clear();
// may need to unload old library
unloadLibrary
(
oldLibPath_,
dynamicCode::libraryBaseName(oldLibPath_),
context.dict()
);
// try loading an existing library (avoid compilation when possible)
if (!loadLibrary(libPath, dynCode.codeName(), context.dict()))
{
createLibrary(dynCode, context);
loadLibrary(libPath, dynCode.codeName(), context.dict());
}
// retain for future reference
oldLibPath_ = libPath;
}
~PluginManagerImpl()
{
for (int i = m_plugins.size() - 1; i >= 0; --i)
{
LUMIX_DELETE(m_engine.getAllocator(), m_plugins[i]);
}
for (int i = 0; i < m_libraries.size(); ++i)
{
unloadLibrary(m_libraries[i]);
}
}
extern "C" DECLSPEC void SDLCALL Java_paulscode_android_mupen64plusae_jni_NativeExports_unloadLibraries(JNIEnv* env, jclass cls)
{
// Unload the libraries to ensure that static variables are re-initialized next time
LOGI("Unloading native libraries");
// Clear stale error messages
dlerror();
// Find and call the JNI_OnUnLoad functions from the SDL2 library
pJNI_OnUnload JNI_OnUnLoad = (pJNI_OnUnload) locateFunction(handleSDL, "SDL2", "JNI_OnUnload");
JNI_OnUnLoad(mVm, mReserved);
JNI_OnUnLoad = NULL;
// Nullify function pointers so that they can no longer be used
aeiInit = NULL;
sdlInit = NULL;
sdlSetScreen = NULL;
sdlMainReady = NULL;
coreDoCommand = NULL;
frontMain = NULL;
nativeResume = NULL;
nativePause = NULL;
// Close shared libraries
unloadLibrary(handleFront, "mupen64plus-ui-console");
unloadLibrary(handleCore, coreLibraryName);
unloadLibrary(handleFreetype, "freetype");
unloadLibrary(handleSDL, "SDL2");
unloadLibrary(handleAEI, "ae-imports");
// Nullify handles so that they can no longer be used
handleFront = NULL;
handleCore = NULL;
handleFreetype = NULL;
handleSDL = NULL;
handleAEI = NULL;
coreLibraryName = "mupen64plus-core";
}
void SharedLibrary::gc(DL_HANDLE handle) {
static std::vector<DL_HANDLE> *sHandles=new std::vector<DL_HANDLE>;
if (handle) {
if (sHandles==NULL)
sHandles=new std::vector<DL_HANDLE>;
sHandles->push_back(handle);
}else if(sHandles){
for (std::vector<DL_HANDLE>::iterator i=sHandles->begin();i!=sHandles->end();++i) {
unloadLibrary(*i);
}
delete sHandles;
sHandles=NULL;
}
}
bool PluginManager::loadLibrary(const std::string & filePath, bool reload)
{
// Check if library is already loaded and reload is not requested
auto it = m_librariesByFilePath.find(filePath);
if (it != m_librariesByFilePath.cend() && !reload) {
return true;
}
// Get path to directory containing the plugin library
std::string pluginPath = iozeug::removeTrailingPathSeparator(iozeug::getPath(filePath));
// Load extra information from "PluginInfo.json" if present
Variant pluginInfo = Variant();
SerializerJSON json;
if (json.load(pluginInfo, pluginPath + iozeug::SystemInfo::pathSeperator() + "PluginInfo.json"))
{
// Replace every occurance of ${PluginPath} with respective path
std::string jsonString = pluginInfo.toJSON();
auto from = std::string("${PluginPath}");
size_t start_pos = 0;
while((start_pos = jsonString.find(from, start_pos)) != std::string::npos) {
jsonString.replace(start_pos, from.length(), pluginPath);
start_pos += pluginPath.length();
}
// Convert back to JSON Variant
json.fromString(pluginInfo, jsonString);
}
// If library was already loaded, remember it in case reloading fails
PluginLibrary * previous = nullptr;
if (it != m_librariesByFilePath.cend()) {
previous = it->second;
}
// Open plugin library
PluginLibraryImpl * library = new PluginLibraryImpl(filePath);
if (!library->isValid())
{
// Loading failed. Destroy library object and return failure.
globjects::warning() << (previous ? "Reloading" : "Loading") << " plugin(s) from '" << filePath << "' failed.";
delete library;
return false;
}
// Library has been loaded. Unload previous incarnation.
if (previous) {
unloadLibrary(previous);
}
// Add library to list (in case of reload, this overwrites the previous)
m_librariesByFilePath[filePath] = library;
// Initialize plugin library
library->initialize();
// Iterate over plugins
const unsigned int numPlugins = library->numPlugins();
for (unsigned int i = 0; i < numPlugins; ++i)
{
// Get plugin
gloperate::Plugin * plugin = library->plugin(i);
if (!plugin)
continue;
// // Set relative data path for plugin (if known)
// if (!relDataPath.empty()) {
// plugin->setRelDataPath(relDataPath.c_str());
// }
if (!pluginInfo.isNull())
{
plugin->setPluginInfo(pluginInfo);
}
// Add plugin to list
m_plugins.push_back(plugin);
// Save plugin by name
std::string name = plugin->name();
m_pluginsByName[name] = plugin;
}
// Return success
return true;
}
void displayError(WCHAR* pwszError)
{
MessageBoxW(NULL, pwszError, L"Raw Input error!", MB_ICONERROR | MB_OK);
CRawInput::hookLibrary(false);
unloadLibrary();
}
void Foam::codedFixedValueFvPatchField<Type>::updateLibrary() const
{
dynamicCode::checkSecurity
(
"codedFixedValueFvPatchField<Type>::updateLibrary()",
dict_
);
// use system/codeDict or in-line
const dictionary& codeDict =
(
dict_.found("code")
? dict_
: this->dict().subDict(redirectType_)
);
dynamicCodeContext context(codeDict);
// codeName: redirectType + _<sha1>
// codeDir : redirectType
dynamicCode dynCode
(
redirectType_ + context.sha1().str(true),
redirectType_
);
const fileName libPath = dynCode.libPath();
// the correct library was already loaded => we are done
if (const_cast<Time&>(this->db().time()).libs().findLibrary(libPath))
{
return;
}
Info<< "Using dynamicCode for patch " << this->patch().name()
<< " on field " << this->dimensionedInternalField().name() << nl
<< "at line " << codeDict.startLineNumber()
<< " in " << codeDict.name() << endl;
// remove instantiation of fvPatchField provided by library
redirectPatchFieldPtr_.clear();
// may need to unload old library
unloadLibrary
(
oldLibPath_,
dynamicCode::libraryBaseName(oldLibPath_),
context.dict()
);
// try loading an existing library (avoid compilation when possible)
if (!loadLibrary(libPath, dynCode.codeName(), context.dict()))
{
createLibrary(dynCode, context);
loadLibrary(libPath, dynCode.codeName(), context.dict());
}
// retain for future reference
oldLibPath_ = libPath;
}
OsmAnd::CoreResourcesEmbeddedBundle_P::~CoreResourcesEmbeddedBundle_P()
{
unloadLibrary();
}
int main( int argc, _TCHAR* argv[] )
{
_TCHAR* errorMsg;
_TCHAR* program;
_TCHAR* iniFile;
_TCHAR* ch;
_TCHAR** configArgv = NULL;
int configArgc = 0;
int exitCode = 0;
int ret = 0;
void * handle = 0;
RunMethod runMethod;
SetInitialArgs setArgs;
setlocale(LC_ALL, "");
initialArgc = argc;
initialArgv = malloc((argc + 1) * sizeof(_TCHAR*));
memcpy(initialArgv, argv, (argc + 1) * sizeof(_TCHAR*));
/*
* Strip off any extroneous <CR> from the last argument. If a shell script
* on Linux is created in DOS format (lines end with <CR><LF>), the C-shell
* does not strip off the <CR> and hence the argument is bogus and may
* not be recognized by the launcher or eclipse itself.
*/
ch = _tcschr( argv[ argc - 1 ], _T_ECLIPSE('\r') );
if (ch != NULL)
{
*ch = _T_ECLIPSE('\0');
}
/* Determine the full pathname of this program. */
program = findProgram(argv);
/* Parse configuration file arguments */
iniFile = checkForIni(argc, argv);
if (iniFile != NULL)
ret = readConfigFile(iniFile, &configArgc, &configArgv);
else
ret = readIniFile(program, &configArgc, &configArgv);
if (ret == 0)
{
parseArgs (&configArgc, configArgv);
}
/* Parse command line arguments */
/* Overrides configuration file arguments */
parseArgs( &argc, argv );
/* Special case - user arguments specified in the config file
* are appended to the user arguments passed from the command line.
*/
if (configArgc > 0)
{
createUserArgs(configArgc, configArgv, &argc, &argv);
}
/* Initialize official program name */
officialName = name != NULL ? _tcsdup( name ) : getDefaultOfficialName(program);
/* Find the directory where the Eclipse program is installed. */
programDir = getProgramDir(program);
/* Find the eclipse library */
eclipseLibrary = findLibrary(eclipseLibrary, program);
if(eclipseLibrary != NULL)
handle = loadLibrary(eclipseLibrary);
if(handle == NULL) {
errorMsg = malloc( (_tcslen(libraryMsg) + _tcslen(officialName) + 10) * sizeof(_TCHAR) );
_stprintf( errorMsg, libraryMsg, officialName );
if (!suppressErrors)
displayMessage( officialName, errorMsg );
else
_ftprintf(stderr, _T_ECLIPSE("%s:\n%s\n"), officialName, errorMsg);
free( errorMsg );
exit( 1 );
}
setArgs = (SetInitialArgs)findSymbol(handle, SET_INITIAL_ARGS);
if(setArgs != NULL)
setArgs(initialArgc, initialArgv, eclipseLibrary);
else {
if(!suppressErrors)
displayMessage(officialName, entryMsg);
else
_ftprintf(stderr, _T_ECLIPSE("%s:\n%s\n"), officialName, entryMsg);
exit(1);
}
runMethod = (RunMethod)findSymbol(handle, RUN_METHOD);
if(runMethod != NULL)
exitCode = runMethod(argc, argv, userVMarg);
else {
if(!suppressErrors)
displayMessage(officialName, entryMsg);
else
_ftprintf(stderr, _T_ECLIPSE("%s:\n%s\n"), officialName, entryMsg);
exit(1);
}
unloadLibrary(handle);
free( eclipseLibrary );
free( programDir );
free( program );
free( officialName );
return exitCode;
}
virtual void beforeScriptCompiled() override
{
m_reload_after_compile = true;
m_is_compiling = true;
unloadLibrary();
}
Plugin *
PluginLoader::Impl::loadPlugin(PluginKey key,
float inputSampleRate, int adapterFlags)
{
string libname, identifier;
if (!decomposePluginKey(key, libname, identifier)) {
std::cerr << "Vamp::HostExt::PluginLoader: Invalid plugin key \""
<< key << "\" in loadPlugin" << std::endl;
return 0;
}
string fullPath = getLibraryPathForPlugin(key);
if (fullPath == "") return 0;
void *handle = loadLibrary(fullPath);
if (!handle) return 0;
VampGetPluginDescriptorFunction fn =
(VampGetPluginDescriptorFunction)lookupInLibrary
(handle, "vampGetPluginDescriptor");
if (!fn) {
unloadLibrary(handle);
return 0;
}
int index = 0;
const VampPluginDescriptor *descriptor = 0;
while ((descriptor = fn(VAMP_API_VERSION, index))) {
if (string(descriptor->identifier) == identifier) {
Vamp::PluginHostAdapter *plugin =
new Vamp::PluginHostAdapter(descriptor, inputSampleRate);
Plugin *adapter = new PluginDeletionNotifyAdapter(plugin, this);
m_pluginLibraryHandleMap[adapter] = handle;
if (adapterFlags & ADAPT_INPUT_DOMAIN) {
if (adapter->getInputDomain() == Plugin::FrequencyDomain) {
adapter = new PluginInputDomainAdapter(adapter);
}
}
if (adapterFlags & ADAPT_BUFFER_SIZE) {
adapter = new PluginBufferingAdapter(adapter);
}
if (adapterFlags & ADAPT_CHANNEL_COUNT) {
adapter = new PluginChannelAdapter(adapter);
}
return adapter;
}
++index;
}
cerr << "Vamp::HostExt::PluginLoader: Plugin \""
<< identifier << "\" not found in library \""
<< fullPath << "\"" << endl;
return 0;
}
Common::Error ComposerEngine::run() {
Common::Event event;
_vars.resize(1000);
for (uint i = 0; i < _vars.size(); i++)
_vars[i] = 0;
_queuedScripts.resize(10);
for (uint i = 0; i < _queuedScripts.size(); i++) {
_queuedScripts[i]._count = 0;
_queuedScripts[i]._scriptId = 0;
}
if (!_bookIni.loadFromFile("book.ini")) {
_directoriesToStrip = 0;
if (!_bookIni.loadFromFile("programs/book.ini")) {
// mac version?
if (!_bookIni.loadFromFile("Darby the Dragon.ini"))
if (!_bookIni.loadFromFile("Gregory.ini"))
error("failed to find book.ini");
}
}
uint width = 640;
if (_bookIni.hasKey("Width", "Common"))
width = atoi(getStringFromConfig("Common", "Width").c_str());
uint height = 480;
if (_bookIni.hasKey("Height", "Common"))
height = atoi(getStringFromConfig("Common", "Height").c_str());
initGraphics(width, height, true);
_screen.create(width, height, Graphics::PixelFormat::createFormatCLUT8());
Graphics::Cursor *cursor = Graphics::makeDefaultWinCursor();
CursorMan.replaceCursor(cursor->getSurface(), cursor->getWidth(), cursor->getHeight(), cursor->getHotspotX(),
cursor->getHotspotY(), cursor->getKeyColor());
CursorMan.replaceCursorPalette(cursor->getPalette(), cursor->getPaletteStartIndex(), cursor->getPaletteCount());
delete cursor;
_console = new Console(this);
loadLibrary(0);
uint fps = atoi(getStringFromConfig("Common", "FPS").c_str());
uint frameTime = 125; // Default to 125ms (1000/8)
if (fps != 0)
frameTime = 1000 / fps;
else
warning("FPS in book.ini is zero. Defaulting to 8...");
uint32 lastDrawTime = 0;
while (!shouldQuit()) {
for (uint i = 0; i < _pendingPageChanges.size(); i++) {
if (_pendingPageChanges[i]._remove)
unloadLibrary(_pendingPageChanges[i]._pageId);
else
loadLibrary(_pendingPageChanges[i]._pageId);
lastDrawTime = _system->getMillis();
}
_pendingPageChanges.clear();
uint32 thisTime = _system->getMillis();
// maintain our own internal timing, since otherwise we get
// confused when starved of CPU (for example when the user
// is dragging the scummvm window around)
if (thisTime > _lastTime + frameTime)
_currentTime += frameTime;
else
_currentTime += thisTime - _lastTime;
_lastTime = thisTime;
for (uint i = 0; i < _queuedScripts.size(); i++) {
QueuedScript &script = _queuedScripts[i];
if (!script._count)
continue;
if (script._baseTime + script._duration > _currentTime)
continue;
if (script._count != 0xffffffff)
script._count--;
script._baseTime = _currentTime;
runScript(script._scriptId, i, 0, 0);
}
if (lastDrawTime + frameTime <= thisTime) {
// catch up if we're more than 2 frames behind
if (lastDrawTime + (frameTime * 2) <= thisTime)
lastDrawTime = thisTime;
else
lastDrawTime += frameTime;
redraw();
tickOldScripts();
processAnimFrame();
} else if (_needsUpdate) {
redraw();
}
while (_eventMan->pollEvent(event)) {
switch (event.type) {
case Common::EVENT_LBUTTONDOWN:
onMouseDown(event.mouse);
break;
case Common::EVENT_LBUTTONUP:
break;
case Common::EVENT_RBUTTONDOWN:
break;
case Common::EVENT_MOUSEMOVE:
onMouseMove(event.mouse);
break;
case Common::EVENT_KEYDOWN:
switch (event.kbd.keycode) {
case Common::KEYCODE_d:
if (event.kbd.hasFlags(Common::KBD_CTRL)) {
// Start the debugger
getDebugger()->attach();
getDebugger()->onFrame();
}
break;
case Common::KEYCODE_q:
if (event.kbd.hasFlags(Common::KBD_CTRL))
quitGame();
break;
default:
break;
}
onKeyDown(event.kbd.keycode);
break;
default:
break;
}
}
_system->delayMillis(20);
}
_screen.free();
return Common::kNoError;
}
// The main function
int main(int argc, char* argv[])
{
int option_index = 0;
int opt;
char* dbPath = NULL;
char* userPIN = NULL;
char* module = NULL;
char* slot = NULL;
char* serial = NULL;
char* token = NULL;
char *errMsg = NULL;
int noPublicKey = 0;
int result = 0;
CK_RV rv;
moduleHandle = NULL;
p11 = NULL;
CK_SLOT_ID slotID = 0;
if (argc == 1)
{
usage();
exit(0);
}
while ((opt = getopt_long(argc, argv, "hv", long_options, &option_index)) != -1)
{
switch (opt)
{
case OPT_DB:
dbPath = optarg;
break;
case OPT_SLOT:
slot = optarg;
break;
case OPT_SERIAL:
serial = optarg;
break;
case OPT_TOKEN:
token = optarg;
break;
case OPT_MODULE:
module = optarg;
break;
case OPT_NO_PUBLIC_KEY:
noPublicKey = 1;
break;
case OPT_PIN:
userPIN = optarg;
break;
case OPT_VERSION:
case 'v':
printf("%s\n", PACKAGE_VERSION);
exit(0);
break;
case OPT_HELP:
case 'h':
default:
usage();
exit(0);
break;
}
}
// Get a pointer to the function list for PKCS#11 library
CK_C_GetFunctionList pGetFunctionList = loadLibrary(module, &moduleHandle, &errMsg);
if (pGetFunctionList == NULL)
{
fprintf(stderr, "ERROR: Could not load the library: %s\n", errMsg);
exit(1);
}
// Load the function list
(*pGetFunctionList)(&p11);
// Initialize the library
rv = p11->C_Initialize(NULL_PTR);
if (rv != CKR_OK)
{
fprintf(stderr, "ERROR: Could not initialize the library.\n");
exit(1);
}
// Get the slotID
result = findSlot(slot, serial, token, slotID);
if (!result)
{
// Migrate the database
result = migrate(dbPath, slotID, userPIN, noPublicKey);
}
// Finalize the library
p11->C_Finalize(NULL_PTR);
unloadLibrary(moduleHandle);
return result;
}
ADSI::~ADSI()
{
unloadLibrary();
}
void ComposerEngine::loadLibrary(uint id) {
if (getGameType() == GType_ComposerV1 && !_libraries.empty()) {
// kill the previous page, starting with any scripts running on it
for (Common::List<OldScript *>::iterator i = _oldScripts.begin(); i != _oldScripts.end(); i++)
delete *i;
_oldScripts.clear();
Library *library = &_libraries.front();
unloadLibrary(library->_id);
}
Common::String filename;
if (getGameType() == GType_ComposerV1) {
if (!id || _bookGroup.empty())
filename = getStringFromConfig("Common", "StartPage");
else
filename = getStringFromConfig(_bookGroup, Common::String::format("%d", id));
filename = mangleFilename(filename);
// bookGroup is the basename of the path.
// TODO: tidy this up.
_bookGroup.clear();
for (uint i = 0; i < filename.size(); i++) {
if (filename[i] == '~' || filename[i] == '/' || filename[i] == ':')
continue;
for (uint j = 0; j < filename.size(); j++) {
if (filename[j] == '/') {
_bookGroup.clear();
continue;
}
if (filename[j] == '.')
break;
_bookGroup += filename[j];
}
break;
}
} else {
if (!id)
id = atoi(getStringFromConfig("Common", "StartUp").c_str());
filename = getFilename("Libs", id);
}
Library library;
library._id = id;
library._archive = new ComposerArchive();
if (!library._archive->openFile(filename))
error("failed to open '%s'", filename.c_str());
_libraries.push_front(library);
Library &newLib = _libraries.front();
Common::Array<uint16> buttonResources = library._archive->getResourceIDList(ID_BUTN);
for (uint i = 0; i < buttonResources.size(); i++) {
uint16 buttonId = buttonResources[i];
Common::SeekableReadStream *stream = library._archive->getResource(ID_BUTN, buttonId);
Button button(stream, buttonId, getGameType());
bool inserted = false;
for (Common::List<Button>::iterator b = newLib._buttons.begin(); b != newLib._buttons.end(); b++) {
if (button._zorder < b->_zorder)
continue;
newLib._buttons.insert(b, button);
inserted = true;
break;
}
if (!inserted)
newLib._buttons.push_back(button);
}
Common::Array<uint16> ambientResources = library._archive->getResourceIDList(ID_AMBI);
for (uint i = 0; i < ambientResources.size(); i++) {
Common::SeekableReadStream *stream = library._archive->getResource(ID_AMBI, ambientResources[i]);
Button button(stream);
newLib._buttons.insert(newLib._buttons.begin(), button);
}
Common::Array<uint16> accelResources = library._archive->getResourceIDList(ID_ACEL);
for (uint i = 0; i < accelResources.size(); i++) {
Common::SeekableReadStream *stream = library._archive->getResource(ID_ACEL, accelResources[i]);
KeyboardHandler handler;
handler.keyId = stream->readUint16LE();
handler.modifierId = stream->readUint16LE();
handler.scriptId = stream->readUint16LE();
newLib._keyboardHandlers.push_back(handler);
}
Common::Array<uint16> randResources = library._archive->getResourceIDList(ID_RAND);
for (uint i = 0; i < randResources.size(); i++) {
Common::SeekableReadStream *stream = library._archive->getResource(ID_RAND, randResources[i]);
Common::Array<RandomEvent> &events = _randomEvents[randResources[i]];
uint16 count = stream->readUint16LE();
for (uint j = 0; j < count; j++) {
RandomEvent random;
random.scriptId = stream->readUint16LE();
random.weight = stream->readUint16LE();
events.push_back(random);
}
delete stream;
}
// add background sprite, if it exists
if (hasResource(ID_BMAP, 1000))
setBackground(1000);
// TODO: better CTBL logic
loadCTBL(1000, 100);
// Run the startup script.
runScript(1000, 0, 0, 0);
_mouseEnabled = true;
onMouseMove(_lastMousePos);
runEvent(kEventLoad, id, 0, 0);
}
bool ADSI::loadLibrary(const QString &fileName)
{
if(!adsiLibrary) {
adsiLibrary = new QLibrary(this);
}
if(adsiLibrary->isLoaded()) {
m_lastErrorString = "Library '" + fileName + "'already loaded!";
qCritical() << m_lastErrorString;
return false;
}
// adsiLibrary->unload();
adsiLibrary->setFileName(fileName);
adsiLibrary->load();
if(!adsiLibrary->isLoaded()) {
m_lastErrorString = "Failed to load library '" + fileName + "'!" + adsiLibrary->errorString();
qCritical() << m_lastErrorString;
return false;
}
m_AD_Open = (AD_OpenFunction) adsiLibrary->resolve("AD_Open");
if(!m_AD_Open) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_Open' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_Close = (AD_CloseFunction) adsiLibrary->resolve("AD_Close");
if(!m_AD_Close) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_Close' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetLastErrorCode = (AD_GetLastErrorCodeFunction) adsiLibrary->resolve("AD_GetLastErrorCode");
if(!m_AD_GetLastErrorCode) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetLastErrorCode' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetLastErrorString = (AD_GetLastErrorStringFunction) adsiLibrary->resolve("AD_GetLastErrorString");
if(!m_AD_GetLastErrorString) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetLastErrorString' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_DefaultNamingContext = (AD_DefaultNamingContextFunction) adsiLibrary->resolve("AD_DefaultNamingContext");
if(!m_AD_DefaultNamingContext) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_DefaultNamingContext' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_ObjectExists = (AD_ObjectExistsFunction) adsiLibrary->resolve("AD_ObjectExists");
if(!m_AD_ObjectExists) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_ObjectExists' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_RenameObject = (AD_RenameObjectFunction) adsiLibrary->resolve("AD_RenameObject");
if(!m_AD_RenameObject) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_RenameObject' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_MoveObject = (AD_MoveObjectFunction) adsiLibrary->resolve("AD_MoveObject");
if(!m_AD_MoveObject) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_MoveObject' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_DeleteObject = (AD_DeleteObjectFunction) adsiLibrary->resolve("AD_DeleteObject");
if(!m_AD_DeleteObject) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_DeleteObject' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_UnlockObject = (AD_UnlockObjectFunction) adsiLibrary->resolve("AD_UnlockObject");
if(!m_AD_UnlockObject) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_UnlockObject' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_EnableObject = (AD_EnableObjectFunction) adsiLibrary->resolve("AD_EnableObject");
if(!m_AD_EnableObject) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_EnableObject' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_IsObjectDisabled = (AD_IsObjectDisabledFunction) adsiLibrary->resolve("AD_IsObjectDisabled");
if(!m_AD_IsObjectDisabled) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_IsObjectDisabled' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_SetAccountExpire = (AD_SetAccountExpireFunction) adsiLibrary->resolve("AD_SetAccountExpire");
if(!m_AD_SetAccountExpire) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_SetAccountExpire' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_SetPasswordExpire = (AD_SetPasswordExpireFunction) adsiLibrary->resolve("AD_SetPasswordExpire");
if(!m_AD_SetPasswordExpire) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_SetPasswordExpire' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_SetUserCannotChangePassword = (AD_SetUserCannotChangePasswordFunction) adsiLibrary->resolve("AD_SetUserCannotChangePassword");
if(!m_AD_SetUserCannotChangePassword) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_SetUserCannotChangePassword' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetUserCannotChangePassword = (AD_GetUserCannotChangePasswordFunction) adsiLibrary->resolve("AD_GetUserCannotChangePassword");
if(!m_AD_GetUserCannotChangePassword) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetUserCannotChangePassword' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_SetUserPasswordChange = (AD_SetUserPasswordChangeFunction) adsiLibrary->resolve("AD_SetUserPasswordChange");
if(!m_AD_SetUserPasswordChange) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_SetUserPasswordChange' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetUserPasswordChange = (AD_GetUserPasswordChangeFunction) adsiLibrary->resolve("AD_GetUserPasswordChange");
if(!m_AD_GetUserPasswordChange) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetUserPasswordChange' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetObjectAttribute = (AD_GetObjectAttributeFunction) adsiLibrary->resolve("AD_GetObjectAttribute");
if(!m_AD_GetObjectAttribute) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetObjectAttribute' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_ModifyAttribute = (AD_ModifyAttributeFunction) adsiLibrary->resolve("AD_ModifyAttribute");
if(!m_AD_ModifyAttribute) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_ModifyAttribute' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_CreateOU = (AD_CreateOUFunction) adsiLibrary->resolve("AD_CreateOU");
if(!m_AD_CreateOU) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_CreateOU' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetAllOUs = (AD_GetAllOUsFunction) adsiLibrary->resolve("AD_GetAllOUs");
if(!m_AD_GetAllOUs) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetAllOUs' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_GetObjectsInOU = (AD_GetObjectsInOUFunction) adsiLibrary->resolve("AD_GetObjectsInOU");
if(!m_AD_GetObjectsInOU) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_GetObjectsInOU' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_CreateUser = (AD_CreateUserFunction) adsiLibrary->resolve("AD_CreateUser");
if(!m_AD_CreateUser) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_CreateUser' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_AD_SetPassword = (AD_SetPasswordFunction) adsiLibrary->resolve("AD_SetPassword");
if(!m_AD_SetPassword) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'AD_SetPassword' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_ComputerName = (ComputerNameFunction) adsiLibrary->resolve("ComputerName");
if(!m_ComputerName) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'ComputerName' !" ;
qCritical() << m_lastErrorString;
return false;
}
m_UserNameOfCurrentThread = (UserNameOfCurrentThreadFunction) adsiLibrary->resolve("UserNameOfCurrentThread");
if(!m_UserNameOfCurrentThread) {
unloadLibrary();
m_lastErrorString = "Failed to resolve function 'UserNameOfCurrentThread' !" ;
qCritical() << m_lastErrorString;
return false;
}
return true;
}
bool ComponentManager::loadLibrary(const std::string & filePath, bool reload)
{
// Check if library is already loaded and reload is not requested
auto it = m_librariesByFilePath.find(filePath);
if (it != m_librariesByFilePath.cend() && !reload) {
return true;
}
// Load module information file, if present
cpplocate::ModuleInfo modInfo;
modInfo.load(filePath + ".modinfo");
// If library was already loaded, remember it in case reloading fails
PluginLibrary * previous = nullptr;
if (it != m_librariesByFilePath.cend()) {
previous = it->second;
}
// Open plugin library
PluginLibrary * library = new PluginLibrary(filePath);
if (!library->isValid())
{
// Loading failed. Destroy library object and return failure.
cppassist::warning() << (previous ? "Reloading" : "Loading") << " plugin(s) from '" << filePath << "' failed.";
delete library;
return false;
}
// Library has been loaded. Unload previous incarnation.
if (previous) {
unloadLibrary(previous);
}
// Add library to list (in case of reload, this overwrites the previous)
m_librariesByFilePath[filePath] = library;
// Initialize plugin library
library->initialize();
// Iterate over plugins
const unsigned int numComponents = library->numComponents();
for (unsigned int i = 0; i < numComponents; ++i)
{
// Get component
AbstractComponent * component = library->component(i);
if (!component)
continue;
// Set module information
if (!modInfo.empty())
{
component->setModuleInfo(modInfo);
}
// Add component to list
m_components.push_back(component);
// Save component by name
std::string name = component->name();
m_componentsByName[name] = component;
}
// Return success
return true;
}
void
PluginLoader::Impl::enumeratePlugins(PluginKey forPlugin)
{
vector<string> path = PluginHostAdapter::getPluginPath();
string libraryName, identifier;
if (forPlugin != "") {
if (!decomposePluginKey(forPlugin, libraryName, identifier)) {
std::cerr << "WARNING: Vamp::HostExt::PluginLoader: Invalid plugin key \""
<< forPlugin << "\" in enumerate" << std::endl;
return;
}
}
for (size_t i = 0; i < path.size(); ++i) {
vector<string> files = listFiles(path[i], PLUGIN_SUFFIX);
for (vector<string>::iterator fi = files.begin();
fi != files.end(); ++fi) {
if (libraryName != "") {
// libraryName is lowercased and lacking an extension,
// as it came from the plugin key
string temp = *fi;
for (size_t i = 0; i < temp.length(); ++i) {
temp[i] = tolower(temp[i]);
}
string::size_type pi = temp.find('.');
if (pi == string::npos) {
if (libraryName != temp) continue;
} else {
if (libraryName != temp.substr(0, pi)) continue;
}
}
string fullPath = path[i];
fullPath = splicePath(fullPath, *fi);
void *handle = loadLibrary(fullPath);
if (!handle) continue;
VampGetPluginDescriptorFunction fn =
(VampGetPluginDescriptorFunction)lookupInLibrary
(handle, "vampGetPluginDescriptor");
if (!fn) {
unloadLibrary(handle);
continue;
}
int index = 0;
const VampPluginDescriptor *descriptor = 0;
while ((descriptor = fn(VAMP_API_VERSION, index))) {
++index;
if (identifier != "") {
if (descriptor->identifier != identifier) continue;
}
PluginKey key = composePluginKey(*fi, descriptor->identifier);
// std::cerr << "enumerate: " << key << " (path: " << fullPath << ")" << std::endl;
if (m_pluginLibraryNameMap.find(key) ==
m_pluginLibraryNameMap.end()) {
m_pluginLibraryNameMap[key] = fullPath;
}
}
unloadLibrary(handle);
}
}
if (forPlugin == "") m_allPluginsEnumerated = true;
}