Plugin library

Plugin loading and unloading. More...

Collaboration diagram for Plugin library:

Typedefs
typedef void *(*	GNUNET_PLUGIN_Callback) (void *arg)
	Signature of any function exported by a plugin. More...
typedef void(*	GNUNET_PLUGIN_LoaderCallback) (void *cls, const char *library_name, void *lib_ret)
	Signature of a function called by GNUNET_PLUGIN_load_all(). More...

Functions
int	GNUNET_PLUGIN_test (const char *library_name)
	Test if a plugin exists. More...
void *	GNUNET_PLUGIN_load (const char *library_name, void *arg)
	Setup plugin (runs the "init" callback and returns whatever "init" returned). More...
void	GNUNET_PLUGIN_load_all (const char *basename, void *arg, GNUNET_PLUGIN_LoaderCallback cb, void *cb_cls)
	Load all compatible plugins with the given base name. More...
void	GNUNET_PLUGIN_load_all_in_context (const struct GNUNET_OS_ProjectData *ctx, const char *basename, void *arg, GNUNET_PLUGIN_LoaderCallback cb, void *cb_cls)
	Load all compatible plugins with the given base name while inside the given context (i.e. More...
void *	GNUNET_PLUGIN_unload (const char *library_name, void *arg)
	Unload plugin (runs the "done" callback and returns whatever "done" returned). More...

Detailed Description

Plugin loading and unloading.

Typedef Documentation

GNUNET_PLUGIN_Callback

typedef void*(* GNUNET_PLUGIN_Callback) (void *arg)

Signature of any function exported by a plugin.

Parameters

arg	argument to the function (context)

Returns

some pointer, NULL if the plugin was shutdown or if there was an error, otherwise the plugin's API on success

Definition at line 60 of file gnunet_plugin_lib.h.

GNUNET_PLUGIN_LoaderCallback

typedef void(* GNUNET_PLUGIN_LoaderCallback) (void *cls, const char *library_name, void *lib_ret)

Signature of a function called by GNUNET_PLUGIN_load_all().

Parameters

cls	closure
library_name	full name of the library (to be used with GNUNET_PLUGIN_unload)
lib_ret	return value from the initialization function of the library (same as what GNUNET_PLUGIN_load would have returned for the given library name)

Definition at line 104 of file gnunet_plugin_lib.h.

Function Documentation

GNUNET_PLUGIN_test()

int GNUNET_PLUGIN_test

(

const char *

library_name

)

Test if a plugin exists.

Note that the library must export a symbol called "library_name_init" for the test to succeed.

Parameters

library_name

name of the plugin to test if it is installed

Returns

GNUNET_YES if the plugin exists, GNUNET_NO if not

Definition at line 141 of file plugin.c.

{
  void *libhandle;
  GNUNET_PLUGIN_Callback init;
  struct PluginList plug;
 
  if (! initialized)
  {
    initialized = GNUNET_YES;
    plugin_init ();
  }
  libhandle = lt_dlopenext (library_name);
  if (NULL == libhandle)
    return GNUNET_NO;
  plug.handle = libhandle;
  plug.name = (char *) library_name;
  init = resolve_function (&plug,
                           "init");
  if (NULL == init)
  {
    GNUNET_break (0);
    lt_dlclose (libhandle);
    return GNUNET_NO;
  }
  lt_dlclose (libhandle);
  return GNUNET_YES;
}

References _, GNUNET_asprintf(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, PluginList::handle, LOG, name, and PluginList::name.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PLUGIN_load()

void* GNUNET_PLUGIN_load	(	const char *	library_name,
		void *	arg
	)

Setup plugin (runs the "init" callback and returns whatever "init" returned).

If "init" returns NULL, the plugin is unloaded.

Note that the library must export symbols called "library_name_init" and "library_name_done". These will be called when the library is loaded and unloaded respectively.

Parameters

library_name	name of the plugin to load
arg	argument to the plugin initialization function

Returns

whatever the initialization function returned, NULL on error

Definition at line 198 of file plugin.c.

{
  void *libhandle;
  struct PluginList *plug;
  GNUNET_PLUGIN_Callback init;
  void *ret;
 
  if (! initialized)
  {
    initialized = GNUNET_YES;
    plugin_init ();
  }
  libhandle = lt_dlopenext (library_name);
  if (NULL == libhandle)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("`%s' failed for library `%s' with error: %s\n"),
         "lt_dlopenext",
         library_name,
         lt_dlerror ());
    return NULL;
  }
  plug = GNUNET_new (struct PluginList);
  plug->handle = libhandle;
  plug->name = GNUNET_strdup (library_name);
  plug->next = plugins;
  plugins = plug;
  init = resolve_function (plug,
                           "init");
  if ( (NULL == init) ||
       (NULL == (ret = init (arg))) )
  {
    lt_dlclose (libhandle);
    GNUNET_free (plug->name);
    plugins = plug->next;
    GNUNET_free (plug);
    return NULL;
  }
  return ret;
}

References _, find_typedefs::arg, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, GNUNET_strdup, GNUNET_YES, PluginList::handle, init, initialized, LOG, PluginList::name, PluginList::next, plugin_init(), plugins, resolve_function(), and ret.

Referenced by client_connect_cb(), find_libraries(), GAS_plugin_init(), GNUNET_ATS_solvers_solver_start(), GNUNET_DATACACHE_create(), GPI_plugins_load(), GST_plugins_load(), load_plugin(), load_underlay(), run(), start_helper(), and tokenizer_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PLUGIN_load_all()

void GNUNET_PLUGIN_load_all	(	const char *	basename,
		void *	arg,
		GNUNET_PLUGIN_LoaderCallback	cb,
		void *	cb_cls
	)

Load all compatible plugins with the given base name.

Note that the library must export symbols called "basename_ANYTHING_init" and "basename_ANYTHING__done". These will be called when the library is loaded and unloaded respectively.

Parameters

basename	basename of the plugins to load
arg	argument to the plugin initialization function
cb	function to call for each plugin found
cb_cls	closure for cb

Definition at line 359 of file plugin.c.

{
  struct LoadAllContext lac;
  char *path;
 
  path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
  if (NULL == path)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not determine plugin installation path.\n"));
    return;
  }
  lac.basename = basename;
  lac.arg = arg;
  lac.cb = cb;
  lac.cb_cls = cb_cls;
  GNUNET_DISK_directory_scan (path,
                              &find_libraries,
                              &lac);
  GNUNET_free (path);
}

References _, find_typedefs::arg, LoadAllContext::arg, LoadAllContext::basename, LoadAllContext::cb, LoadAllContext::cb_cls, find_libraries(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OS_installation_get_path(), and GNUNET_OS_IPK_LIBDIR.

Referenced by GNUNET_PLUGIN_load_all_in_context().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PLUGIN_load_all_in_context()

void GNUNET_PLUGIN_load_all_in_context	(	const struct GNUNET_OS_ProjectData *	ctx,
		const char *	basename,
		void *	arg,
		GNUNET_PLUGIN_LoaderCallback	cb,
		void *	cb_cls
	)

Load all compatible plugins with the given base name while inside the given context (i.e.

a specific project data structure.)

Note that the library must export symbols called basename_ANYTHING_init and basename_ANYTHING__done. These will be called when the library is loaded and unloaded respectively.

Parameters

ctx	the context used to find the plugins
basename	basename of the plugins to load
arg	argument to the plugin initialization function
cb	function to call for each plugin found
cb_cls	closure for cb

Definition at line 386 of file plugin.c.

{
  const struct GNUNET_OS_ProjectData *cpd = GNUNET_OS_project_data_get ();
 
  GNUNET_OS_init (ctx);
  GNUNET_PLUGIN_load_all (basename,
                          arg,
                          cb,
                          cb_cls);
  GNUNET_OS_init (cpd);
}

References find_typedefs::arg, ctx, GNUNET_OS_init(), GNUNET_OS_project_data_get(), and GNUNET_PLUGIN_load_all().

Referenced by GNUNET_BLOCK_context_create(), init(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PLUGIN_unload()

void* GNUNET_PLUGIN_unload	(	const char *	library_name,
		void *	arg
	)

Unload plugin (runs the "done" callback and returns whatever "done" returned).

The plugin is then unloaded.

Parameters

library_name	name of the plugin to unload
arg	argument to the plugin shutdown function

Returns

whatever the shutdown function returned, typically NULL or a "char *" representing the error message

Definition at line 242 of file plugin.c.

{
  struct PluginList *pos;
  struct PluginList *prev;
  GNUNET_PLUGIN_Callback done;
  void *ret;
 
  prev = NULL;
  pos = plugins;
  while ( (NULL != pos) &&
          (0 != strcmp (pos->name,
                        library_name)) )
  {
    prev = pos;
    pos = pos->next;
  }
  if (NULL == pos)
    return NULL;
 
  done = resolve_function (pos,
                           "done");
  ret = NULL;
  if (NULL == prev)
    plugins = pos->next;
  else
    prev->next = pos->next;
  if (NULL != done)
    ret = done (arg);
  if (NULL == getenv ("VALGRINDING_PLUGINS"))
    lt_dlclose (pos->handle);
  GNUNET_free (pos->name);
  GNUNET_free (pos);
  if (NULL == plugins)
  {
    plugin_fini ();
    initialized = GNUNET_NO;
  }
  return ret;
}

References find_typedefs::arg, done(), getenv(), GNUNET_free, GNUNET_NO, PluginList::handle, initialized, PluginList::name, PluginList::next, plugin_fini(), plugins, resolve_function(), and ret.

Referenced by __attribute__(), cleanup_task(), client_disconnect_cb(), do_shutdown(), GAS_plugin_done(), GNUNET_ATS_solvers_solver_stop(), GNUNET_BLOCK_context_destroy(), GNUNET_DATACACHE_destroy(), GPI_plugins_unload(), GST_plugins_load(), GST_plugins_unload(), run(), shutdown_task(), and unload_plugin().

Here is the call graph for this function:

Here is the caller graph for this function: