/*
* Initialize the repository
*/
int mca_base_component_repository_init(void)
{
/* Setup internal structures */
if (!initialized) {
#if OPAL_WANT_LIBLTDL
/* Initialize libltdl */
if (lt_dlinit() != 0) {
return OPAL_ERR_OUT_OF_RESOURCE;
}
#if OPAL_HAVE_LTDL_ADVISE
if (lt_dladvise_init(&opal_mca_dladvise)) {
return OPAL_ERR_OUT_OF_RESOURCE;
}
if (lt_dladvise_ext(&opal_mca_dladvise)) {
return OPAL_ERROR;
}
if (lt_dladvise_global(&opal_mca_dladvise)) {
return OPAL_ERROR;
}
#endif
OBJ_CONSTRUCT(&repository, opal_list_t);
#endif
initialized = true;
}
/* All done */
return OPAL_SUCCESS;
}
void
DynamicLoaderModule::init( SLIInterpreter* i )
{
// bind functions to terminal names
i->createcommand( "Install", &loadmodule_function );
// initialize ltdl library for loading dynamic modules
int dl_error = lt_dlinit();
if ( !dl_error )
{
const char* path = getenv( "SLI_MODULE_PATH" );
if ( path != NULL )
{
i->message( SLIInterpreter::M_INFO, "DynamicLoaderModule::init", "Setting module path to" );
i->message( SLIInterpreter::M_INFO, "DynamicLoaderModule::init", path );
dl_error = lt_dlsetsearchpath( path );
if ( dl_error )
i->message( SLIInterpreter::M_ERROR,
"DynamicLoaderModule::init",
"Could not set dynamic module path." );
}
}
else
{
i->message( SLIInterpreter::M_ERROR,
"DynamicLoaderModule::init",
"Could not initialize libltdl. No dynamic modules will be avaiable." );
}
}
/**
* oh_init_ltdl
*
* Does all the initialization needed for the ltdl process to
* work. It takes no arguments, and returns 0 on success, < 0 on error
*
* Returns: 0 on Success.
**/
static int oh_init_ltdl(void)
{
struct oh_global_param path_param = { .type = OPENHPI_PATH };
int err;
static int init_done = 0;
data_access_lock();
if (init_done) {
data_access_unlock();
return 0;
}
err = lt_dlinit();
if (err != 0) {
dbg("Can not init ltdl");
data_access_unlock();
return -1;
}
oh_get_global_param(&path_param);
err = lt_dlsetsearchpath(path_param.u.path);
if (err != 0) {
dbg("Can not set lt_dl search path");
oh_exit_ltdl();
data_access_unlock();
return -1;
}
init_done = 1;
data_access_unlock();
return 0;
}
static void
sysdep_dynl_init ()
{
char *env;
lt_dlinit ();
/* Initialize 'system_extensions_path' from
$GUILE_SYSTEM_EXTENSIONS_PATH, or if that's not set:
<SCM_LIB_DIR> <LT_PATHSEP_CHAR> <SCM_EXTENSIONS_DIR>.
'lt_dladdsearchdir' can't be used because it is searched before
the system-dependent search path, which is the one 'libtool
--mode=execute -dlopen' fiddles with (info "(libtool) Libltdl
Interface"). See
<http://lists.gnu.org/archive/html/guile-devel/2010-11/msg00095.html>.
The environment variables $LTDL_LIBRARY_PATH and $LD_LIBRARY_PATH
can't be used because they would be propagated to subprocesses
which may cause problems for other programs. See
<http://lists.gnu.org/archive/html/guile-devel/2012-09/msg00037.html> */
env = getenv ("GUILE_SYSTEM_EXTENSIONS_PATH");
if (env)
system_extensions_path = env;
else
{
system_extensions_path
= scm_gc_malloc_pointerless (strlen (SCM_LIB_DIR)
+ strlen (SCM_EXTENSIONS_DIR) + 2,
"system_extensions_path");
sprintf (system_extensions_path, "%s%c%s",
SCM_LIB_DIR, LT_PATHSEP_CHAR, SCM_EXTENSIONS_DIR);
}
}
/*
* (Try to) load the shared object `file'. Won't complain if it isn't a shared
* object, but it will bitch about a shared object not having a
* ``module_register'' symbol..
*/
static int plugin_load_file (char *file)
{
lt_dlhandle dlh;
void (*reg_handle) (void);
DEBUG ("file = %s", file);
lt_dlinit ();
lt_dlerror (); /* clear errors */
if ((dlh = lt_dlopen (file)) == NULL)
{
const char *error = lt_dlerror ();
ERROR ("lt_dlopen (%s) failed: %s", file, error);
fprintf (stderr, "lt_dlopen (%s) failed: %s\n", file, error);
return (1);
}
if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL)
{
WARNING ("Couldn't find symbol `module_register' in `%s': %s\n",
file, lt_dlerror ());
lt_dlclose (dlh);
return (-1);
}
(*reg_handle) ();
return (0);
}
void PluginManager::start(){
Logger* log = Logger::getLogger();
std::string list = Settings::getSettings()->get("autoload_plugins");
size_t pos_c = 0;
size_t pos_e;
if(list.length() > 0){
while(pos_c != list.npos){
pos_e = list.find(",", pos_c);
load(list.substr(pos_c, pos_e));
pos_c = pos_e;
}
}else{
log->info("No automatically loaded plugins were defined in the "
"configuation, add \"autoload_plugins = <comma list of plugins>\" to conf "
"to have them loaded.");
}
/* Initalise the ltdl module. */
LTDL_SET_PRELOADED_SYMBOLS();
if(lt_dlinit() != 0){
// FIXME: Should raise an error here.!
log->error("Failed to load initalise the loader %s", lt_dlerror());
stop();
}
/* Need to load ourselves before we can load other modules. */
lt_dlhandle nlib = lt_dlopen(NULL);
if(nlib == NULL){
log->error("Failed to load ourselves because %s.", lt_dlerror());
stop();
}
}
int
radiusd_add_load_path(const char *path)
{
if (lt_dlinit())
return 1;
return lt_dladdsearchdir(path);
}
int init_module_loading()
{
int ret;
static int initialised=0;
if (initialised){
LOG(L_CRIT, "BUG: init_module_loading: already intialised\n");
return -1;
}
/* make sure preloaded modules are initialised */
/*LTDL_SET_PRELOADED_SYMBOLS();*/
ret=lt_dlinit();
if (ret){
LOG(L_CRIT, "ERROR: init_module_loading: lt_dlinit failed: %s\n",
lt_dlerror());
goto error;
}
ret=lt_dlsetsearchpath(MODULE_SEARCH_PATH);
if (ret){
LOG(L_CRIT, "ERROR: init_module_loading: lt_dlsetsearchpath "
"failed: %s\n",
lt_dlerror());
goto error;
}
initialised++;
return ret;
error:
lt_dlexit();
return -1;
}
int
radiusd_set_load_path(const char *path)
{
if (lt_dlinit())
return 1;
return lt_dlsetsearchpath(path);
}
/**
* librdf_new_world:
*
* Create a new Redland execution environment.
*
* Once this constructor is called to build a #librdf_world object
* several functions may be called to set some parameters such as
* librdf_world_set_error(), librdf_world_set_warning(),
* librdf_world_set_logger(), librdf_world_set_digest(),
* librdf_world_set_feature().
*
* The world object needs initializing using librdf_world_open()
* whether or not the above functions are called. It will be
* automatically called by all object constructors in Redland 1.0.6
* or later, but for earlier versions it MUST be called before using
* any other part of Redland.
*
* Returns: a new #librdf_world or NULL on failure
*/
librdf_world*
librdf_new_world(void)
{
librdf_world *world;
#ifdef HAVE_GETTIMEOFDAY
struct timeval tv;
struct timezone tz;
#endif
world = (librdf_world*)LIBRDF_CALLOC(librdf_world, sizeof(*world), 1);
if(!world)
return NULL;
#ifdef HAVE_GETTIMEOFDAY
if(!gettimeofday(&tv, &tz)) {
world->genid_base = tv.tv_sec;
} else
world->genid_base = 1;
#else
world->genid_base = 1;
#endif
world->genid_counter = 1;
#ifdef MODULAR_LIBRDF
world->ltdl_opened = !(lt_dlinit());
if (world->ltdl_opened)
lt_dlsetsearchpath(REDLAND_MODULE_PATH);
else
LIBRDF_DEBUG1("lt_dlinit() failed\n");
#endif
return world;
}
void loadmod(void) {
int (*lse_mod_test)(void) ;
char * modname = cstring(0,0);
lt_dlhandle modp;
// Initialize libtool
lt_dlinit();
// Add local modules to search path
lt_dladdsearchdir("./modules/");
#ifdef PKGLIBDIR
// Add global modules to search path
lt_dladdsearchdir(PKGLIBDIR);
#endif
// try to load the module
modp = lt_dlopenext(modname);
// If we fail, set the flag to 0 and exit
flag = 0;
if ( ! modp ) return;
// Else make sure the module is sane
if ( !(lse_mod_test = (int (*)(void)) lt_dlsym(modp, "lse_mod_test")) ) return;
// If all is well, then the test value
// should return 1, so se the flag to this and
flag = lse_mod_test();
}
/*
* Load a module - this will load the shared object, call
* C_Initialize, and get the list of function pointers
*/
void *
C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs)
{
sc_pkcs11_module_t *mod;
CK_RV rv, (*c_get_function_list)(CK_FUNCTION_LIST_PTR_PTR);
#ifdef HAVE_LTDL_H
lt_dlinit();
#endif
mod = calloc(1, sizeof(*mod));
mod->_magic = MAGIC;
if (mspec == NULL)
return NULL;
mod->handle = sc_dlopen(mspec);
if (mod->handle == NULL) {
fprintf(stderr, "sc_dlopen failed: %s\n", sc_dlerror());
goto failed;
}
/* Get the list of function pointers */
c_get_function_list = (CK_RV (*)(CK_FUNCTION_LIST_PTR_PTR))
sc_dlsym(mod->handle, "C_GetFunctionList");
if (!c_get_function_list)
goto failed;
rv = c_get_function_list(funcs);
if (rv == CKR_OK)
return (void *) mod;
else
fprintf(stderr, "C_GetFunctionList failed %lx", rv);
failed:
C_UnloadModule((void *) mod);
return NULL;
}
/*
* Load a module - this will load the shared object, call
* C_Initialize, and get the list of function pointers
*/
void *
C_LoadModule(const char *mspec, CK_FUNCTION_LIST_PTR_PTR funcs)
{
sc_pkcs11_module_t *mod;
CK_RV (*c_get_function_list)(CK_FUNCTION_LIST_PTR_PTR);
int rv;
lt_dlinit();
mod = (sc_pkcs11_module_t *) calloc(1, sizeof(*mod));
mod->_magic = MAGIC;
if (mspec == NULL)
mspec = PKCS11_DEFAULT_MODULE_NAME;
mod->handle = lt_dlopen(mspec);
if (mod->handle == NULL) {
#if 0
fprintf(stderr, "lt_dlopen failed: %s\n", lt_dlerror());
#endif
goto failed;
}
/* Get the list of function pointers */
c_get_function_list = (CK_RV (*)(CK_FUNCTION_LIST_PTR_PTR))
lt_dlsym(mod->handle, "C_GetFunctionList");
if (!c_get_function_list)
goto failed;
rv = c_get_function_list(funcs);
if (rv == CKR_OK)
return (void *) mod;
failed:
C_UnloadModule((void *) mod);
return NULL;
}
/*
* Read the directory and load all .so files
*/
vector<AbstractPlugin*> DlOpenPluginLoader::LoadPlugins() {
AbstractPlugin *plugin = NULL;
set<string>::iterator iter;
set<string> plugin_names = FindPlugins(m_dirname);
vector<AbstractPlugin*> plugins;
if (!m_dl_active) {
if (lt_dlinit()) {
OLA_WARN << "lt_dlinit failed";
return plugins;
}
}
if (lt_dlsetsearchpath(m_dirname.c_str())) {
OLA_WARN << "lt_setpath failed";
lt_dlexit();
return plugins;
}
m_dl_active = true;
for (iter = plugin_names.begin(); iter != plugin_names.end(); ++iter) {
string path = m_dirname;
path.append("/");
path.append(*iter);
if ((plugin = this->LoadPlugin(path)))
plugins.push_back(plugin);
else
OLA_WARN << "Failed to load plugin: " << path;
}
return plugins;
}
int
main (int argc, char* argv[])
{
lt_dlhandle dlhand;
char sym[300];
char* drvnam = argv[1];
char** info;
/* Establish a handler for SIGSEGV signals. */
signal (SIGSEGV, catch_segv);
lt_dlinit ();
dlhand = lt_dlopenext (drvnam);
if (dlhand == NULL) {
fprintf (stderr, "Could not open driver module %s\n"
"libltdl error: %s\n", drvnam, lt_dlerror ());
return 1;
}
sprintf (sym, "plD_DEVICE_INFO_%s", drvnam);
info = (char **) lt_dlsym (dlhand, sym);
if (info != NULL) {
printf ("%s", *info);
return 0;
}
else {
fprintf (stderr, "Could not read symbol %s in driver module %s\n"
"libltdl error: %s\n", sym, drvnam, lt_dlerror ());
return 1;
}
}
int oph_ioserver_setup(const char *server_type, oph_ioserver_handler **handle)
{
if (!handle){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_LOG_NULL_HANDLE);
logging_server(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_COMMON_LOG, OPH_IOSERVER_LOG_NULL_HANDLE);
return OPH_IOSERVER_NULL_HANDLE;
}
oph_ioserver_handler *internal_handle = (oph_ioserver_handler *)malloc(sizeof(oph_ioserver_handler));
internal_handle->server_type = NULL;
internal_handle->server_subtype = NULL;
internal_handle->lib = NULL;
internal_handle->dlh = NULL;
//Set storage server type
if(oph_parse_server_name (server_type, &internal_handle->server_type, &internal_handle->server_subtype)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_LOG_SERVER_PARSE_ERROR);
logging_server(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_COMMON_LOG, OPH_IOSERVER_LOG_SERVER_PARSE_ERROR);
return OPH_IOSERVER_INVALID_PARAM;
}
//If already executed don't procede further
if (internal_handle->dlh)
return OPH_IOSERVER_SUCCESS;
//LTDL_SET_PRELOADED_SYMBOLS();
if(lt_dlinit () != 0)
{
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_LOG_DLINIT_ERROR, lt_dlerror());
logging_server(LOG_ERROR, __FILE__, __LINE__, internal_handle->server_type, OPH_IOSERVER_LOG_DLINIT_ERROR, lt_dlerror());
return OPH_IOSERVER_DLOPEN_ERR;
}
if (oph_find_server_plugin (internal_handle->server_type, &internal_handle->lib)){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_LOG_LIB_NOT_FOUND);
logging_server(LOG_ERROR, __FILE__, __LINE__, internal_handle->server_type, OPH_IOSERVER_LOG_LIB_NOT_FOUND);
return OPH_IOSERVER_LIB_NOT_FOUND;
}
if (!(internal_handle->dlh = (lt_dlhandle) lt_dlopen (internal_handle->lib)))
{
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_LOG_DLOPEN_ERROR, lt_dlerror());
logging_server(LOG_ERROR, __FILE__, __LINE__, internal_handle->server_type, OPH_IOSERVER_LOG_DLOPEN_ERROR, lt_dlerror());
return OPH_IOSERVER_DLOPEN_ERR;
}
char func_name[OPH_IOSERVER_BUFLEN] = {'\0'};
snprintf(func_name, OPH_IOSERVER_BUFLEN, OPH_IOSERVER_SETUP_FUNC, internal_handle->server_type);
if (!(_SERVER_setup = (int (*)(oph_ioserver_handler *)) lt_dlsym (internal_handle->dlh, func_name))){
pmesg(LOG_ERROR, __FILE__, __LINE__, OPH_IOSERVER_LOG_LOAD_FUNC_ERROR, lt_dlerror());
logging_server(LOG_ERROR, __FILE__, __LINE__, internal_handle->server_type, OPH_IOSERVER_LOG_LOAD_FUNC_ERROR, lt_dlerror());
return OPH_IOSERVER_DLSYM_ERR;
}
*handle = internal_handle;
return _SERVER_setup (*handle);
}
void BOSS_Synthesis::initModules(const string & inv) {
InvMap::iterator it;
it = invmap.find(inv);
if(it!=invmap.end()) {
cerr << "Module order for inventory is already defined - skipping!"
<< endl;
return;
}
ifstream in;
if (cl("-modules").optionarg != "") {
in.open(cl("-modules").optionarg.c_str());
if (!in) {
cerr << "No (valid) module order file specified for inventory - exiting!"
<< endl;
exit(EXIT_FAILURE);
}
} else {
cerr << "Empty \"modules\" parameter provided, exiting" << endl;
exit(EXIT_FAILURE);
}
// Initialise the database connection
try {
cerr << "Initialising the database connection - " ;
data_base = new MySQL_Handler(cl("-h").optionarg,cl("-u").optionarg,cl("-p").optionarg,cl("-db").optionarg);
cerr << "OK" << endl;
}
catch (const MySQL_ConnectFailed & e) {
e.printError(true);
cerr << "Cannot establish database connection - exiting!"
<< endl;
in.close();
exit(EXIT_FAILURE);
}
/* Initialise libltdl. */
if (lt_dlinit()) {
cerr << "BOSS_Synthesis: couldn't initialise libtool." << endl;
in.close();
delete data_base;
exit(EXIT_FAILURE);
}
Scheduler s;
string name;
while(getline(in, name)) {
cerr << "name = " << name << endl;
if (name != "") {
BOSS::Module * module = load(name);
if (module != NULL) {
cerr << module->getDescription() << endl; //NOTE: this line can be deleted, mho
ModulePointer mp(name,module);
s.push_back(mp);
} else {
cerr << "got an error while loading the module " << name << endl;
}
}
}
invmap[inv]=pair<Scheduler, MySQL_Handler *>(s,data_base);
in.close();
}
/* initialize module routines */
int neb_init_modules(void) {
/* initialize library */
if (lt_dlinit())
return ERROR;
return OK;
}
/*
* (Try to) load the shared object `file'. Won't complain if it isn't a shared
* object, but it will bitch about a shared object not having a
* ``module_register'' symbol..
*/
static int plugin_load_file (char *file, uint32_t flags)
{
lt_dlhandle dlh;
void (*reg_handle) (void);
lt_dlinit ();
lt_dlerror (); /* clear errors */
#if LIBTOOL_VERSION == 2
if (flags & PLUGIN_FLAGS_GLOBAL) {
lt_dladvise advise;
lt_dladvise_init(&advise);
lt_dladvise_global(&advise);
dlh = lt_dlopenadvise(file, advise);
lt_dladvise_destroy(&advise);
} else {
dlh = lt_dlopen (file);
}
#else /* if LIBTOOL_VERSION == 1 */
if (flags & PLUGIN_FLAGS_GLOBAL)
WARNING ("plugin_load_file: The global flag is not supported, "
"libtool 2 is required for this.");
dlh = lt_dlopen (file);
#endif
if (dlh == NULL)
{
char errbuf[1024] = "";
ssnprintf (errbuf, sizeof (errbuf),
"lt_dlopen (\"%s\") failed: %s. "
"The most common cause for this problem are "
"missing dependencies. Use ldd(1) to check "
"the dependencies of the plugin "
"/ shared object.",
file, lt_dlerror ());
ERROR ("%s", errbuf);
/* Make sure this is printed to STDERR in any case, but also
* make sure it's printed only once. */
if (list_log != NULL)
fprintf (stderr, "ERROR: %s\n", errbuf);
return (1);
}
if ((reg_handle = (void (*) (void)) lt_dlsym (dlh, "module_register")) == NULL)
{
WARNING ("Couldn't find symbol \"module_register\" in \"%s\": %s\n",
file, lt_dlerror ());
lt_dlclose (dlh);
return (-1);
}
(*reg_handle) ();
return (0);
}
/**
* Module activation
* @ingroup globus_callout_activation
*/
static
int
globus_l_callout_activate(void)
{
int result = (int) GLOBUS_SUCCESS;
char * tmp_string;
static char * _function_name_ =
"globus_l_callout_activate";
tmp_string = globus_module_getenv("GLOBUS_CALLOUT_DEBUG_LEVEL");
if(tmp_string != GLOBUS_NULL)
{
globus_i_callout_debug_level = atoi(tmp_string);
if(globus_i_callout_debug_level < 0)
{
globus_i_callout_debug_level = 0;
}
}
tmp_string = globus_module_getenv("GLOBUS_CALLOUT_DEBUG_FILE");
if(tmp_string != GLOBUS_NULL)
{
globus_i_callout_debug_fstream = fopen(tmp_string, "a");
if(globus_i_callout_debug_fstream == NULL)
{
result = (int) GLOBUS_FAILURE;
goto exit;
}
}
else
{
globus_i_callout_debug_fstream = stderr;
}
GLOBUS_I_CALLOUT_DEBUG_ENTER;
result = globus_module_activate(GLOBUS_COMMON_MODULE);
if(result != GLOBUS_SUCCESS)
{
goto exit;
}
#ifndef BUILD_STATIC_ONLY
if((result = lt_dlinit()) != 0)
{
goto exit;
}
#endif
GLOBUS_I_CALLOUT_DEBUG_EXIT;
exit:
return result;
}
static int dso_init(void) {
#ifdef PR_USE_CTRLS
register unsigned int i = 0;
#endif /* PR_USE_CTRLS */
/* Allocate the pool for this module's use. */
dso_pool = make_sub_pool(permanent_pool);
pr_pool_tag(dso_pool, MOD_DSO_VERSION);
lt_dlpreload_default(lt_preloaded_symbols);
/* Initialize libltdl. */
if (lt_dlinit() < 0) {
pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION ": error initializing libltdl: %s",
lt_dlerror());
return -1;
}
/* Explicitly set the search path used for opening modules. */
if (lt_dlsetsearchpath(dso_module_path) < 0) {
pr_log_pri(PR_LOG_ERR, MOD_DSO_VERSION ": error setting module path: %s",
lt_dlerror());
return -1;
}
#ifdef PR_USE_CTRLS
/* Register ctrls handlers. */
for (i = 0; dso_acttab[i].act_action; i++) {
pool *sub_pool = make_sub_pool(dso_pool);
/* Allocate and initialize the ACL for this control. */
dso_acttab[i].act_acl = pcalloc(sub_pool, sizeof(ctrls_acl_t));
dso_acttab[i].act_acl->acl_pool = sub_pool;
pr_ctrls_init_acl(dso_acttab[i].act_acl);
if (pr_ctrls_register(&dso_module, dso_acttab[i].act_action,
dso_acttab[i].act_desc, dso_acttab[i].act_cb) < 0)
pr_log_pri(PR_LOG_INFO, MOD_DSO_VERSION
": error registering '%s' control: %s", dso_acttab[i].act_action,
strerror(errno));
}
#endif /* PR_USE_CTRLS */
/* Ideally, we'd call register a listener for the 'core.exit' event
* and call lt_dlexit() there, politely freeing up any resources allocated
* by the ltdl library. However, it's possible that other modules, later in
* the dispatch cycles, may need to use pointers to memory in shared modules
* that would become invalid by such finalization. So we skip it, for now.
*
* If there was a way to schedule this handler, to happen after all other
* exit handlers, that'd be best.
*/
pr_event_register(&dso_module, "core.restart", dso_restart_ev, NULL);
return 0;
}
/* return 0 on error */
int nutscan_load_upsclient_library()
{
if( dl_handle != NULL ) {
/* if previous init failed */
if( dl_handle == (void *)1 ) {
return 0;
}
/* init has already been done */
return 1;
}
if( lt_dlinit() != 0 ) {
fprintf(stderr, "Error initializing lt_init\n");
return 0;
}
dl_handle = lt_dlopenext(libname);
if (!dl_handle) {
dl_error = lt_dlerror();
goto err;
}
lt_dlerror(); /* Clear any existing error */
*(void **) (&nut_upscli_splitaddr) = lt_dlsym(dl_handle,
"upscli_splitaddr");
if ((dl_error = lt_dlerror()) != NULL) {
goto err;
}
*(void **) (&nut_upscli_tryconnect) = lt_dlsym(dl_handle,
"upscli_tryconnect");
if ((dl_error = lt_dlerror()) != NULL) {
goto err;
}
*(void **) (&nut_upscli_list_start) = lt_dlsym(dl_handle,
"upscli_list_start");
if ((dl_error = lt_dlerror()) != NULL) {
goto err;
}
*(void **) (&nut_upscli_list_next) = lt_dlsym(dl_handle,
"upscli_list_next");
if ((dl_error = lt_dlerror()) != NULL) {
goto err;
}
return 1;
err:
fprintf(stderr, "Cannot load NUT library (%s) : %s. NUT search disabled.\n", libname, dl_error);
dl_handle = (void *)1;
lt_dlexit();
return 0;
}
/*
* The libtool dynamic loading library must be initialized before any calls
* are made to library routines. Initialize only once.
*/
static void check_lt_initialized(void)
{
static int initialized = FALSE;
if (!initialized) {
#if defined(PIC) || !defined(SIDL_PURE_STATIC_RUNTIME)
(void) lt_dlinit();
#endif /* defined(PIC) || !defined(SIDL_PURE_STATIC_RUNTIME) */
initialized = TRUE;
}
}
exception_t init_module_list(){
int errors = 0;
//skyeye_modules = skyeye_mm(sizeof(skyeye_modules_t));
skyeye_modules = NULL;
/* Initialise libltdl. */
errors = lt_dlinit ();
if(skyeye_modules == NULL)
return Malloc_exp;
return No_exp;
}
int main( int argc, char *argv[] )
{
void * dummy;
lt_dlinit();
dummy= lt_dlopen("dummy.so");
if (dummy) lt_dlclose(dummy);
return(0);
}
void moduleloader_init(const char* searchpath){
lt_dlinit();
char* path_list = strdup(searchpath);
char* path = strtok(path_list, ":");
while ( path ){
lt_dladdsearchdir(path);
path = strtok(NULL, ":");
}
free(path_list);
}
/* pub funs */
fixc_eng_t
fixc_open_eng(const char *file)
{
static int mod_initted_p = 0;
fixc_eng_t res;
fixc_eng_f fun;
/* speed-dating singleton */
if (!mod_initted_p) {
/* initialise the dl system */
lt_dlinit();
/* add moddir to search path */
add_myself();
/* and just so we are a proper singleton */
mod_initted_p = 1;
}
if (UNLIKELY((res = my_dlopen(file)) == NULL)) {
return NULL;
}
if ((fun = eng_sym(res, "fixc_get_cid")) != NULL) {
__get_cid = (fixc_comp_t(*)())fun;
}
if ((fun = eng_sym(res, "fixc_get_aid")) != NULL) {
__get_aid = (fixc_attr_t(*)())fun;
}
if ((fun = eng_sym(res, "fixc_get_mty")) != NULL) {
__get_mty = (fixc_msgt_t(*)())fun;
}
if ((fun = eng_sym(res, "fixc_msgt_fixmlify")) != NULL) {
__msgt_fixmlify = (const char*(*)())fun;
}
if ((fun = eng_sym(res, "fixc_comp_fixmlify")) != NULL) {
__comp_fixmlify = (const char*(*)())fun;
}
if ((fun = eng_sym(res, "fixc_attr_fixmlify")) != NULL) {
__attr_fixmlify = (const char*(*)())fun;
}
if ((fun = eng_sym(res, "fixc_comp_rptb")) != NULL) {
__comp_rptb = (fixc_attr_t(*)())fun;
}
if ((fun = eng_sym(res, "fixc_get_comp_orb")) != NULL) {
__get_comp_orb = (fixc_comp_t(*)())fun;
}
if ((fun = eng_sym(res, "fixc_get_comp_sub")) != NULL) {
__get_comp_sub = (fixc_comp_sub_t(*)())fun;
}
if ((fun = eng_sym(res, "fixc_get_fld_ctx")) != NULL) {
__get_fld_ctx = (fixc_fld_ctx_t(*)())fun;
}
return res;
}
int nv_plugins_init() {
int ret = 0;
/* init the plugin system */
LTDL_SET_PRELOADED_SYMBOLS();
ret = lt_dlinit();
if (ret) {
nv_log(NVLOG_ERROR, "lt_dlinit(): %s", lt_dlerror());
return -1;
}
return ret;
}
KLibLoader::KLibLoader( QObject* parent, const char* name )
: QObject( parent, name )
{
s_self = this;
d = new KLibLoaderPrivate;
lt_dlinit();
d->unload_mode = KLibLoaderPrivate::UNKNOWN;
if (getenv("KDE_NOUNLOAD") != 0)
d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;
else if (getenv("KDE_DOUNLOAD") != 0)
d->unload_mode = KLibLoaderPrivate::UNLOAD;
d->loaded_stack.setAutoDelete( true );
}
/**
Initializes the dynamic module facility.
Applications that use this library must call this function
prior to any operation involved with the facility.
@return true on error, false otherwise.
*/
static bool initialize()
{
if ( lt_dlinit() > 0 )
return true;
if ( lt_dlsetsearchpath("") > 0 )
{
lt_dlexit();
return true;
}
return false;
}
