static void xfsm_splash_screen_load (XfsmSplashScreen *splash, const gchar *engine) { void (*init) (XfsmSplashEngine *engine); gchar *filename; filename = g_module_build_path (LIBDIR "/xfce4/session/splash-engines", engine); splash->module = g_module_open (filename, G_MODULE_BIND_LOCAL); g_free (filename); if (G_LIKELY (splash->module != NULL)) { if (g_module_symbol (splash->module, "engine_init", (gpointer)&init)) { init (&splash->engine); } else { g_module_close (splash->module); splash->module = NULL; } } else { g_warning ("Unable to load engine \"%s\": %s", engine, g_module_error ()); } }
static MMPlugin * load_plugin (const gchar *path) { MMPlugin *plugin = NULL; GModule *module; MMPluginCreateFunc plugin_create_func; gint *major_plugin_version; gint *minor_plugin_version; gchar *path_display; /* Get printable UTF-8 string of the path */ path_display = g_filename_display_name (path); module = g_module_open (path, G_MODULE_BIND_LAZY); if (!module) { g_warning ("Could not load plugin '%s': %s", path_display, g_module_error ()); goto out; } if (!g_module_symbol (module, "mm_plugin_major_version", (gpointer *) &major_plugin_version)) { g_warning ("Could not load plugin '%s': Missing major version info", path_display); goto out; } if (*major_plugin_version != MM_PLUGIN_MAJOR_VERSION) { g_warning ("Could not load plugin '%s': Plugin major version %d, %d is required", path_display, *major_plugin_version, MM_PLUGIN_MAJOR_VERSION); goto out; } if (!g_module_symbol (module, "mm_plugin_minor_version", (gpointer *) &minor_plugin_version)) { g_warning ("Could not load plugin '%s': Missing minor version info", path_display); goto out; } if (*minor_plugin_version != MM_PLUGIN_MINOR_VERSION) { g_warning ("Could not load plugin '%s': Plugin minor version %d, %d is required", path_display, *minor_plugin_version, MM_PLUGIN_MINOR_VERSION); goto out; } if (!g_module_symbol (module, "mm_plugin_create", (gpointer *) &plugin_create_func)) { g_warning ("Could not load plugin '%s': %s", path_display, g_module_error ()); goto out; } plugin = (*plugin_create_func) (); if (plugin) { g_object_weak_ref (G_OBJECT (plugin), (GWeakNotify) g_module_close, module); } else mm_warn ("Could not load plugin '%s': initialization failed", path_display); out: if (module && !plugin) g_module_close (module); g_free (path_display); return plugin; }
gint ms_load_plugin(gchar *path) { #ifdef HAVE_GLIB g_module_open(path,0); #endif return 0; }
void StarDictPlugins::get_plugin_info(const char *filename, StarDictPlugInType &plugin_type, std::string &info_xml, bool &can_configure) { GModule *module; module = g_module_open (filename, G_MODULE_BIND_LAZY); if (!module) { g_print("Load %s failed!\n", filename); return; } union { stardict_plugin_init_func_t stardict_plugin_init; gpointer stardict_plugin_init_avoid_warning; } func; func.stardict_plugin_init = 0; if (!g_module_symbol (module, "stardict_plugin_init", (gpointer *)&(func.stardict_plugin_init_avoid_warning))) { g_print("Load %s failed: No stardict_plugin_init func!\n", filename); g_module_close (module); return; } StarDictPlugInObject *plugin_obj = new StarDictPlugInObject(); bool failed = func.stardict_plugin_init(plugin_obj, app_dirs); if (failed) { g_print("Load %s failed!\n", filename); g_module_close (module); delete plugin_obj; return; } plugin_type = plugin_obj->type; info_xml = plugin_obj->info_xml; can_configure = (plugin_obj->configure_func != NULL); delete plugin_obj; g_module_close (module); }
static gpointer load_self_module (gpointer user_data) { module_self = g_module_open (NULL, G_MODULE_BIND_LAZY); return NULL; }
static gboolean pluma_object_module_load (GTypeModule *gmodule) { PlumaObjectModule *module = PLUMA_OBJECT_MODULE (gmodule); PlumaObjectModuleRegisterFunc register_func; gchar *path; pluma_debug_message (DEBUG_PLUGINS, "Loading %s module from %s", module->priv->module_name, module->priv->path); path = g_module_build_path (module->priv->path, module->priv->module_name); g_return_val_if_fail (path != NULL, FALSE); pluma_debug_message (DEBUG_PLUGINS, "Module filename: %s", path); module->priv->library = g_module_open (path, G_MODULE_BIND_LAZY); g_free (path); if (module->priv->library == NULL) { g_warning ("%s: %s", module->priv->module_name, g_module_error()); return FALSE; } /* extract symbols from the lib */ if (!g_module_symbol (module->priv->library, module->priv->type_registration, (void *) ®ister_func)) { g_warning ("%s: %s", module->priv->module_name, g_module_error()); g_module_close (module->priv->library); return FALSE; } /* symbol can still be NULL even though g_module_symbol * returned TRUE */ if (register_func == NULL) { g_warning ("Symbol '%s' should not be NULL", module->priv->type_registration); g_module_close (module->priv->library); return FALSE; } module->priv->type = register_func (gmodule); if (module->priv->type == 0) { g_warning ("Invalid object contained by module %s", module->priv->module_name); return FALSE; } if (module->priv->resident) { g_module_make_resident (module->priv->library); } return TRUE; }
static gboolean nautilus_module_load (GTypeModule *gmodule) { NautilusModule *module; module = NAUTILUS_MODULE (gmodule); module->library = g_module_open (module->path, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL); if (!module->library) { g_warning ("%s", g_module_error ()); return FALSE; } if (!g_module_symbol (module->library, "nautilus_module_initialize", (gpointer *)&module->initialize) || !g_module_symbol (module->library, "nautilus_module_shutdown", (gpointer *)&module->shutdown) || !g_module_symbol (module->library, "nautilus_module_list_types", (gpointer *)&module->list_types)) { g_warning ("%s", g_module_error ()); g_module_close (module->library); return FALSE; } module->initialize (gmodule); return TRUE; }
static void ToolsCoreInitializeDebug(ToolsServiceState *state) { RpcDebugLibData *libdata; RpcDebugInitializeFn initFn; state->debugLib = g_module_open(MODULE_NAME(vmrpcdbg), G_MODULE_BIND_LOCAL); if (state->debugLib == NULL) { g_error("Cannot load vmrpcdbg library.\n"); } if (!g_module_symbol(state->debugLib, "RpcDebug_Initialize", (gpointer *) &initFn)) { g_error("Cannot find symbol: RpcDebug_Initialize\n"); } libdata = initFn(&state->ctx, state->debugPlugin); ASSERT(libdata != NULL); ASSERT(libdata->debugPlugin != NULL); state->debugData = libdata; #if defined(_WIN32) VMTools_AttachConsole(); #endif }
void plugin_load (const char * filename) { GModule *module; Plugin * (* func) (AudAPITable * table); AUDDBG ("Loading plugin: %s.\n", filename); if (!(module = g_module_open(filename, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL))) { printf("Failed to load plugin (%s): %s\n", filename, g_module_error()); return; } /* v2 plugin loading */ if (g_module_symbol (module, "get_plugin_info", (void *) & func)) { Plugin * header = func (& api_table); g_return_if_fail (header != NULL); plugin2_process(header, module, filename); return; } printf("Invalid plugin (%s)\n", filename); g_module_close(module); }
/* FIXME: It would be better to just fix the flags using RTLD_NOLOAD because * the libraries are surely loaded. */ static gboolean reload_libraries(void) { /* Do not do it on Win32 because the libs must be fully resolved there and * because the library names are different (with -0). */ #ifndef G_OS_WIN32 static const gchar *const gwyddion_libs[] = { "libgwyddion2", "libgwyprocess2", "libgwydraw2", "libgwydgets2", "libgwymodule2", "libgwyapp2", }; guint i; for (i = 0; i < G_N_ELEMENTS(gwyddion_libs); i++) { gchar *filename = g_strconcat(gwyddion_libs[i], ".", GWY_SHARED_LIBRARY_EXTENSION, NULL); GModule *modhandle = g_module_open(filename, G_MODULE_BIND_LAZY); if (!modhandle) { gchar *excstr = g_strdup_printf("Cannot dlopen() %s.", filename); PyErr_SetString(PyExc_ImportError, excstr); g_free(excstr); return FALSE; } g_module_make_resident(modhandle); g_free(filename); } #endif return TRUE; }
void GuiModuleFactory::RegisterGuiPlugin(string filename) { typedef string (* GetTypeFunc)(); typedef Gui* (* CreateFunc)( Module* mod ); GetTypeFunc GetType; CreateFunc Create; // GError **error; filename = "./plugins/" + filename; GModule* gm = g_module_open( filename.c_str(), G_MODULE_BIND_MASK ); if( gm!=NULL ) { if( g_module_symbol( gm, "GetGuiType", (gpointer *)&GetType ) == TRUE ) { if( g_module_symbol( gm, "CreateGui", (gpointer *)&Create ) == TRUE ) { RegisterGui( GetType(), Create ); } else { TRACE( "GuiModuleFactory::RegisterGuiPlugin - Nie znaleziono " "CreateGui() w %s\n", filename.c_str() ); } } else { TRACE( "MGuiModuleFactory::RegisterGuiPlugin - Nie znaleziono CreateGui() w pliku %s\n", filename.c_str() ); } } }
osync_bool osync_module_load(OSyncModule *module, const char *path, OSyncError **error) { osync_trace(TRACE_ENTRY, "%s(%p, %s, %p)", __func__, module, path, error); osync_assert(module); osync_assert(!module->module); if (!g_module_supported()) { osync_error_set(error, OSYNC_ERROR_GENERIC, "This platform does not support loading of modules"); goto error; } /* Try to open the module or fail if an error occurs. * * Do local bind to avoid symbol-clashing - i.e. plugins having the same * functions name - e.g. finalize(). * * Don't do lazy binding, otherwise symbols of kdepim-sync can't get loaded. * Related to C++ and dlopen? */ module->module = g_module_open(path, G_MODULE_BIND_LOCAL); if (!module->module) { osync_error_set(error, OSYNC_ERROR_GENERIC, "Unable to open module %s: %s", path, g_module_error()); goto error; } module->path = osync_strdup(path); osync_trace(TRACE_EXIT, "%s", __func__); return TRUE; error: osync_trace(TRACE_EXIT_ERROR, "%s: %s", __func__, osync_error_print(error)); return FALSE; }
static void open_libbeagle (void) { static gboolean done = FALSE; if (!done) { int i; GModule *beagle; done = TRUE; beagle = g_module_open ("libbeagle.so.1", G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL); if (!beagle) return; for (i = 0; i < G_N_ELEMENTS (beagle_dl_mapping); i++) { if (!g_module_symbol (beagle, beagle_dl_mapping[i].fn_name, beagle_dl_mapping[i].fn_ptr_ref)) { g_warning ("Missing symbol '%s' in libbeagle\n", beagle_dl_mapping[i].fn_name); g_module_close (beagle); for (i = 0; i < G_N_ELEMENTS (beagle_dl_mapping); i++) beagle_dl_mapping[i].fn_ptr_ref = NULL; return; } } } }
static gboolean a11y_invoke_module (const char *module_path) { GModule *handle; void (*invoke_fn) (void); if (!module_path) { g_warning ("Accessibility: invalid module path (NULL)"); return FALSE; } if (!(handle = g_module_open (module_path, 0))) { g_warning ("Accessibility: failed to load module '%s': '%s'", module_path, g_module_error ()); return FALSE; } if (!g_module_symbol (handle, INIT_METHOD, (gpointer *)&invoke_fn)) { g_warning ("Accessibility: error library '%s' does not include " "method '%s' required for accessibility support", module_path, INIT_METHOD); g_module_close (handle); return FALSE; } invoke_fn (); return TRUE; }
// TBD: Support a comma separated list of plugin directories. static void rehash_loaders() { GError *error = NULL; const gchar * giv_plugin_dir = PACKAGE_PLUGIN_DIR; #ifdef G_OS_WIN32 // Hardcoded path relative to installation dir on Windows gchar giv_win32_plugin_dir[512]; sprintf(giv_win32_plugin_dir, "%s/plugins", g_win32_get_package_installation_directory_of_module(NULL)); giv_plugin_dir = giv_win32_plugin_dir; #endif if (getenv("GIV_PLUGIN_DIR")) giv_plugin_dir = (const char*)getenv("GIV_PLUGIN_DIR"); // No matter of we succeed or not, we will not automatically // call this function again. giv_image_loaded_loaders = TRUE; GDir *plugin_dir = g_dir_open(giv_plugin_dir, 0, &error); // No directory found, ok, just ignore it. if (error) { fprintf(stderr, "plugin dir error: %s\n", error->message); g_error_free(error); return; } const gchar *name; while( (name=g_dir_read_name(plugin_dir)) ) { // printf("name = %s\n", name); // Try to load it as a module if it ends with ".dll" // or ".so". gchar *extension = g_strrstr(name, "."); if (!extension) continue; extension++; if (g_ascii_strncasecmp(G_MODULE_SUFFIX, extension, strlen(G_MODULE_SUFFIX))==0) { gchar *module_name = g_strndup(name, extension-name-1); gchar *module_path = g_strdup_printf("%s/%s", giv_plugin_dir, name); GModule *module = g_module_open (module_path, G_MODULE_BIND_MASK); if (module) { givimage_loaders = g_slist_prepend(givimage_loaders, module); } else fprintf(stderr, "Failed loading module %s\n", module_path); g_free(module_path); g_free(module_name); } } g_dir_close(plugin_dir); }
/* ***************************************************************************** * load and initialize and external module */ gboolean nav_init (const gchar *mod_path, const gchar *mod_name) { gchar *t_path; nav_close (); t_path = g_module_build_path (mod_path, mod_name); nav_module = g_module_open (t_path, G_MODULE_BIND_LAZY); if (!nav_module) { g_print (_("WARNING: %s\n"), g_module_error ()); return FALSE; } if (!g_module_symbol (nav_module, "calculate_route", (gpointer *)&calculate_route)) { g_print (_("ERROR: %s\n"), g_module_error ()); nav_close (); return FALSE; } if (calculate_route == NULL) { g_print (_("ERROR: Missing symbol \"calculate_route\" in navigation module '%s'\n"), g_module_name (nav_module)); nav_close (); return FALSE; } g_print (_("Navigation module '%s' successfully loaded.\n"), g_module_name (nav_module)); return TRUE; }
static gboolean _cogl_renderer_choose_driver (CoglRenderer *renderer, GError **error) { const char *driver_name = g_getenv ("COGL_DRIVER"); const char *libgl_name; #ifdef HAVE_COGL_GL if (driver_name == NULL || !strcmp (driver_name, "gl")) { renderer->driver = COGL_DRIVER_GL; libgl_name = COGL_GL_LIBNAME; goto found; } #endif #ifdef HAVE_COGL_GLES2 if (driver_name == NULL || !strcmp (driver_name, "gles2")) { renderer->driver = COGL_DRIVER_GLES2; libgl_name = COGL_GLES2_LIBNAME; goto found; } #endif #ifdef HAVE_COGL_GLES if (driver_name == NULL || !strcmp (driver_name, "gles1")) { renderer->driver = COGL_DRIVER_GLES1; libgl_name = COGL_GLES1_LIBNAME; goto found; } #endif g_set_error (error, COGL_DRIVER_ERROR, COGL_DRIVER_ERROR_NO_SUITABLE_DRIVER_FOUND, "No suitable driver found"); return FALSE; found: #ifndef HAVE_DIRECTLY_LINKED_GL_LIBRARY renderer->libgl_module = g_module_open (libgl_name, G_MODULE_BIND_LAZY); if (renderer->libgl_module == NULL) { g_set_error (error, COGL_DRIVER_ERROR, COGL_DRIVER_ERROR_FAILED_TO_LOAD_LIBRARY, "Failed to dynamically open the GL library \"%s\"", libgl_name); return FALSE; } #endif /* HAVE_DIRECTLY_LINKED_GL_LIBRARY */ return TRUE; }
/** * gck_module_initialize: * @path: The file system path to the PKCS#11 module to load. * @reserved: Extra arguments for the PKCS#11 module, should usually be NULL. * @reserved_options: No options are currently available. * @err: A location to store an error resulting from a failed load. * * Load and initialize a PKCS#11 module represented by a GckModule object. * * Return value: The loaded PKCS#11 module or NULL if failed. **/ GckModule* gck_module_initialize (const gchar *path, gpointer reserved, guint reserved_options, GError **err) { CK_C_GetFunctionList get_function_list; CK_FUNCTION_LIST_PTR funcs; GModule *module; GckModule *self; CK_RV rv; g_return_val_if_fail (path != NULL, NULL); g_return_val_if_fail (!err || !*err, NULL); /* Load the actual module */ module = g_module_open (path, 0); if (!module) { g_set_error (err, GCK_ERROR, (int)CKR_GCK_MODULE_PROBLEM, "Error loading pkcs11 module: %s", g_module_error ()); return NULL; } /* Get the entry point */ if (!g_module_symbol (module, "C_GetFunctionList", (void**)&get_function_list)) { g_set_error (err, GCK_ERROR, (int)CKR_GCK_MODULE_PROBLEM, "Invalid pkcs11 module: %s", g_module_error ()); g_module_close (module); return NULL; } /* Get the function list */ rv = (get_function_list) (&funcs); if (rv != CKR_OK) { g_set_error (err, GCK_ERROR, rv, "Couldn't get pkcs11 function list: %s", gck_message_from_rv (rv)); g_module_close (module); return NULL; } self = g_object_new (GCK_TYPE_MODULE, "functions", funcs, "path", path, NULL); self->pv->module = module; memset (&self->pv->init_args, 0, sizeof (self->pv->init_args)); self->pv->init_args.flags = CKF_OS_LOCKING_OK; self->pv->init_args.CreateMutex = create_mutex; self->pv->init_args.DestroyMutex = destroy_mutex; self->pv->init_args.LockMutex = lock_mutex; self->pv->init_args.UnlockMutex = unlock_mutex; self->pv->init_args.pReserved = reserved; /* Now initialize the module */ rv = (self->pv->funcs->C_Initialize) (&self->pv->init_args); if (rv != CKR_OK) { g_set_error (err, GCK_ERROR, rv, "Couldn't initialize module: %s", gck_message_from_rv (rv)); g_object_unref (self); return NULL; } self->pv->initialized = TRUE; return self; }
void init_cups(void) { const char *libcups[] = { "libcups", "libcups.so", "libcups.so.1", "libcups.so.2", NULL }; if (!(cups_dests_get && cups_dests_free)) { int i; for (i = 0; libcups[i] != NULL; i++) { cups = g_module_open(libcups[i], G_MODULE_BIND_LAZY); if (cups) break; } if (!cups) { cups_init = FALSE; return; } if (!g_module_symbol(cups, "cupsGetDests", (gpointer) & cups_dests_get) || !g_module_symbol(cups, "cupsFreeDests", (gpointer) & cups_dests_free)) { g_module_close(cups); cups_init = FALSE; } } cups_init = TRUE; }
static gboolean panel_applets_manager_dbus_factory_activate (PanelAppletsManager *manager, const gchar *iid) { PanelAppletFactoryInfo *info; ActivateAppletFunc activate_applet; info = get_applet_factory_info (manager, iid); if (!info) return FALSE; /* Out-of-process applets are activated by the session bus */ if (!info->in_process) return TRUE; if (info->module) { if (info->n_applets == 0) { if (info->activate_applet () != 0) { g_warning ("Failed to reactivate factory %s\n", iid); return FALSE; } } info->n_applets++; return TRUE; } info->module = g_module_open (info->location, G_MODULE_BIND_LAZY); if (!info->module) { /* FIXME: use a GError? */ g_warning ("Failed to load applet %s: %s\n", iid, g_module_error ()); return FALSE; } if (!g_module_symbol (info->module, "_panel_applet_shlib_factory", (gpointer *) &activate_applet)) { /* FIXME: use a GError? */ g_warning ("Failed to load applet %s: %s\n", iid, g_module_error ()); g_module_close (info->module); info->module = NULL; return FALSE; } /* Activate the applet */ if (activate_applet () != 0) { /* FIXME: use a GError? */ g_warning ("Failed to load applet %s\n", iid); g_module_close (info->module); info->module = NULL; return FALSE; } info->activate_applet = activate_applet; info->n_applets = 1; return TRUE; }
/* test for g_module_open (NULL, ...) */ RESULT test_module_symbol_null () { gpointer proc = GINT_TO_POINTER (42); GModule *m = g_module_open (NULL, G_MODULE_BIND_LAZY); if (m == NULL) return FAILED ("bind to main module failed. #0"); if (g_module_symbol (m, "__unlikely_\nexistent__", &proc)) return FAILED ("non-existent symbol lookup failed. #1"); if (proc) return FAILED ("non-existent symbol lookup failed. #2"); if (!g_module_symbol (m, EXTERNAL_SYMBOL, &proc)) return FAILED ("external lookup failed. #3"); if (!proc) return FAILED ("external lookup failed. #4"); if (!g_module_symbol (m, "dummy_test_export", &proc)) return FAILED ("in-proc lookup failed. #5"); if (!proc) return FAILED ("in-proc lookup failed. #6"); if (!g_module_close (m)) return FAILED ("close failed. #7"); return OK; }
G_MODULE_EXPORT gboolean swfdec_mozilla_make_sure_this_thing_stays_in_memory (void) { static gboolean inited = FALSE; GModule *module; gpointer check; if (inited) return TRUE; if (!g_module_supported ()) return FALSE; module = g_module_open (PLUGIN_FILE, 0); if (module == NULL) return FALSE; /* now load this function name to be sure it we've loaded ourselves */ if (!g_module_symbol (module, "swfdec_mozilla_make_sure_this_thing_stays_in_memory", &check) || check != swfdec_mozilla_make_sure_this_thing_stays_in_memory) { g_module_close (module); return FALSE; } g_module_make_resident (module); g_module_close (module); inited = TRUE; return TRUE; }
static void * open_module (const char * path) { GModule * handle = g_module_open (path, G_MODULE_BIND_LOCAL); if (! handle) { fprintf (stderr, "ladspa: Failed to open module %s: %s\n", path, g_module_error ()); return NULL; } void * sym; if (! g_module_symbol (handle, "ladspa_descriptor", & sym)) { fprintf (stderr, "ladspa: Not a valid LADSPA module: %s\n", path); g_module_close (handle); return NULL; } LADSPA_Descriptor_Function descfun = (LADSPA_Descriptor_Function) sym; const LADSPA_Descriptor * desc; for (int i = 0; (desc = descfun (i)); i ++) { PluginData * plugin = open_plugin (path, desc); if (plugin) index_append (plugins, plugin); } return handle; }
static int pipeline_set_ruta(pipeline_t* p, const char * elemento, const char *ruta, const char *dir) { elemento_t *dato = g_hash_table_lookup(p->m_modulos, elemento); int dev = 0; if (ruta) { if (dato->m_handler) { g_module_close(dato->m_handler); } char *ruta_modulo = g_module_build_path(dir, ruta); dato->m_handler = g_module_open(ruta_modulo, G_MODULE_BIND_LAZY); if (dato->m_handler) { typedef modulo_t *(*funcion_modulo_t) (); funcion_modulo_t f; if(g_module_symbol(dato->m_handler, "get_modulo", (gpointer *)&f) != TRUE) { dev = -1; } else { dato->m_modulo = f ? f() : 0; dato->m_modulo->m_tabla = g_hash_table_new(g_str_hash, g_str_equal); } } else { dev = -1; } pipeline_salida_error(p, "Pipeline", "Bibliotecas", g_module_error()); } else { dev = -1; } return dev; }
static void sweep_plugin_init (const gchar * path) { GModule * module; sw_plugin * m_plugin; gpointer m_plugin_ptr; GList * gl; module = g_module_open (path, G_MODULE_BIND_LAZY); if (!module) { #ifdef DEBUG fprintf (stderr, "sweep_plugin_init: Error opening %s: %s\n", path, g_module_error()); #endif return; } if (g_module_symbol (module, "plugin", &m_plugin_ptr)) { m_plugin = (sw_plugin *)m_plugin_ptr; module_list = g_list_append (module_list, m_plugin); for (gl = m_plugin->plugin_init (); gl; gl = gl->next) { plugins = g_list_insert_sorted (plugins, (sw_procedure *)gl->data, (GCompareFunc)cmp_proc_names); } } }
static int qemu_rbd_load_libs(void) { if (librbd_loaded) { return 0; } if (!g_module_supported()) { error_report("modules are not supported on this platform: %s", g_module_error()); return -1; } librbd_handle = g_module_open("/usr/lib64/qemu/librbd.so.1", 0); if (!librbd_handle) { error_report("error loading librbd: %s", g_module_error()); return -1; } /* * Due to c++ templates used in librbd/librados and their * dependencies, and linker duplicate trimming rules, closing * librbd would leave it mapped. Make this explicit. */ g_module_make_resident(librbd_handle); if (qemu_rbd_set_mandatory_functions() < 0) { return -1; } qemu_rbd_set_optional_functions(); librbd_loaded = true; return 0; }
static gboolean load_storage_module (const char *module_name) { GModule *module; char *filename; filename = g_module_build_path (PLUGINDIR, module_name); module = g_module_open (filename, 0); g_free (filename); if (module == NULL) return FALSE; if (!g_module_symbol (module, "init", (gpointer *) &store.init) || !g_module_symbol (module, "deinit", (gpointer *) &store.deinit) || !g_module_symbol (module, "print_data_save", (gpointer *) &store.print_data_save) || !g_module_symbol (module, "print_data_load", (gpointer *) &store.print_data_load) || !g_module_symbol (module, "print_data_delete", (gpointer *) &store.print_data_delete) || !g_module_symbol (module, "discover_prints", (gpointer *) &store.discover_prints)) { g_module_close (module); return FALSE; } g_module_make_resident (module); return TRUE; }
static gboolean parole_module_load (GTypeModule *gtype_module) { ParoleProviderModule *module; module = PAROLE_PROVIDER_MODULE (gtype_module); module->library = g_module_open (gtype_module->name, G_MODULE_BIND_LOCAL); if ( G_UNLIKELY (module->library == NULL) ) { g_critical ("Failed to load plugin : %s", g_module_error ()); return FALSE; } if ( !g_module_symbol (module->library, "parole_plugin_initialize", (gpointer) &module->initialize) || !g_module_symbol (module->library, "parole_plugin_shutdown", (gpointer) &module->shutdown)) { g_critical ("Plugin %s missing required symbols", gtype_module->name); g_module_close (module->library); return FALSE; } TRACE ("Loading module %s", gtype_module->name); module->provider_type = (*module->initialize) (module); module->active = TRUE; TRACE ("Finished loading module %s", gtype_module->name); return TRUE; }
static int dt_imageio_load_module_storage (dt_imageio_module_storage_t *module, const char *libname, const char *plugin_name) { module->widget = NULL; g_strlcpy(module->plugin_name, plugin_name, 20); module->module = g_module_open(libname, G_MODULE_BIND_LAZY); if(!module->module) goto error; int (*version)(); if(!g_module_symbol(module->module, "dt_module_dt_version", (gpointer)&(version))) goto error; if(version() != dt_version()) { fprintf(stderr, "[imageio_load_module] `%s' is compiled for another version of dt (module %d (%s) != dt %d (%s)) !\n", libname, abs(version()), version() < 0 ? "debug" : "opt", abs(dt_version()), dt_version() < 0 ? "debug" : "opt"); goto error; } if(!g_module_symbol(module->module, "name", (gpointer)&(module->name))) goto error; if(!g_module_symbol(module->module, "gui_reset", (gpointer)&(module->gui_reset))) goto error; if(!g_module_symbol(module->module, "gui_init", (gpointer)&(module->gui_init))) goto error; if(!g_module_symbol(module->module, "gui_cleanup", (gpointer)&(module->gui_cleanup))) goto error; if(!g_module_symbol(module->module, "store", (gpointer)&(module->store))) goto error; if(!g_module_symbol(module->module, "get_params", (gpointer)&(module->get_params))) goto error; if(!g_module_symbol(module->module, "free_params", (gpointer)&(module->free_params))) goto error; if(!g_module_symbol(module->module, "finalize_store", (gpointer)&(module->finalize_store))) module->finalize_store = NULL; if(!g_module_symbol(module->module, "set_params", (gpointer)&(module->set_params))) goto error; if(!g_module_symbol(module->module, "supported", (gpointer)&(module->supported))) module->supported = _default_supported; if(!g_module_symbol(module->module, "dimension", (gpointer)&(module->dimension))) module->dimension = _default_storage_dimension; if(!g_module_symbol(module->module, "recommended_dimension", (gpointer)&(module->recommended_dimension))) module->recommended_dimension = _default_storage_dimension; return 0; error: fprintf(stderr, "[imageio_load_module] failed to open storage `%s': %s\n", plugin_name, g_module_error()); if(module->module) g_module_close(module->module); return 1; }
char * plugin_load (session *sess, char *filename, char *arg) { void *handle; gpointer init_func; // => xchat_init_func gpointer deinit_func; // => xchat_deinit_func /* load the plugin */ handle = g_module_open (filename, 0); if (handle == NULL) return (char *)g_module_error (); /* find the init routine xchat_plugin_init */ if (!g_module_symbol (handle, "xchat_plugin_init", &init_func)) { g_module_close (handle); return _("No xchat_plugin_init symbol; is this really an xchat plugin?"); } /* find the plugin's deinit routine, if any */ if (!g_module_symbol (handle, "xchat_plugin_deinit", &deinit_func)) deinit_func = NULL; /* add it to our linked list */ plugin_add (sess, filename, handle, init_func, deinit_func, arg, FALSE); return NULL; }