/** * Module deactivation * @ingroup globus_callout_activation */ static int globus_l_callout_deactivate(void) { int result = (int) GLOBUS_SUCCESS; static char * _function_name_ = "globus_l_callout_deactivate"; GLOBUS_I_CALLOUT_DEBUG_ENTER; globus_module_deactivate(GLOBUS_COMMON_MODULE); GLOBUS_I_CALLOUT_DEBUG_EXIT; if(globus_i_callout_debug_fstream != stderr) { fclose(globus_i_callout_debug_fstream); } #ifndef BUILD_STATIC_ONLY result = lt_dlexit(); #endif return result; }
/* * 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; }
void modena_function_destroy(modena_function_t *self) { lt_dlclose(self->handle); lt_dlexit(); Py_XDECREF(self->pFunction); free(self); }
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; }
void dbi_shutdown_r(dbi_inst Inst) { dbi_inst_t *inst = (dbi_inst_t*) Inst; dbi_conn_t *curconn = inst->rootconn; dbi_conn_t *nextconn; dbi_driver_t *curdriver = inst->rootdriver; dbi_driver_t *nextdriver; while (curconn) { nextconn = curconn->next; dbi_conn_close((dbi_conn)curconn); curconn = nextconn; } while (curdriver) { nextdriver = curdriver->next; curdriver->functions->finalize(curdriver); _safe_dlclose(curdriver); free(curdriver->functions); _free_custom_functions(curdriver); _free_caps(curdriver->caps); free(curdriver->filename); free(curdriver); curdriver = nextdriver; } #if HAVE_LTDL_H (void)lt_dlexit(); #endif free(inst); }
void sxc_shutdown(sxc_client_t *sx, int signal) { if(!sx) return; if(sx->temptrack.slots) { for(int i = 0; i < sx->temptrack.slots; i++) { if(sx->temptrack.names[i]) { /* TODO: for win32 we may also need to track descriptors */ unlink(sx->temptrack.names[i]); if(!signal) free(sx->temptrack.names[i]); } } if(!signal) free(sx->temptrack.names); } if(!signal) { if (sx->log.func && sx->log.func->close) { sx->log.func->close(sx->log.func->ctx); } sxi_filter_unloadall(sx); free(sx); lt_dlexit(); curl_global_cleanup(); } }
/* deinitialize module routines */ int neb_deinit_modules(void) { /* deinitialize library */ if (lt_dlexit()) return ERROR; return OK; }
void xdlclose(void *h) { xassert(h != NULL); if (lt_dlclose(h) != 0) xerror("xdlclose: %s\n", lt_dlerror()); if (lt_dlexit() != 0) xerror("xdlclose: %s\n", lt_dlerror()); return; }
void plugins_destroy(void) { PLUGINS_CALL(destroy); lt_dlinterface_free(interface_id); lt_dlexit(); VLOG_INFO("Destroyed all plugins"); }
/* Unload all modules */ int modules_shutdown() { struct module_entry_t *m; MODULE_ITER(m) m->unload(m); return lt_dlexit(); /* 0 is good */ }
void xdlclose(void *h) { /* close dynamically linked library */ xassert(h != NULL); if (lt_dlclose(h) != 0) xerror("xdlclose: %s\n", lt_dlerror()); if (lt_dlexit() != 0) xerror("xdlclose: %s\n", lt_dlerror()); return; }
void pa_ltdl_done(void) { pa_assert_se(lt_dlexit() == 0); #ifdef PA_BIND_NOW /* lt_dlexit() will free our loader vtable, hence reset our * pointer to it here */ bindnow_loader = NULL; #endif }
int fontforge_main( int argc, char **argv ) { extern const char *source_version_str; extern const char *source_modtime_str; fprintf( stderr, "Copyright (c) 2000-2014 by George Williams. See AUTHORS for Contributors.\n" ); fprintf( stderr, " License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n" ); fprintf( stderr, " with many parts BSD <http://fontforge.org/license.html>. Please read LICENSE.\n" ); fprintf( stderr, " Based on sources from %s" #ifdef FREETYPE_HAS_DEBUGGER "-TtfDb" #endif #ifdef _NO_PYTHON "-NoPython" #endif #ifdef FONTFORGE_CONFIG_USE_DOUBLE "-D" #endif ".\n", FONTFORGE_MODTIME_STR ); fprintf( stderr, " Based on source from git with hash:%s\n", FONTFORGE_GIT_VERSION ); FindProgDir(argv[0]); InitSimpleStuff(); bind_textdomain_codeset("FontForge","UTF-8"); bindtextdomain("FontForge", getLocaleDir()); textdomain("FontForge"); if ( default_encoding==NULL ) default_encoding=FindOrMakeEncoding("ISO8859-1"); if ( default_encoding==NULL ) default_encoding=&custom; /* In case iconv is broken */ CheckIsScript(argc,argv); /* Will run the script and exit if it is a script */ if ( argc==2 ) { char *pt = argv[1]; if ( *pt=='-' && pt[1]=='-' && pt[2]!='\0') ++pt; if ( strcmp(pt,"-usage")==0 ) doscriptusage(); else if ( strcmp(pt,"-help")==0 ) doscripthelp(); else if ( strcmp(pt,"-version")==0 || strcmp(pt,"-v")==0 || strcmp(pt,"-V")==0 ) doversion(FONTFORGE_MODTIME_STR); } # if defined(_NO_PYTHON) ProcessNativeScript(argc, argv,stdin); # else PyFF_Stdin(); # endif #ifndef _NO_LIBUNICODENAMES uninm_names_db_close(names_db); /* close this database before exiting */ uninm_blocks_db_close(blocks_db); #endif lt_dlexit(); return( 0 ); }
/* * Remove the module lists. */ int detach_modules(void) { rbtree_free(instance_tree); rbtree_free(module_tree); lt_dlexit(); return 0; }
int fontforge_main( int argc, char **argv ) { extern const char *source_version_str; extern const char *source_modtime_str; fprintf( stderr, "Copyright (c) 2000-2012 by George Williams.\n Executable based on sources from %s" "-ML" #ifdef FREETYPE_HAS_DEBUGGER "-TtfDb" #endif #ifdef _NO_PYTHON "-NoPython" #endif #ifdef FONTFORGE_CONFIG_USE_DOUBLE "-D" #endif ".\n", source_modtime_str ); fprintf( stderr, " Library based on sources from %s.\n", library_version_configuration.library_source_modtime_string ); /* I don't bother to check that the exe's exectations of the library are */ /* valid. The exe only consists of this file, and so it doesn't care. */ /* as long as the library is self consistant, all should be well */ /* check_library_version(&exe_library_version_configuration,true,false); */ FindProgDir(argv[0]); InitSimpleStuff(); bind_textdomain_codeset("FontForge","UTF-8"); bindtextdomain("FontForge", getLocaleDir()); textdomain("FontForge"); if ( default_encoding==NULL ) default_encoding=FindOrMakeEncoding("ISO8859-1"); if ( default_encoding==NULL ) default_encoding=&custom; /* In case iconv is broken */ CheckIsScript(argc,argv); /* Will run the script and exit if it is a script */ if ( argc==2 ) { char *pt = argv[1]; if ( *pt=='-' && pt[1]=='-' ) ++pt; if ( strcmp(pt,"-usage")==0 ) doscriptusage(); else if ( strcmp(pt,"-help")==0 ) doscripthelp(); else if ( strcmp(pt,"-version")==0 ) doversion(source_version_str); } # if defined(_NO_PYTHON) ProcessNativeScript(argc, argv,stdin); # else PyFF_Stdin(); # endif uninm_names_db_close(names_db); lt_dlexit(); 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; }
//----------------------------------------------------------------------------- mglParser::~mglParser() { DeleteAll(); delete []fval; for(size_t i=0;i<NumList.size();i++) // force delete built-in variables if(NumList[i]) delete NumList[i]; NumList.clear(); #if MGL_HAVE_LTDL lt_dlexit(); #endif }
static void free_lt_handle(SpellerLtHandle h) { #ifdef USE_LTDL int s; s = lt_dlclose((lt_dlhandle)h); assert (s == 0); s = lt_dlexit(); assert (s == 0); #endif }
int nv_plugins_free() { int ret = 0; /* close down the plugin system */ ret = lt_dlexit(); if (ret) { nv_log(NVLOG_ERROR, "lt_dlexit(): %s", lt_dlerror()); return -1; } return ret; }
int uninit_plugin(void) { int rv; rv = lt_dlexit(); if (rv < 0) { dbg("Can not exit ltdl right"); return -1; } return 0; }
WIN32DLL_DEFINE int mcrypt_algorithm_module_ok(const char *file, const char *directory) { word32 ret = 1; mcrypt_dlhandle _handle; void *rr; int (*_version) (void); if (file == NULL && directory == NULL) { return MCRYPT_UNKNOWN_ERROR; } if (lt_dlinit() != 0) { return MCRYPT_UNKNOWN_ERROR; } rr = mcrypt_dlopen(&_handle, directory, NULL, file); if (!rr) { lt_dlexit(); return MCRYPT_UNKNOWN_ERROR; } _version = mcrypt_dlsym(_handle, "_mcrypt_algorithm_version"); if (_version == NULL) { mcrypt_dlclose(_handle); lt_dlexit(); return MCRYPT_UNKNOWN_ERROR; } ret = _version(); mcrypt_dlclose(_handle); lt_dlexit(); return ret; }
/** * oh_exit_ltdl * * Does everything needed to close the ltdl structures. * * Returns: 0 on Success. **/ int oh_exit_ltdl() { int rv; rv = lt_dlexit(); if (rv < 0) { dbg("Could not exit ltdl!"); return -1; } return 0; }
/** * oh_exit_ltdl * * Does everything needed to close the ltdl structures. * * Returns: 0 on Success. **/ static int oh_exit_ltdl(void) { int rv; rv = lt_dlexit(); if (rv < 0) { err("Could not exit ltdl!"); return -1; } return 0; }
/* * Unload all plugins */ void DlOpenPluginLoader::UnloadPlugins() { vector<lt_dlhandle>::iterator iter; for (iter = m_plugin_handles.begin(); iter != m_plugin_handles.end(); iter++) lt_dlclose(*iter); m_plugin_handles.clear(); if (m_dl_active) { if (lt_dlexit()) OLA_WARN << "dlexit: " << lt_dlerror(); m_dl_active = false; } }
/* * Unload all modules and clean up. */ int stp_module_exit(void) { /* destroy the module list (modules unloaded by callback) */ if (module_list) stp_list_destroy(module_list); /* shut down libltdl (forces close of any unclosed modules) */ #ifdef USE_LTDL return lt_dlexit(); #else return 0; #endif }
/** 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; }
static int _free_loaded_module (void *item, void *data) { lt_dlhandle handle = (lt_dlhandle) item; grad_dl_done_t fp = (grad_dl_done_t) lt_dlsym(handle, "done"); GRAD_DEBUG2(1,"Freeing handle %p, grad_dl_done %p", handle, fp); if (fp) fp(); lt_dlclose(handle); lt_dlexit(); return 0; }
/* deinitialize module routines */ int neb_deinit_modules(void) { #ifdef USE_LTDL int result = OK; #endif /* deinitialize library */ #ifdef USE_LTDL result = lt_dlexit(); if (result) return ERROR; #endif return OK; }
DynamicLoaderModule::~DynamicLoaderModule() { // unload all loaded modules for ( vecDynModules::iterator it = dyn_modules.begin(); it != dyn_modules.end(); ++it ) { if ( it->handle != NULL ) { lt_dlclose( it->handle ); it->handle = NULL; } } lt_dlexit(); }
void *xdlopen(const char *module) { void *h = NULL; if (lt_dlinit() != 0) { lib_err_msg(lt_dlerror()); goto done; } h = lt_dlopen(module); if (h == NULL) { lib_err_msg(lt_dlerror()); if (lt_dlexit() != 0) xerror("xdlopen: %s\n", lt_dlerror()); } done: return h; }