lib/eggdrop/module.c File Reference

#include <eggdrop/eggdrop.h>
#include <ltdl.h>
#include <unistd.h>

Go to the source code of this file.

Data Structures
struct	module_list
Defines
#define	find_active_module(name)   find_module((name), module_list_head)
#define	find_deleted_module(name)   find_module((name), deleted_head)
Typedefs
typedef struct module_list	module_list_t
Functions
static int	module_cleanup (void *ignored)
	Calls module_really_unload() for every module marked for unloading.
static module_list_t *	find_module (const char *name, module_list_t *head)
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_unload (const char *name, int why)
	Unload a module.
static void	module_really_unload (module_list_t *entry)
	Remove a module from the process's memory.
egg_module_t *	module_lookup (const char *name)
int	module_loaded (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)
Variables
static const char	rcsid [] = "$Id: module.c,v 1.15 2007-09-13 22:20:55 sven Exp $"
static module_list_t *	module_list_head = NULL
static module_list_t *	deleted_head = NULL
static bind_table_t *	BT_load
static bind_table_t *	BT_unload

---

Define Documentation

#define find_active_module

(

name

)

find_module((name), module_list_head)

Definition at line 41 of file module.c.

Referenced by module_addref(), module_decref(), module_get_api(), module_load(), module_loaded(), module_lookup(), and module_unload().

#define find_deleted_module

(

name

)

find_module((name), deleted_head)

Definition at line 42 of file module.c.

Referenced by module_load().

---

Typedef Documentation

typedef struct module_list module_list_t

---

Function Documentation

static module_list_t* find_module	(	const char *	name,
		module_list_t *	head
	)			[static]

Definition at line 44 of file module.c.

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

{
  module_list_t *entry;

  for (entry = head; entry; entry = entry->next) {
    if (!strcasecmp(name, entry->modinfo.name)) return(entry);
  }
  return(NULL);
}

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);
}

static int module_cleanup

(

void *

ignored

)

[static]

Calls module_really_unload() for every module marked for unloading.

This function is called automatically by garbage_run() if a module has has been closed.

Returns:

Always 0.

Definition at line 287 of file module.c.

References deleted_head, and module_really_unload().

Referenced by module_unload().

{
  while (deleted_head) module_really_unload(deleted_head);

  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);
}

static void module_really_unload

(

module_list_t *

entry

)

[static]

Remove a module from the process's memory.

Tis function will call the modules's unload function, remove all asyncronous events owned by this module and finally remove the module itself from memory.

Parameters:

entry

The module to remove. This must be in the list of deleted modules.

Definition at line 247 of file module.c.

References deleted_head, egg_module::event_cleanup, module_list::hand, LOG_MISC, module_list::modinfo, egg_module::name, module_list::next, module_list::prev, putlog(), script_remove_events_by_owner(), and egg_module::unload_func.

Referenced by module_cleanup().

{
  int errors;
  const char *error;
  module_list_t *m;

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

  if (entry->modinfo.unload_func) entry->modinfo.unload_func();

  script_remove_events_by_owner(&entry->modinfo, 0);

  for (m = module_list_head; m; m = m->next) {
    if (m->modinfo.event_cleanup) m->modinfo.event_cleanup(&entry->modinfo);
  }
  
  for (m = deleted_head; m; m = m->next) {
    if (m->modinfo.event_cleanup) m->modinfo.event_cleanup(&entry->modinfo);
  }
  
  errors = lt_dlclose(entry->hand);
  if (errors) {
    putlog(LOG_MISC, "*", "Error unloading %s!", entry->modinfo.name);
    while ((error = lt_dlerror())) putlog(LOG_MISC, "*", "ltdlerror: %s", error);
  }

  free(entry);
}

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;
}

---

Variable Documentation

bind_table_t* BT_load [static]

Definition at line 37 of file module.c.

bind_table_t * BT_unload [static]

Definition at line 37 of file module.c.

module_list_t * deleted_head = NULL [static]

Definition at line 36 of file module.c.

Referenced by module_cleanup(), module_really_unload(), and module_unload().

module_list_t* module_list_head = NULL [static]

Definition at line 36 of file module.c.

const char rcsid[] = "$Id: module.c,v 1.15 2007-09-13 22:20:55 sven Exp $" [static]

Definition at line 21 of file module.c.