static void test_dso_sym(abts_case *tc, void *data)
{
apr_dso_handle_t *h = NULL;
apr_dso_handle_sym_t func1 = NULL;
apr_status_t status;
void (*function)(char str[256]);
char teststr[256];
char errstr[256];
status = apr_dso_load(&h, modname, p);
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, h);
status = apr_dso_sym(&func1, h, "print_hello");
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, func1);
if (!tc->failed) {
function = (void (*)(char *))func1;
(*function)(teststr);
ABTS_STR_EQUAL(tc, "Hello - I'm a DSO!\n", teststr);
}
apr_dso_unload(h);
}
df_plugin
dfLoadPlugin(
df_context handle,
const char* name,
df_plugin_type type,
df_status* status)
{
df_context_t* context;
apr_dso_handle_t* dso;
apr_status_t apr_status;
char apr_errstr[256];
context = DF_STATIC_CAST(df_context_t*, handle);
apr_status = apr_dso_load(&dso, name, context->pool);
if(apr_status != APR_SUCCESS)
{
apr_dso_error(dso, apr_errstr, 256);
dfLogError(handle, DF_INVALID_PLUGIN, "Failed to load plugin: %s", apr_errstr);
return NULL;
}
df_plugin_t* p = dfAllocate(handle, sizeof(df_plugin_t), status);
if(!p)
return NULL;
if(name)
p->name = dfCreateSymbol(handle, name, strlen(name), status);
p->handle = dso;
p->context = handle;
p->type = type;
return (df_plugin)p;
}
static const char *load_file(cmd_parms *cmd, void *dummy, const char *filename)
{
apr_dso_handle_t *handle;
const char *file;
file = ap_server_root_relative(cmd->pool, filename);
if (!file) {
return apr_pstrcat(cmd->pool, "Invalid LoadFile path ",
filename, NULL);
}
if (apr_dso_load(&handle, file, cmd->pool) != APR_SUCCESS) {
char my_error[256];
return apr_pstrcat(cmd->pool, "Cannot load ", filename,
" into server: ",
apr_dso_error(handle, my_error, sizeof(my_error)),
NULL);
}
ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, NULL,
"loaded file %s", filename);
return NULL;
}
APU_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
const apr_dbd_driver_t **driver)
{
#if APR_DSO_BUILD
char path[80];
apr_dso_handle_t *dlhandle = NULL;
#endif
apr_status_t rv;
*driver = apr_hash_get(drivers, name, APR_HASH_KEY_STRING);
if (*driver) {
return APR_SUCCESS;
}
#if APR_DSO_BUILD
#if APR_HAS_THREADS
rv = apr_thread_mutex_lock(mutex);
if (rv != APR_SUCCESS) {
goto unlock;
}
*driver = apr_hash_get(drivers, name, APR_HASH_KEY_STRING);
if (*driver) {
goto unlock;
}
#endif
#ifdef WIN32
sprintf(path, "apr_dbd_%s.dll", name);
#else
sprintf(path, "apr_dbd_%s.so", name);
#endif
rv = apr_dso_load(&dlhandle, path, pool);
if (rv != APR_SUCCESS) { /* APR_EDSOOPEN */
goto unlock;
}
sprintf(path, "apr_dbd_%s_driver", name);
rv = apr_dso_sym((void*)driver, dlhandle, path);
if (rv != APR_SUCCESS) { /* APR_ESYMNOTFOUND */
apr_dso_unload(dlhandle);
goto unlock;
}
if ((*driver)->init) {
(*driver)->init(pool);
}
apr_hash_set(drivers, name, APR_HASH_KEY_STRING, *driver);
unlock:
#if APR_HAS_THREADS
apr_thread_mutex_unlock(mutex);
#endif
#else /* APR_DSO_BUILD - so if it wasn't already loaded, it's NOTIMPL */
rv = APR_ENOTIMPL;
#endif
return rv;
}
static void initialize() {
static bool initialized = false;
if (!initialized) {
apr_dso_handle_t* hprog = 0;
LLAPRPool pool;
pool.create();
#if LL_WINDOWS
apr_dso_load(&hprog, "libtcmalloc_minimal.dll", pool());
#else
apr_dso_load(&hprog, 0, pool());
#endif
apr_dso_sym((apr_dso_handle_sym_t*)&MallocExtension_GetNumericProperty,
hprog, "MallocExtension_GetNumericProperty");
apr_dso_sym((apr_dso_handle_sym_t*)&MallocExtension_GetStats,
hprog, "MallocExtension_GetStats");
initialized = true;
}
}
static void test_load_notthere(CuTest *tc)
{
apr_dso_handle_t *h = NULL;
apr_status_t status;
status = apr_dso_load(&h, "No_File.so", p);
CuAssertIntEquals(tc, 1, APR_STATUS_IS_EDSOOPEN(status));
CuAssertPtrNotNull(tc, h);
}
static void test_load_notthere(abts_case *tc, void *data)
{
apr_dso_handle_t *h = NULL;
apr_status_t status;
status = apr_dso_load(&h, "No_File.so", p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EDSOOPEN(status));
ABTS_PTR_NOTNULL(tc, h);
}
/**
* Dynamically loads the plugin and runs the plugin's init function.
*
* @param[in] plugin_file Name of plugin dll/dylib/so. TODO:DOC is this correct? see .h
* @return 0 if successful, APR error code or error code from the plugin's init function on failure.
*/
int LLPluginInstance::load(const std::string& plugin_dir, std::string &plugin_file)
{
pluginInitFunction init_function = NULL;
if ( plugin_dir.length() )
{
#if LL_WINDOWS
// VWR-21275:
// *SOME* Windows systems fail to load the Qt plugins if the current working
// directory is not the same as the directory with the Qt DLLs in.
// This should not cause any run time issues since we are changing the cwd for the
// plugin shell process and not the viewer.
// Changing back to the previous directory is not necessary since the plugin shell
// quits once the plugin exits.
_chdir( plugin_dir.c_str() );
#endif
};
int result = apr_dso_load(&mDSOHandle,
plugin_file.c_str(),
gAPRPoolp);
if(result != APR_SUCCESS)
{
char buf[1024];
apr_dso_error(mDSOHandle, buf, sizeof(buf));
LL_WARNS("PluginInstance") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
}
if(result == APR_SUCCESS)
{
result = apr_dso_sym((apr_dso_handle_sym_t*)&init_function,
mDSOHandle,
PLUGIN_INIT_FUNCTION_NAME);
if(result != APR_SUCCESS)
{
LL_WARNS("PluginInstance") << "apr_dso_sym failed with error " << result << LL_ENDL;
}
}
if(result == APR_SUCCESS)
{
result = init_function(staticReceiveMessage, (void*)this, &mPluginSendMessageFunction, &mPluginUserData);
if((result != APR_SUCCESS) || (mPluginUserData == NULL))
{
LL_WARNS("PluginInstance") << "call to init function failed with error " << result << LL_ENDL;
}
}
return (int)result;
}
static void test_load_module(abts_case *tc, void *data)
{
apr_dso_handle_t *h = NULL;
apr_status_t status;
char errstr[256];
status = apr_dso_load(&h, modname, p);
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, h);
apr_dso_unload(h);
}
static void test_load_module(CuTest *tc)
{
apr_dso_handle_t *h = NULL;
apr_status_t status;
char errstr[256];
status = apr_dso_load(&h, modname, p);
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
CuAssertPtrNotNull(tc, h);
apr_dso_unload(h);
}
bool grab_pa_syms(std::string pulse_dso_name)
{
if (sSymsGrabbed)
{
// already have grabbed good syms
return true;
}
bool sym_error = false;
bool rtn = false;
apr_status_t rv;
apr_dso_handle_t *sSymPADSOHandle = NULL;
#define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) do{rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll##PASYM, sSymPADSOHandle, #PASYM); if (rv != APR_SUCCESS) {INFOMSG("Failed to grab symbol: %s", #PASYM); if (REQUIRED) sym_error = true;} else DEBUGMSG("grabbed symbol: %s from %p", #PASYM, (void*)ll##PASYM);}while(0)
//attempt to load the shared library
apr_pool_create(&sSymPADSOMemoryPool, NULL);
if ( APR_SUCCESS == (rv = apr_dso_load(&sSymPADSOHandle,
pulse_dso_name.c_str(),
sSymPADSOMemoryPool) ))
{
INFOMSG("Found DSO: %s", pulse_dso_name.c_str());
#include "linux_volume_catcher_pa_syms.inc"
#include "linux_volume_catcher_paglib_syms.inc"
if ( sSymPADSOHandle )
{
sSymPADSOHandleG = sSymPADSOHandle;
sSymPADSOHandle = NULL;
}
rtn = !sym_error;
}
else
{
INFOMSG("Couldn't load DSO: %s", pulse_dso_name.c_str());
rtn = false; // failure
}
if (sym_error)
{
WARNMSG("Failed to find necessary symbols in PulseAudio libraries.");
}
#undef LL_PA_SYM
sSymsGrabbed = rtn;
return rtn;
}
bool grab_dbus_syms(std::string dbus_dso_name)
{
if (sSymsGrabbed)
{
// already have grabbed good syms
return TRUE;
}
bool sym_error = false;
bool rtn = false;
apr_status_t rv;
apr_dso_handle_t *sSymDBUSDSOHandle = NULL;
#define LL_DBUS_SYM(REQUIRED, DBUSSYM, RTN, ...) do{rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll##DBUSSYM, sSymDBUSDSOHandle, #DBUSSYM); if (rv != APR_SUCCESS) {INFOMSG("Failed to grab symbol: %s", #DBUSSYM); if (REQUIRED) sym_error = true;} else DEBUGMSG("grabbed symbol: %s from %p", #DBUSSYM, (void*)ll##DBUSSYM);}while(0)
//attempt to load the shared library
apr_pool_create(&sSymDBUSDSOMemoryPool, NULL);
if ( APR_SUCCESS == (rv = apr_dso_load(&sSymDBUSDSOHandle,
dbus_dso_name.c_str(),
sSymDBUSDSOMemoryPool) ))
{
INFOMSG("Found DSO: %s", dbus_dso_name.c_str());
#include "llappviewerlinux_api_dbus_syms_raw.inc"
if ( sSymDBUSDSOHandle )
{
sSymDBUSDSOHandleG = sSymDBUSDSOHandle;
sSymDBUSDSOHandle = NULL;
}
rtn = !sym_error;
}
else
{
INFOMSG("Couldn't load DSO: %s", dbus_dso_name.c_str());
rtn = false; // failure
}
if (sym_error)
{
WARNMSG("Failed to find necessary symbols in DBUS-GLIB libraries.");
}
#undef LL_DBUS_SYM
sSymsGrabbed = rtn;
return rtn;
}
static svn_error_t *
svn_dso_load_internal(apr_dso_handle_t **dso, const char *fname)
{
*dso = apr_hash_get(dso_cache, fname, APR_HASH_KEY_STRING);
/* First check to see if we've been through this before... We do this
to avoid calling apr_dso_load multiple times for a given library,
which would result in wasting small amounts of memory each time. */
if (*dso == NOT_THERE)
{
*dso = NULL;
return SVN_NO_ERROR;
}
/* If we got nothing back from the cache, try and load the library. */
if (! *dso)
{
apr_status_t status = apr_dso_load(dso, fname, dso_pool);
if (status)
{
#ifdef SVN_DEBUG_DSO
char buf[1024];
fprintf(stderr,
"Dynamic loading of '%s' failed with the following error:\n%s\n",
fname,
apr_dso_error(*dso, buf, 1024));
#endif
*dso = NULL;
/* It wasn't found, so set the special "we didn't find it" value. */
apr_hash_set(dso_cache,
apr_pstrdup(dso_pool, fname),
APR_HASH_KEY_STRING,
NOT_THERE);
return SVN_NO_ERROR;
}
/* Stash the dso so we can use it next time. */
apr_hash_set(dso_cache,
apr_pstrdup(dso_pool, fname),
APR_HASH_KEY_STRING,
*dso);
}
return SVN_NO_ERROR;
}
static void test_unload_library(CuTest *tc)
{
apr_dso_handle_t *h = NULL;
apr_status_t status;
char errstr[256];
apr_dso_handle_sym_t func1 = NULL;
status = apr_dso_load(&h, libname, p);
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
CuAssertPtrNotNull(tc, h);
status = apr_dso_unload(h);
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
status = apr_dso_sym(&func1, h, "print_hello");
CuAssertIntEquals(tc, 1, APR_STATUS_IS_ESYMNOTFOUND(status));
}
static void test_unload_library(abts_case *tc, void *data)
{
apr_dso_handle_t *h = NULL;
apr_status_t status;
char errstr[256];
apr_dso_handle_sym_t func1 = NULL;
status = apr_dso_load(&h, libname, p);
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, h);
status = apr_dso_unload(h);
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
status = apr_dso_sym(&func1, h, "print_hello");
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ESYMNOTFOUND(status));
}
static int
iconv_dlopen(const char *name, const char *symbol, void **hpp, void **dpp, apr_pool_t *ctx)
{
apr_dso_handle_t *handle;
void *data;
/* dlopen */
if (apr_dso_load(&handle, name, ctx) != APR_SUCCESS) {
return EINVAL;
}
/* dlsym */
if ( apr_dso_sym(&data, handle, symbol) == APR_SUCCESS) {
*hpp = handle;
*dpp = data;
return 0;
}
apr_dso_unload(handle);
return EINVAL;
}
/** Load engine plugin */
MRCP_DECLARE(mrcp_engine_t*) mrcp_engine_loader_plugin_load(mrcp_engine_loader_t *loader, const char *path, const char *name)
{
apr_dso_handle_t *plugin = NULL;
mrcp_plugin_creator_f plugin_creator = NULL;
mrcp_engine_t *engine = NULL;
if(!path || !name) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Load Plugin: invalid params");
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Load Plugin [%s] [%s]",path,name);
if(apr_dso_load(&plugin,path,loader->pool) != APR_SUCCESS) {
char derr[512] = "";
apr_dso_error(plugin,derr,sizeof(derr));
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Load DSO: %s", derr);
return NULL;
}
if(plugin_version_load(plugin) != TRUE) {
apr_dso_unload(plugin);
return NULL;
}
plugin_creator = plugin_creator_load(plugin);
if(!plugin_creator) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Entry Point Found for Plugin");
apr_dso_unload(plugin);
return NULL;
}
plugin_logger_load(plugin);
apr_hash_set(loader->plugins,name,APR_HASH_KEY_STRING,plugin);
engine = plugin_creator(loader->pool);
if(!engine) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Create MRCP Engine");
}
return engine;
}
/**
* Dynamically loads the plugin and runs the plugin's init function.
*
* @param[in] plugin_file Name of plugin dll/dylib/so. TODO:DOC is this correct? see .h
* @return 0 if successful, APR error code or error code from the plugin's init function on failure.
*/
int LLPluginInstance::load(std::string &plugin_file)
{
pluginInitFunction init_function = NULL;
int result = apr_dso_load(&mDSOHandle,
plugin_file.c_str(),
gAPRPoolp);
if(result != APR_SUCCESS)
{
char buf[1024];
apr_dso_error(mDSOHandle, buf, sizeof(buf));
LL_WARNS("Plugin") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
}
if(result == APR_SUCCESS)
{
result = apr_dso_sym((apr_dso_handle_sym_t*)&init_function,
mDSOHandle,
PLUGIN_INIT_FUNCTION_NAME);
if(result != APR_SUCCESS)
{
LL_WARNS("Plugin") << "apr_dso_sym failed with error " << result << LL_ENDL;
}
}
if(result == APR_SUCCESS)
{
result = init_function(staticReceiveMessage, (void*)this, &mPluginSendMessageFunction, &mPluginUserData);
if(result != APR_SUCCESS)
{
LL_WARNS("Plugin") << "call to init function failed with error " << result << LL_ENDL;
}
}
return (int)result;
}
static void test_dso_sym_return_value(CuTest *tc)
{
apr_dso_handle_t *h = NULL;
apr_dso_handle_sym_t func1 = NULL;
apr_status_t status;
int (*function)(int);
char errstr[256];
status = apr_dso_load(&h, modname, p);
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
CuAssertPtrNotNull(tc, h);
status = apr_dso_sym(&func1, h, "count_reps");
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
CuAssertPtrNotNull(tc, func1);
function = (int (*)(int))func1;
status = (*function)(5);
CuAssertIntEquals(tc, 5, status);
apr_dso_unload(h);
}
static void test_dso_sym(CuTest *tc)
{
apr_dso_handle_t *h = NULL;
apr_dso_handle_sym_t func1 = NULL;
apr_status_t status;
void (*function)(char str[256]);
char teststr[256];
char errstr[256];
status = apr_dso_load(&h, modname, p);
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
CuAssertPtrNotNull(tc, h);
status = apr_dso_sym(&func1, h, "print_hello");
CuAssert(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
CuAssertPtrNotNull(tc, func1);
function = (void (*)(char *))func1;
(*function)(teststr);
CuAssertStrEquals(tc, "Hello - I'm a DSO!\n", teststr);
apr_dso_unload(h);
}
static void test_dso_sym_return_value(abts_case *tc, void *data)
{
apr_dso_handle_t *h = NULL;
apr_dso_handle_sym_t func1 = NULL;
apr_status_t status;
int (*function)(int);
char errstr[256];
status = apr_dso_load(&h, modname, p);
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, h);
status = apr_dso_sym(&func1, h, "count_reps");
ABTS_ASSERT(tc, apr_dso_error(h, errstr, 256), APR_SUCCESS == status);
ABTS_PTR_NOTNULL(tc, func1);
if (!tc->failed) {
function = (int (*)(int))func1;
status = (*function)(5);
ABTS_INT_EQUAL(tc, 5, status);
}
apr_dso_unload(h);
}
static const char *mod_websocket_conf_handler(cmd_parms *cmd, void *confv, const char *path, const char *name)
{
websocket_config_rec *conf = (websocket_config_rec *) confv;
char *response;
if ((conf != NULL) && (path != NULL) && (name != NULL)) {
apr_dso_handle_t *res_handle = NULL;
apr_dso_handle_sym_t sym;
if (apr_dso_load(&res_handle, ap_server_root_relative(cmd->pool, path), cmd->pool) == APR_SUCCESS) {
if ((apr_dso_sym(&sym, res_handle, name) == APR_SUCCESS) && (sym != NULL)) {
WebSocketPlugin *plugin = ((WS_Init)sym)();
if ((plugin != NULL) &&
(plugin->version == 0) &&
(plugin->size >= sizeof(WebSocketPlugin)) &&
(plugin->on_message != NULL)) { /* Require an on_message handler */
conf->res_handle = res_handle;
conf->plugin = plugin;
apr_pool_cleanup_register(cmd->pool, conf, mod_websocket_cleanup_config, apr_pool_cleanup_null);
response = NULL;
} else {
apr_dso_unload(res_handle);
response = "Invalid response from initialization function";
}
} else {
apr_dso_unload(res_handle);
response = "Could not find initialization function in module";
}
} else {
response = "Could not open WebSocket handler module";
}
} else {
response = "Invalid parameters";
}
return response;
}
/** Register resource engine plugin */
MRCP_DECLARE(apt_bool_t) mrcp_server_plugin_register(mrcp_server_t *server, const char *path, const char *name)
{
apr_dso_handle_t *plugin = NULL;
apr_dso_handle_sym_t func_handle = NULL;
apt_bool_t dso_err = FALSE;
mrcp_plugin_creator_f plugin_creator = NULL;
mrcp_resource_engine_t *engine;
if(!path || !name) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Register Plugin: no name");
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Register Plugin [%s] [%s]",path,name);
if(apr_dso_load(&plugin,path,server->pool) == APR_SUCCESS) {
if(apr_dso_sym(&func_handle,plugin,MRCP_PLUGIN_SYM_NAME) == APR_SUCCESS) {
if(func_handle) {
plugin_creator = (mrcp_plugin_creator_f)(intptr_t)func_handle;
}
}
else {
dso_err = TRUE;
}
}
else {
dso_err = TRUE;
}
if(dso_err == TRUE) {
char derr[512] = "";
apr_dso_error(plugin,derr,sizeof(derr));
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Load DSO Symbol: %s", derr);
apr_dso_unload(plugin);
return FALSE;
}
if(!plugin_creator) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"No Entry Point Found for Plugin");
apr_dso_unload(plugin);
return FALSE;
}
engine = plugin_creator(server->pool);
if(!engine) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Null Resource Engine");
apr_dso_unload(plugin);
return FALSE;
}
if(!mrcp_plugin_version_check(&engine->plugin_version)) {
apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Incompatible Plugin Version [%d.%d.%d] < ["PLUGIN_VERSION_STRING"]",
engine->plugin_version.major,
engine->plugin_version.minor,
engine->plugin_version.patch);
apr_dso_unload(plugin);
return FALSE;
}
mrcp_server_resource_engine_register(server,engine,name);
apr_hash_set(server->plugin_table,name,APR_HASH_KEY_STRING,plugin);
return TRUE;
}
char *load_cpp_module( apr_pool_t *pool, server_rec *server, cpp_server_rec *server_rec, apr_hash_index_t *next)
{
apr_dso_handle_t *sohandle;
apr_dso_handle_sym_t sosymbol;
ApacheServerRec *pServer = new ApacheServerRec(server);
cpp_factory_t *cur_handler;
apr_ssize_t n_len;
const void *n;
void *p;
char *name;
char *path;
apr_hash_this(next, &n, &n_len, &p);
name = apr_pstrndup(pool, (char *)n, n_len);
path = apr_pstrdup(pool, (char *)p);
if ( apr_dso_load(&sohandle, path, pool) != APR_SUCCESS ) {
char my_error[256];
return apr_pstrcat(
pool, "Error Loading CPP SO ", path, " into server: ",
apr_dso_error( sohandle, my_error, sizeof(my_error)),
NULL);
}
/* Log the event */
ap_log_perror( APLOG_MARK, APLOG_DEBUG|APLOG_NOERRNO,
0, pool,
"loaded CPP so: %s", name);
if ( apr_dso_sym ( &sosymbol, sohandle, name) != APR_SUCCESS) {
char my_error[256];
return apr_pstrcat(
pool, "Can't locate cpp_factory_t `",
name, "' in file ", path, ": ",
apr_dso_error(sohandle, my_error, sizeof(my_error)),
NULL);
}
/* symbol should now be ref the factory structure with
* the handler, input, output and protocol filters
*/
cur_handler = (cpp_factory_t *) sosymbol;
ApacheHandler *handler = cur_handler->handler_func ?
cur_handler->handler_func(pServer) : NULL;
ApacheInputFilter *input_filter = cur_handler->input_filter_func ?
cur_handler->input_filter_func(pServer) : NULL;
ApacheOutputFilter *output_filter = cur_handler->output_filter_func ?
cur_handler->output_filter_func(pServer) : NULL;
ApacheProtocol *protocol = cur_handler->protocol_func ?
cur_handler->protocol_func(pServer) : NULL;
if( handler != NULL ) {
apr_hash_set(server_rec->handler_hash,
name, strlen(name), handler);
}
if( input_filter != NULL ) {
apr_hash_set(server_rec->input_filter_hash,
name, strlen(name), input_filter);
apr_pool_cleanup_register(pool, (void *)input_filter, delete_input_filter,
apr_pool_cleanup_null);
}
if( output_filter != NULL ) {
apr_hash_set(server_rec->output_filter_hash,
name, strlen(name), output_filter);
apr_pool_cleanup_register(pool, (void *)output_filter, delete_output_filter,
apr_pool_cleanup_null);
}
if( protocol != NULL ) {
apr_hash_set(server_rec->protocol_hash,
name, strlen(name), protocol);
apr_pool_cleanup_register(pool, (void *)protocol, delete_protocol_handler,
apr_pool_cleanup_null);
}
return NULL;
}
apr_status_t apu_dso_load(apr_dso_handle_t **dlhandleptr,
apr_dso_handle_sym_t *dsoptr,
const char *module,
const char *modsym,
apr_pool_t *pool)
{
apr_dso_handle_t *dlhandle = NULL;
char *pathlist;
char path[APR_PATH_MAX + 1];
apr_array_header_t *paths;
apr_pool_t *global;
apr_status_t rv = APR_EDSOOPEN;
char *eos = NULL;
int i;
*dsoptr = apr_hash_get(dsos, module, APR_HASH_KEY_STRING);
if (*dsoptr) {
return APR_EINIT;
}
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
global = apr_hash_pool_get(dsos);
/* Retrieve our path search list or prepare for a single search */
if ((apr_env_get(&pathlist, APR_DSOPATH, pool) != APR_SUCCESS)
|| (apr_filepath_list_split(&paths, pathlist, pool) != APR_SUCCESS))
paths = apr_array_make(pool, 1, sizeof(char*));
#if defined(APR_DSO_LIBDIR)
/* Always search our prefix path, but on some platforms such as
* win32 this may be left undefined
*/
(*((char **)apr_array_push(paths))) = APR_DSO_LIBDIR;
#endif
for (i = 0; i < paths->nelts; ++i)
{
#if defined(WIN32)
/* Use win32 dso search semantics and attempt to
* load the relative lib on the first pass.
*/
if (!eos) {
eos = path;
--i;
}
else
#endif
{
eos = apr_cpystrn(path, ((char**)paths->elts)[i], sizeof(path));
if ((eos > path) && (eos - path < sizeof(path) - 1))
*(eos++) = '/';
}
apr_cpystrn(eos, module, sizeof(path) - (eos - path));
rv = apr_dso_load(&dlhandle, path, global);
if (dlhandleptr) {
*dlhandleptr = dlhandle;
}
if (rv == APR_SUCCESS) { /* APR_EDSOOPEN */
break;
}
#if defined(APR_DSO_LIBDIR)
else if (i < paths->nelts - 1) {
#else
else { /* No APR_DSO_LIBDIR to skip */
#endif
/* try with apr-APR_MAJOR_VERSION appended */
eos = apr_cpystrn(eos,
"apr-" APR_STRINGIFY(APR_MAJOR_VERSION) "/",
sizeof(path) - (eos - path));
apr_cpystrn(eos, module, sizeof(path) - (eos - path));
rv = apr_dso_load(&dlhandle, path, global);
if (dlhandleptr) {
*dlhandleptr = dlhandle;
}
if (rv == APR_SUCCESS) { /* APR_EDSOOPEN */
break;
}
}
}
if (rv != APR_SUCCESS) /* APR_ESYMNOTFOUND */
return rv;
rv = apr_dso_sym(dsoptr, dlhandle, modsym);
if (rv != APR_SUCCESS) { /* APR_ESYMNOTFOUND */
apr_dso_unload(dlhandle);
}
else {
module = apr_pstrdup(global, module);
apr_hash_set(dsos, module, APR_HASH_KEY_STRING, *dsoptr);
}
return rv;
}
static const char *load_module(cmd_parms *cmd, void *dummy,
const char *modname, const char *filename)
{
apr_dso_handle_t *modhandle;
apr_dso_handle_sym_t modsym;
module *modp;
const char *szModuleFile = ap_server_root_relative(cmd->pool, filename);
so_server_conf *sconf;
ap_module_symbol_t *modi;
ap_module_symbol_t *modie;
int i;
const char *error;
/* we need to setup this value for dummy to make sure that we don't try
* to add a non-existant tree into the build when we return to
* execute_now.
*/
*(ap_directive_t **)dummy = NULL;
if (!szModuleFile) {
return apr_pstrcat(cmd->pool, "Invalid LoadModule path ",
filename, NULL);
}
/*
* check for already existing module
* If it already exists, we have nothing to do
* Check both dynamically-loaded modules and statically-linked modules.
*/
sconf = (so_server_conf *)ap_get_module_config(cmd->server->module_config,
&so_module);
modie = (ap_module_symbol_t *)sconf->loaded_modules->elts;
for (i = 0; i < sconf->loaded_modules->nelts; i++) {
modi = &modie[i];
if (modi->name != NULL && strcmp(modi->name, modname) == 0) {
ap_log_perror(APLOG_MARK, APLOG_WARNING, 0,
cmd->pool, "module %s is already loaded, skipping",
modname);
return NULL;
}
}
for (i = 0; ap_preloaded_modules[i]; i++) {
const char *preload_name;
apr_size_t preload_len;
apr_size_t thismod_len;
modp = ap_preloaded_modules[i];
/* make sure we're comparing apples with apples
* make sure name of preloaded module is mod_FOO.c
* make sure name of structure being loaded is FOO_module
*/
if (memcmp(modp->name, "mod_", 4)) {
continue;
}
preload_name = modp->name + strlen("mod_");
preload_len = strlen(preload_name) - 2;
if (strlen(modname) <= strlen("_module")) {
continue;
}
thismod_len = strlen(modname) - strlen("_module");
if (strcmp(modname + thismod_len, "_module")) {
continue;
}
if (thismod_len != preload_len) {
continue;
}
if (!memcmp(modname, preload_name, preload_len)) {
return apr_pstrcat(cmd->pool, "module ", modname,
" is built-in and can't be loaded",
NULL);
}
}
modi = apr_array_push(sconf->loaded_modules);
modi->name = modname;
/*
* Load the file into the Apache address space
*/
if (apr_dso_load(&modhandle, szModuleFile, cmd->pool) != APR_SUCCESS) {
char my_error[256];
return apr_pstrcat(cmd->pool, "Cannot load ", szModuleFile,
" into server: ",
apr_dso_error(modhandle, my_error, sizeof(my_error)),
NULL);
}
ap_log_perror(APLOG_MARK, APLOG_DEBUG, 0, cmd->pool,
"loaded module %s", modname);
/*
* Retrieve the pointer to the module structure through the module name:
* First with the hidden variant (prefix `AP_') and then with the plain
* symbol name.
*/
if (apr_dso_sym(&modsym, modhandle, modname) != APR_SUCCESS) {
char my_error[256];
return apr_pstrcat(cmd->pool, "Can't locate API module structure `",
modname, "' in file ", szModuleFile, ": ",
apr_dso_error(modhandle, my_error, sizeof(my_error)),
NULL);
}
modp = (module*) modsym;
modp->dynamic_load_handle = (apr_dso_handle_t *)modhandle;
modi->modp = modp;
/*
* Make sure the found module structure is really a module structure
*
*/
if (modp->magic != MODULE_MAGIC_COOKIE) {
return apr_pstrcat(cmd->pool, "API module structure `", modname,
"' in file ", szModuleFile, " is garbled -"
" perhaps this is not an Apache module DSO?", NULL);
}
/*
* Add this module to the Apache core structures
*/
error = ap_add_loaded_module(modp, cmd->pool);
if (error) {
return error;
}
/*
* Register a cleanup in the config apr_pool_t (normally pconf). When
* we do a restart (or shutdown) this cleanup will cause the
* shared object to be unloaded.
*/
apr_pool_cleanup_register(cmd->pool, modi, unload_module, apr_pool_cleanup_null);
/*
* Finally we need to run the configuration process for the module
*/
ap_single_module_configure(cmd->pool, cmd->server, modp);
return NULL;
}
/*
* Initialise a HOTP authentication stack.
*
*/
dynalogin_result_t dynalogin_init(dynalogin_session_t **session,
apr_pool_t *pool, apr_hash_t *config)
{
apr_status_t ret;
dynalogin_session_t *h;
char *ds_module_name;
char *ds_module_filename;
char *ds_sym_name;
*session = NULL;
if(oath_init() != OATH_OK)
{
ERRMSG("libhotp init failed");
return DYNALOGIN_ERROR;
}
if(pool == NULL)
{
return DYNALOGIN_ERROR;
}
/* pool is not required, APR will create a root pool if it
* is NULL.
* Maybe we don't need a config and can run on defaults? */
if(config == NULL)
{
ERRMSG("no config");
return DYNALOGIN_ERROR;
}
if((h = (dynalogin_session_t *)apr_pcalloc(pool, sizeof(dynalogin_session_t)))
== NULL)
return DYNALOGIN_ERROR;
h->pool = pool;
syslog(LOG_DEBUG, "looking in %s for modules", PKGLIBDIR);
GET_STRING_PARAM(ds_module_name, config, DYNALOGIN_PARAM_DSNAME)
ds_module_filename = apr_psprintf(h->pool, "%s%c%s.so",
PKGLIBDIR, DIR_SEPARATOR, ds_module_name);
ds_sym_name = apr_psprintf(h->pool, "%s_module", ds_module_name);
if(ds_module_filename==NULL || ds_sym_name==NULL)
return DYNALOGIN_ERROR;
if(apr_dso_load(&h->dso_handle,
ds_module_filename, h->pool)!=APR_SUCCESS)
return DYNALOGIN_ERROR;
if(apr_dso_sym((apr_dso_handle_sym_t *)&(h->datasource), h->dso_handle, ds_sym_name)
!=APR_SUCCESS)
{
apr_dso_unload(h->dso_handle);
return DYNALOGIN_ERROR;
}
if(h->datasource->init != NULL)
if(h->datasource->init(h->pool, config) != DYNALOGIN_SUCCESS)
{
apr_dso_unload(h->dso_handle);
return DYNALOGIN_ERROR;
}
GET_INT_PARAM_DEF(h->hotp_digits, config, DYNALOGIN_PARAM_HOTP_DIGITS, DEFAULT_HOTP_DIGITS)
GET_INT_PARAM_DEF(h->hotp_window, config, DYNALOGIN_PARAM_HOTP_WINDOW, DEFAULT_HOTP_WINDOW)
GET_INT_PARAM_DEF(h->totp_digits, config, DYNALOGIN_PARAM_TOTP_DIGITS, DEFAULT_TOTP_DIGITS)
GET_INT_PARAM_DEF(h->totp_window, config, DYNALOGIN_PARAM_TOTP_WINDOW, DEFAULT_TOTP_WINDOW)
GET_INT_PARAM_DEF(h->totp_x, config, DYNALOGIN_PARAM_TOTP_X, DEFAULT_TOTP_X)
GET_INT_PARAM_DEF(h->totp_t0, config, DYNALOGIN_PARAM_TOTP_T0, DEFAULT_TOTP_T0)
*session = h;
return DYNALOGIN_SUCCESS;
}
bool grab_gst_syms(std::string gst_dso_name,
std::string gst_dso_name_vid)
{
if (sSymsGrabbed)
{
// already have grabbed good syms
return TRUE;
}
bool sym_error = false;
bool rtn = false;
apr_status_t rv;
apr_dso_handle_t *sSymGSTDSOHandle = NULL;
#define LL_GST_SYM(REQ, GSTSYM, RTN, ...) do{rv = apr_dso_sym((apr_dso_handle_sym_t*)&ll##GSTSYM, sSymGSTDSOHandle, #GSTSYM); if (rv != APR_SUCCESS) {INFOMSG("Failed to grab symbol: %s", #GSTSYM); if (REQ) sym_error = true;} else DEBUGMSG("grabbed symbol: %s from %p", #GSTSYM, (void*)ll##GSTSYM);}while(0)
//attempt to load the shared libraries
apr_pool_create(&sSymGSTDSOMemoryPool, NULL);
if ( APR_SUCCESS == (rv = apr_dso_load(&sSymGSTDSOHandle,
gst_dso_name.c_str(),
sSymGSTDSOMemoryPool) ))
{
INFOMSG("Found DSO: %s", gst_dso_name.c_str());
#include "llmediaimplgstreamer_syms_raw.inc"
if ( sSymGSTDSOHandle )
{
sSymGSTDSOHandleG = sSymGSTDSOHandle;
sSymGSTDSOHandle = NULL;
}
if ( APR_SUCCESS ==
(rv = apr_dso_load(&sSymGSTDSOHandle,
gst_dso_name_vid.c_str(),
sSymGSTDSOMemoryPool) ))
{
INFOMSG("Found DSO: %s", gst_dso_name_vid.c_str());
#include "llmediaimplgstreamer_syms_rawv.inc"
rtn = !sym_error;
}
else
{
INFOMSG("Couldn't load DSO: %s", gst_dso_name_vid.c_str());
rtn = false; // failure
}
}
else
{
INFOMSG("Couldn't load DSO: %s", gst_dso_name.c_str());
rtn = false; // failure
}
if (sym_error)
{
WARNMSG("Failed to find necessary symbols in GStreamer libraries.");
}
if ( sSymGSTDSOHandle )
{
sSymGSTDSOHandleV = sSymGSTDSOHandle;
sSymGSTDSOHandle = NULL;
}
#undef LL_GST_SYM
sSymsGrabbed = !!rtn;
return rtn;
}
SWITCH_DECLARE(switch_status_t) switch_dso_load(switch_dso_handle_t ** res_handle, const char *path, switch_memory_pool_t *ctx)
{
return apr_dso_load(res_handle, path, ctx);
}
/**
* Dynamically loads the plugin and runs the plugin's init function.
*
* @param[in] plugin_file Name of plugin dll/dylib/so. TODO:DOC is this correct? see .h
* @return 0 if successful, APR error code or error code from the plugin's init function on failure.
*/
int LLPluginInstance::load(const std::string& plugin_dir, std::string &plugin_file)
{
pluginInitFunction init_function = NULL;
if ( plugin_dir.length() )
{
#if LL_WINDOWS
// VWR-21275:
// *SOME* Windows systems fail to load the Qt plugins if the current working
// directory is not the same as the directory with the Qt DLLs in.
// This should not cause any run time issues since we are changing the cwd for the
// plugin shell process and not the viewer.
// Changing back to the previous directory is not necessary since the plugin shell
// quits once the plugin exits.
_chdir( plugin_dir.c_str() );
#endif
};
#if LL_LINUX && defined(LL_STANDALONE)
void *dso_handle = dlopen(plugin_file.c_str(), RTLD_NOW | RTLD_GLOBAL);
int result = (!dso_handle)?APR_EDSOOPEN:apr_os_dso_handle_put(&mDSOHandle,
dso_handle, LLAPRRootPool::get()());
#else
int result = apr_dso_load(&mDSOHandle,
plugin_file.c_str(),
LLAPRRootPool::get()());
#endif
if(result != APR_SUCCESS)
{
char buf[1024];
#if LL_LINUX && defined(LL_STANDALONE)
if (!dso_handle)
{
char* error = dlerror();
buf[0] = 0;
if (error)
{
strncpy(buf, error, sizeof(buf));
}
buf[sizeof(buf) - 1] = 0;
}
else
#endif
{
apr_dso_error(mDSOHandle, buf, sizeof(buf));
}
#if LL_LINUX && defined(LL_STANDALONE)
LL_WARNS("Plugin") << "plugin load " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
#else
LL_WARNS("Plugin") << "apr_dso_load of " << plugin_file << " failed with error " << result << " , additional info string: " << buf << LL_ENDL;
#endif
}
if(result == APR_SUCCESS)
{
result = apr_dso_sym((apr_dso_handle_sym_t*)&init_function,
mDSOHandle,
PLUGIN_INIT_FUNCTION_NAME);
if(result != APR_SUCCESS)
{
LL_WARNS("Plugin") << "apr_dso_sym failed with error " << result << LL_ENDL;
}
}
if(result == APR_SUCCESS)
{
result = init_function(&LLPluginInstance::staticReceiveMessage, this, &mReceiveMessageFunction, &mPluginObject);
if(result != 0)
{
LL_WARNS("Plugin") << "call to init function failed with error " << result << LL_ENDL;
}
}
return (int)result;
}