void ungrab_gst_syms()
{
// should be safe to call regardless of whether we've
// actually grabbed syms.
if ( sSymGSTDSOHandleG )
{
apr_dso_unload(sSymGSTDSOHandleG);
sSymGSTDSOHandleG = NULL;
}
if ( sSymGSTDSOHandleV )
{
apr_dso_unload(sSymGSTDSOHandleV);
sSymGSTDSOHandleV = NULL;
}
if ( sSymGSTDSOMemoryPool )
{
apr_pool_destroy(sSymGSTDSOMemoryPool);
sSymGSTDSOMemoryPool = NULL;
}
// NULL-out all of the symbols we'd grabbed
#define LL_GST_SYM(REQ, GSTSYM, RTN, ...) do{ll##GSTSYM = NULL;}while(0)
#include "llmediaimplgstreamer_syms_raw.inc"
#include "llmediaimplgstreamer_syms_rawv.inc"
#undef LL_GST_SYM
sSymsGrabbed = false;
}
apr_iconv_mod_load(const char *modname, int modtype, const void *args,
struct iconv_module **modpp, apr_pool_t *ctx)
{
struct iconv_module_desc *mdesc;
struct iconv_module *mod, *depmod;
const struct iconv_module_depend *depend;
char buffer[APR_PATH_MAX];
void *handle;
int error;
if (iconv_getpath(buffer, modname, ctx) != 0)
return EINVAL;
error = iconv_dlopen(buffer, "iconv_module", &handle, (void**)&mdesc, ctx);
if (error)
return error;
if (modtype != ICMOD_ANY && mdesc->imd_type != modtype) {
apr_dso_unload(handle);
return APR_EFTYPE;
}
mod = malloc(sizeof(*mod));
if (mod == NULL) {
apr_dso_unload(handle);
return ENOMEM;
}
memset(mod, 0, sizeof(*mod));
mod->im_handle = handle;
mod->im_desc = mdesc;
mod->im_args = args;
depend = mdesc->imd_depend;
if (depend) {
while (depend->md_name) {
error = apr_iconv_mod_load(depend->md_name,
depend->md_type, NULL, &depmod, ctx);
if (error)
goto bad;
depmod->im_depdata = depend->md_data;
depmod->im_next = mod->im_deplist;
mod->im_deplist = depmod;
depend++;
}
}
error = ICONV_MOD_DYN_LOAD(mod,ctx);
if (error)
goto bad;
depmod = mod->im_deplist;
while (depmod) {
mod->im_depcnt++;
depmod = depmod->im_next;
}
error = ICONV_MOD_LOAD(mod,ctx);
if (error)
goto bad;
mod->im_flags |= ICMODF_LOADED;
*modpp = mod;
return 0;
bad:
apr_iconv_mod_unload(mod,ctx);
return error;
}
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);
}
void ungrab_pa_syms()
{
// should be safe to call regardless of whether we've
// actually grabbed syms.
if ( sSymPADSOHandleG )
{
apr_dso_unload(sSymPADSOHandleG);
sSymPADSOHandleG = NULL;
}
if ( sSymPADSOMemoryPool )
{
apr_pool_destroy(sSymPADSOMemoryPool);
sSymPADSOMemoryPool = NULL;
}
// NULL-out all of the symbols we'd grabbed
#define LL_PA_SYM(REQUIRED, PASYM, RTN, ...) do{ll##PASYM = NULL;}while(0)
#include "linux_volume_catcher_pa_syms.inc"
#include "linux_volume_catcher_paglib_syms.inc"
#undef LL_PA_SYM
sSymsGrabbed = false;
}
static void mrcp_server_on_terminate_complete(apt_task_t *task)
{
apt_consumer_task_t *consumer_task = apt_task_object_get(task);
mrcp_server_t *server = apt_consumer_task_object_get(consumer_task);
mrcp_resource_engine_t *resource_engine;
apr_dso_handle_t *plugin;
apr_hash_index_t *it;
void *val;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Close Resource Engines");
it=apr_hash_first(server->pool,server->resource_engine_table);
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
resource_engine = val;
if(resource_engine) {
mrcp_resource_engine_close(resource_engine);
}
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unload Plugins");
it=apr_hash_first(server->pool,server->plugin_table);
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
plugin = val;
if(plugin) {
apr_dso_unload(plugin);
}
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"On Server Task Terminate");
}
/**
* Destructor.
*/
LLPluginInstance::~LLPluginInstance()
{
if(mDSOHandle != NULL)
{
apr_dso_unload(mDSOHandle);
mDSOHandle = 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;
}
void dynalogin_done(dynalogin_session_t *h)
{
if(h==NULL)
return;
if(h->datasource->done != NULL)
h->datasource->done();
apr_dso_unload(h->dso_handle);
oath_done();
}
/** 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;
}
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);
}
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 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;
}
/** Unload loaded plugins */
MRCP_DECLARE(apt_bool_t) mrcp_engine_loader_plugins_unload(mrcp_engine_loader_t *loader)
{
apr_hash_index_t *it;
void *val;
apr_dso_handle_t *plugin;
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unload Plugins");
it=apr_hash_first(loader->pool,loader->plugins);
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
plugin = val;
if(plugin) {
apr_dso_unload(plugin);
}
}
apr_hash_clear(loader->plugins);
return TRUE;
}
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 apr_status_t mod_websocket_cleanup_config(void *data)
{
if (data != NULL) {
websocket_config_rec *conf = (websocket_config_rec *) data;
if (conf != NULL) {
if ((conf->plugin != NULL) && (conf->plugin->destroy != NULL)) {
conf->plugin->destroy(conf->plugin);
}
conf->plugin = NULL;
if (conf->res_handle != NULL) {
apr_dso_unload(conf->res_handle);
conf->res_handle = NULL;
}
}
}
return APR_SUCCESS;
}
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;
}
void ungrab_dbus_syms()
{
// should be safe to call regardless of whether we've
// actually grabbed syms.
if ( sSymDBUSDSOHandleG )
{
apr_dso_unload(sSymDBUSDSOHandleG);
sSymDBUSDSOHandleG = NULL;
}
sSymDBUSDSOMemoryPool.destroy();
// NULL-out all of the symbols we'd grabbed
#define LL_DBUS_SYM(REQUIRED, DBUSSYM, RTN, ...) do{ll##DBUSSYM = NULL;}while(0)
#include "llappviewerlinux_api_dbus_syms_raw.inc"
#undef LL_DBUS_SYM
sSymsGrabbed = false;
}
df_status
dfUnloadPlugin(
df_plugin handle)
{
apr_status_t apr_status;
char apr_errstr[256];
df_plugin_t* p = (df_plugin_t*)handle;
if(!p) return DF_INVALID_PLUGIN;
apr_status = apr_dso_unload(p->handle);
if(apr_status != APR_SUCCESS)
{
apr_dso_error(p->handle, apr_errstr, 256);
dfLogError(p->context, DF_INVALID_PLUGIN, "Failed to load plugin: %s", apr_errstr);
return DF_INVALID_PLUGIN;
}
return DF_SUCCESS;
}
apr_iconv_mod_unload(struct iconv_module *mod, apr_pool_t *ctx)
{
struct iconv_module *deplist, *tmp;
int error = 0;
if (mod == NULL)
return -1;
if (mod->im_flags & ICMODF_LOADED)
error = ICONV_MOD_UNLOAD(mod,ctx);
error = ICONV_MOD_DYN_UNLOAD(mod,ctx);
deplist = mod->im_deplist;
while (deplist) {
tmp = deplist->im_next;
apr_iconv_mod_unload(deplist,ctx);
deplist = tmp;
}
if (mod->im_handle != NULL)
if (apr_dso_unload(mod->im_handle) != APR_SUCCESS)
error = APR_EINVAL;
free(mod);
return error;
}
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);
}
void Shlib::unload() {
CHECK_APR_SUCCESS(
apr_dso_unload(static_cast<apr_dso_handle_t*>(handle)));
}
/** 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;
}
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;
}
/*
* 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;
}
SWITCH_DECLARE(switch_status_t) switch_dso_unload(switch_dso_handle_t *handle)
{
return apr_dso_unload(handle);
}
