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; }