lib/eggdrop/module.h File Reference

Go to the source code of this file.

Data Structures
struct	egg_module
Defines
#define	MODULE_USER   0
#define	MODULE_SHUTDOWN   1
#define	MODULE_RESTART   2
#define	BTN_LOAD_MODULE   "load"
#define	BTN_UNLOAD_MODULE   "unload"
#define	EXPORT_SCOPE
Typedefs
typedef struct egg_module	egg_module_t
typedef int(*	egg_start_func_t )(egg_module_t *modinfo)
typedef int(*	egg_close_func_t )(int why)
typedef void(*	egg_unload_func_t )(void)
typedef void(*	egg_cleanup_hook_t )(egg_module_t *mod)
Functions
int	module_init (void)
int	module_shutdown (void)
	Shuts down the module interface.
int	module_add_dir (const char *moddir)
int	module_load (const char *name)
	Load a module.
int	module_loaded (const char *name)
int	module_unload (const char *name, int why)
	Unload a module.
egg_module_t *	module_lookup (const char *name)
void *	module_get_api (const char *name, int major, int minor)
int	module_addref (const char *name)
int	module_decref (const char *name)
int	module_list (const char ***names)

---

Define Documentation

#define BTN_LOAD_MODULE   "load"

Definition at line 31 of file module.h.

Referenced by module_init().

#define BTN_UNLOAD_MODULE   "unload"

Definition at line 32 of file module.h.

Referenced by module_init().

#define EXPORT_SCOPE

Definition at line 75 of file module.h.

#define MODULE_RESTART   2

Definition at line 28 of file module.h.

Referenced by module_shutdown().

#define MODULE_SHUTDOWN   1

Definition at line 27 of file module.h.

Referenced by module_unload().

#define MODULE_USER   0

Definition at line 26 of file module.h.

Referenced by module_unload(), party_unloadmod(), and script_module_unload().

---

Typedef Documentation

typedef void(* egg_cleanup_hook_t)(egg_module_t *mod)

Definition at line 40 of file module.h.

typedef int(* egg_close_func_t)(int why)

Definition at line 38 of file module.h.

typedef struct egg_module egg_module_t

Definition at line 35 of file module.h.

typedef int(* egg_start_func_t)(egg_module_t *modinfo)

Definition at line 37 of file module.h.

typedef void(* egg_unload_func_t)(void)

Definition at line 39 of file module.h.

---

Function Documentation

int module_add_dir

(

const char *

moddir

)

Definition at line 95 of file module.c.

References egg_mprintf().

Referenced by core_init().

{
  char *fixed_moddir;

  if (*moddir != '/') {
    char cwd[1024];

    cwd[0] = 0;
    getcwd(cwd, sizeof(cwd));
    cwd[sizeof(cwd)-1] = 0;
    fixed_moddir = egg_mprintf("%s/%s", cwd, moddir);
  }
  else fixed_moddir = (char *)moddir;

  lt_dladdsearchdir(fixed_moddir);
  if (fixed_moddir != moddir) free(fixed_moddir);
  return(0);
}

int module_addref

(

const char *

name

)

Definition at line 320 of file module.c.

References find_active_module, and module_list::refcount.

{
  module_list_t *entry;

  entry = find_active_module(name);
  if (!entry) return(-1);
  entry->refcount++;
  return(0);
}

int module_decref

(

const char *

name

)

Definition at line 330 of file module.c.

References find_active_module, and module_list::refcount.

{
  module_list_t *entry;

  entry = find_active_module(name);
  if (!entry) return(-1);
  entry->refcount--;
  return(0);
}

void* module_get_api	(	const char *	name,
		int	major,
		int	minor
	)

Definition at line 310 of file module.c.

References find_active_module, module_list::modinfo, egg_module::module_api, NULL, and module_list::refcount.

Referenced by chanserv_init().

{
  module_list_t *entry;

  entry = find_active_module(name);
  if (!entry) return(NULL);
  entry->refcount++;
  return entry->modinfo.module_api;
}

int module_init

(

void

)

Definition at line 54 of file module.c.

References bind_table_add(), BTN_LOAD_MODULE, BTN_UNLOAD_MODULE, and MATCH_MASK.

Referenced by eggdrop_init().

{
  BT_load = bind_table_add(BTN_LOAD_MODULE, 1, "s", MATCH_MASK, 0);   /* DDD  */
  BT_unload = bind_table_add(BTN_UNLOAD_MODULE, 2, "ss", MATCH_MASK, 0);    /* DDD  */
  return(0);
}

int module_list

(

const char ***

names

)

Definition at line 340 of file module.c.

References module_list::modinfo, egg_module::name, module_list::next, and NULL.

Referenced by party_modules().

{
  module_list_t *entry;
  int i = 0;

  for (entry = module_list_head; entry; entry = entry->next) i++;
  *names = malloc((i + 1) * sizeof(char **));
  i = 0;
  for (entry = module_list_head; entry; entry = entry->next) {
    (*names)[i] = entry->modinfo.name;
    i++;
  }
  (*names)[i] = NULL;
  return(i);
}

int module_load

(

const char *

name

)

Load a module.

This function loads a module and executes its start function. If the module name does not contain a path the default paths will be searched. If it does have an extenteion the plattforms default library extentions will be added.

Parameters:

name

The name of the module to load.

Returns:

0 on success. (This will be logged.)

-1 if the module is already loaded. (Nothing will be logged.)

-2 if the module could not be opened. (This will be logged.)

-3 if no start function is present. (Nothing will be logged.)

-4 if the start function returned an error. (Nothing will be logged.)

-5 if the module can't be loaded because it's marked for unloading. (Nothing will be logged.)

Definition at line 131 of file module.c.

References bind_check(), egg_mprintf(), find_active_module, find_deleted_module, module_list::hand, LOG_MISC, module_list::modinfo, module_list::next, NULL, module_list::prev, putlog(), and module_list::refcount.

Referenced by core_init(), and party_loadmod().

{
  lt_dlhandle hand;
  module_list_t *entry;
  egg_start_func_t startfunc;
  char *startname;


  /* See if it's already loaded. */
  entry = find_active_module(name);
  if (entry) return(-1);
  entry = find_deleted_module(name);
  if (entry) return(-5);

  hand = lt_dlopenext(name);
  if (!hand) {
    const char *err = lt_dlerror();
    putlog(LOG_MISC, "*", "Error loading module %s: %s", name, err);
    return(-2);
  }

  startname = egg_mprintf("%s_LTX_start", name);
  startfunc = (egg_start_func_t)lt_dlsym(hand, startname);
  free(startname);
  if (!startfunc) {
    startfunc = (egg_start_func_t)lt_dlsym(hand, "start");
    if (!startfunc) {
      lt_dlclose(hand);
      return(-3);
    }
  }

  /* Create an entry for it. */
  entry = calloc(1, sizeof(*entry));
  entry->prev = NULL;
  entry->next = module_list_head;
  entry->refcount = 0;
  entry->hand = hand;
  module_list_head = entry;

  if (startfunc(&entry->modinfo)) {
    module_list_head = module_list_head->next;
    free(entry);
    return(-4);
  }

  putlog(LOG_MISC, "*", "Module loaded: %s", name);
  bind_check(BT_load, NULL, name, name);

  return(0);
}

int module_loaded

(

const char *

name

)

Definition at line 303 of file module.c.

References find_active_module, and NULL.

{
  if (name == NULL) return 0;

  return (find_active_module(name) != NULL);
}

egg_module_t* module_lookup

(

const char *

name

)

Definition at line 294 of file module.c.

References find_active_module, module_list::modinfo, and NULL.

{
  module_list_t *entry;

  entry = find_active_module(name);
  if (entry) return(&entry->modinfo);
  return(NULL);
}

int module_shutdown

(

void

)

Shuts down the module interface.

This function unloads all loaded modules and deletes the load and unload bind tables.

The module_unload() function is called for every module that is currently loaded. If there is still a module loaded, for example because of dependencies, module_unload() is called again. This is done until either all modules have been unloaded or no more modules could be unloaded.

Returns:

Always 0.

Definition at line 75 of file module.c.

References bind_table_del(), garbage_run(), module_list::modinfo, MODULE_RESTART, module_unload(), egg_module::name, and module_list::next.

Referenced by eggdrop_shutdown().

{
  int unloaded;
  module_list_t *entry, *next;

  do {
    unloaded = 0;
    for (entry = module_list_head; entry; entry = next) {
      next = entry->next;
      if (!module_unload(entry->modinfo.name, MODULE_RESTART)) unloaded = 1;
    }
  } while (unloaded);

  bind_table_del(BT_load);
  bind_table_del(BT_unload);

  garbage_run();
  return (0);
}

int module_unload	(	const char *	name,
		int	why
	)

Unload a module.

If a module's reference count is 0 its closing function will be executed. If the closing function did not veto the unloading it will be removed from the list of active modules, the "unload" bind is triggered and a cleanup run is sceduled.

Parameters:

	name	The name of the module to unload.
	why	The reason this function was called: MODULE_USER, MODULE_RESTART or MODULE_SHUTDOWN.

Returns:

0 on success. (This will be logged.)

-1 if the module is not loaded. (Nothing will be logged.)

-2 if the module is in use by another module. (Nothing will be logged.)

-3 if the module's closing function vetoed. (Nothing will be logged.)

Definition at line 201 of file module.c.

References bind_check(), egg_module::close_func, deleted_head, find_active_module, garbage_add(), GARBAGE_ONCE, LOG_MISC, module_list::modinfo, module_cleanup(), MODULE_SHUTDOWN, MODULE_USER, module_list::next, NULL, module_list::prev, putlog(), and module_list::refcount.

Referenced by module_shutdown(), party_unloadmod(), and script_module_unload().

{
  module_list_t *entry;
  int retval;

  entry = find_active_module(name);
  if (!entry) return(-1);
  if (entry->refcount > 0) return(-2);
  if (entry->modinfo.close_func) {
    retval = entry->modinfo.close_func(why);
    if (retval) return(-3);
  }

  if (entry->prev) entry->prev->next = entry->next;
  else module_list_head = entry->next;
  if (entry->next) entry->next->prev = entry->prev;

  entry->next = NULL;
  if (!deleted_head) {
    deleted_head = entry;
    entry->prev = NULL;
  } else {
    module_list_t *tail;

    for (tail = deleted_head; tail->next; tail = tail->next);
    tail->next = entry;
    entry->prev = tail;
  }

  bind_check(BT_unload, NULL, name, name, why == MODULE_USER ? "request" : why == MODULE_SHUTDOWN ? "shutdown" : "restart");
  putlog(LOG_MISC, "*", "Module unloaded: %s", name);
  garbage_add(module_cleanup, NULL, GARBAGE_ONCE);
  return 0;
}