loader.c File Reference

Module Loader. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/paths.h"
#include <dirent.h>
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/channel.h"
#include "asterisk/term.h"
#include "asterisk/manager.h"
#include "asterisk/cdr.h"
#include "asterisk/enum.h"
#include "asterisk/http.h"
#include "asterisk/lock.h"
#include "asterisk/features.h"
#include "asterisk/dsp.h"
#include "asterisk/udptl.h"
#include "asterisk/heap.h"
#include "asterisk/app.h"
#include <dlfcn.h>
#include "asterisk/md5.h"
#include "asterisk/utils.h"

Include dependency graph for loader.c:

Go to the source code of this file.

Data Structures
struct	ast_module
struct	ast_module_user
struct	load_order
struct	load_order_entry
struct	loadupdate
struct	module_list
struct	module_user_list
struct	reload_classes
struct	reload_queue
struct	reload_queue_item
struct	updaters
Defines
#define	RTLD_LOCAL   0
#define	RTLD_NOW   0
Functions
struct ast_module_user *	__ast_module_user_add (struct ast_module *mod, struct ast_channel *chan)
void	__ast_module_user_hangup_all (struct ast_module *mod)
void	__ast_module_user_remove (struct ast_module *mod, struct ast_module_user *u)
static struct load_order_entry *	add_to_load_order (const char *resource, struct load_order *load_order, int required)
int	ast_load_resource (const char *resource_name)
	Load a module.
int	ast_loader_register (int(*v)(void))
	Add a procedure to be run when modules have been updated.
int	ast_loader_unregister (int(*v)(void))
	Remove a procedure to be run when modules are updated.
int	ast_module_check (const char *name)
	Check if module exists.
char *	ast_module_helper (const char *line, const char *word, int pos, int state, int rpos, int needsreload)
	Match modules names for the Asterisk cli.
struct ast_module *	ast_module_ref (struct ast_module *mod)
void	ast_module_register (const struct ast_module_info *info)
int	ast_module_reload (const char *name)
	Reload asterisk modules.
void	ast_module_shutdown (void)
	Run the unload() callback for all loaded modules.
void	ast_module_unref (struct ast_module *mod)
void	ast_module_unregister (const struct ast_module_info *info)
void	ast_process_pending_reloads (void)
	Process reload requests received during startup.
int	ast_unload_resource (const char *resource_name, enum ast_module_unload_mode force)
	Unload a module.
int	ast_update_module_list (int(*modentry)(const char *module, const char *description, int usecnt, const char *like), const char *like)
	Ask for a list of modules, descriptions, and use counts.
void	ast_update_use_count (void)
	Notify when usecount has been changed.
static struct ast_module *	find_resource (const char *resource, int do_lock)
static unsigned int	inspect_module (const struct ast_module *mod)
static int	key_matches (const unsigned char *key1, const unsigned char *key2)
static struct ast_module *	load_dynamic_module (const char *resource_in, unsigned int global_symbols_only)
int	load_modules (unsigned int preload_only)
static enum ast_module_load_result	load_resource (const char *resource_name, unsigned int global_symbols_only, struct ast_heap *resource_heap, int required)
static int	load_resource_list (struct load_order *load_order, unsigned int global_symbols, int *mod_count)
static int	mod_load_cmp (void *a, void *b)
static int	printdigest (const unsigned char *d)
static void	queue_reload_request (const char *module)
static int	resource_name_match (const char *name1_in, const char *name2_in)
static enum ast_module_load_result	start_resource (struct ast_module *mod)
static void	unload_dynamic_module (struct ast_module *mod)
static int	verify_key (const unsigned char *key)
Variables
static char	buildopt_sum [33] = AST_BUILDOPT_SUM
static int	do_full_reload = 0
static struct module_list	embedded_module_list
static unsigned int	embedding = 1
static const unsigned char	expected_key []
static struct module_list	module_list
static struct reload_classes	reload_classes []
static struct reload_queue	reload_queue
static ast_mutex_t	reloadlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 }
static struct ast_module *	resource_being_loaded
static struct updaters	updaters

---

Detailed Description

Module Loader.

Author:

Mark Spencer <markster@digium.com>

Kevin P. Fleming <kpfleming@digium.com>

Luigi Rizzo <rizzo@icir.org>

• See ModMngMnt

Definition in file loader.c.

---

Define Documentation

#define RTLD_LOCAL   0

Definition at line 64 of file loader.c.

Referenced by load_dynamic_module().

#define RTLD_NOW   0

Definition at line 60 of file loader.c.

Referenced by load_dynamic_module().

---

Function Documentation

struct ast_module_user* __ast_module_user_add	(	struct ast_module *	mod,
		struct ast_channel *	chan
	)		[read]

Definition at line 195 of file loader.c.

References ast_calloc, ast_module_user::chan, AST_LIST_LOCK, ast_module::users, AST_LIST_INSERT_HEAD, AST_LIST_UNLOCK, ast_atomic_fetchadd_int(), ast_module::usecount, and ast_update_use_count().

Referenced by pbx_exec(), ast_func_read(), ast_func_read2(), and ast_func_write().

{
   struct ast_module_user *u = ast_calloc(1, sizeof(*u));

   if (!u)
      return NULL;

   u->chan = chan;

   AST_LIST_LOCK(&mod->users);
   AST_LIST_INSERT_HEAD(&mod->users, u, entry);
   AST_LIST_UNLOCK(&mod->users);

   ast_atomic_fetchadd_int(&mod->usecount, +1);

   ast_update_use_count();

   return u;
}

void __ast_module_user_hangup_all

(

struct ast_module *

mod

)

Definition at line 227 of file loader.c.

References AST_LIST_LOCK, ast_module::users, AST_LIST_REMOVE_HEAD, ast_softhangup(), ast_module_user::chan, AST_SOFTHANGUP_APPUNLOAD, ast_atomic_fetchadd_int(), ast_module::usecount, ast_free, AST_LIST_UNLOCK, and ast_update_use_count().

Referenced by ast_unload_resource().

{
   struct ast_module_user *u;

   AST_LIST_LOCK(&mod->users);
   while ((u = AST_LIST_REMOVE_HEAD(&mod->users, entry))) {
      ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
      ast_atomic_fetchadd_int(&mod->usecount, -1);
      ast_free(u);
   }
   AST_LIST_UNLOCK(&mod->users);

   ast_update_use_count();
}

void __ast_module_user_remove	(	struct ast_module *	mod,
		struct ast_module_user *	u
	)

Definition at line 216 of file loader.c.

References AST_LIST_LOCK, ast_module::users, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_atomic_fetchadd_int(), ast_module::usecount, ast_free, and ast_update_use_count().

Referenced by pbx_exec(), ast_func_read(), ast_func_read2(), and ast_func_write().

{
   AST_LIST_LOCK(&mod->users);
   AST_LIST_REMOVE(&mod->users, u, entry);
   AST_LIST_UNLOCK(&mod->users);
   ast_atomic_fetchadd_int(&mod->usecount, -1);
   ast_free(u);

   ast_update_use_count();
}

static struct load_order_entry* add_to_load_order	(	const char *	resource,
		struct load_order *	load_order,
		int	required
	)		[static, read]

Definition at line 894 of file loader.c.

References AST_LIST_TRAVERSE, resource_name_match(), load_order_entry::resource, load_order_entry::required, ast_calloc, ast_strdup, and AST_LIST_INSERT_TAIL.

Referenced by load_modules().

{
   struct load_order_entry *order;

   AST_LIST_TRAVERSE(load_order, order, entry) {
      if (!resource_name_match(order->resource, resource)) {
         /* Make sure we have the proper setting for the required field 
            (we might have both load= and required= lines in modules.conf) */
         order->required |= required;
         return NULL;
      }
   }

   if (!(order = ast_calloc(1, sizeof(*order))))
      return NULL;

   order->resource = ast_strdup(resource);
   order->required = required;
   AST_LIST_INSERT_TAIL(load_order, order, entry);

   return order;
}

int ast_load_resource

(

const char *

resource_name

)

Load a module.

Parameters:

resource_name

The name of the module to load.

This function is run by the PBX to load the modules. It performs all loading and initialization tasks. Basically, to load a module, just give it the name of the module and it will do the rest.

Returns:

See possible enum values for ast_module_load_result.

Definition at line 876 of file loader.c.

References AST_LIST_LOCK, load_resource(), and AST_LIST_UNLOCK.

Referenced by handle_load(), load_module(), and manager_moduleload().

{
   int res;
   AST_LIST_LOCK(&module_list);
   res = load_resource(resource_name, 0, NULL, 0);
   AST_LIST_UNLOCK(&module_list);

   return res;
}

int ast_loader_register

(

int(*)(void)

updater

)

Add a procedure to be run when modules have been updated.

Parameters:

updater

The function to run when modules have been updated.

This function adds the given function to a linked list of functions to be run when the modules are updated.

Return values:

0	on success
-1	on failure.

Definition at line 1192 of file loader.c.

References ast_malloc, loadupdate::updater, AST_LIST_LOCK, AST_LIST_INSERT_HEAD, and AST_LIST_UNLOCK.

{
   struct loadupdate *tmp;

   if (!(tmp = ast_malloc(sizeof(*tmp))))
      return -1;

   tmp->updater = v;
   AST_LIST_LOCK(&updaters);
   AST_LIST_INSERT_HEAD(&updaters, tmp, entry);
   AST_LIST_UNLOCK(&updaters);

   return 0;
}

int ast_loader_unregister

(

int(*)(void)

updater

)

Remove a procedure to be run when modules are updated.

Parameters:

updater

The updater function to unregister.

This removes the given function from the updater list.

Return values:

0	on success
-1	on failure.

Definition at line 1207 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE_SAFE_BEGIN, loadupdate::updater, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_END, and AST_LIST_UNLOCK.

{
   struct loadupdate *cur;

   AST_LIST_LOCK(&updaters);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, entry) {
      if (cur->updater == v)  {
         AST_LIST_REMOVE_CURRENT(entry);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&updaters);

   return cur ? 0 : -1;
}

int ast_module_check

(

const char *

name

)

Check if module exists.

Check if module with the name given is loaded.

Definition at line 1179 of file loader.c.

References ast_strlen_zero(), and find_resource().

Referenced by load_module(), ifmodule_read(), manager_modulecheck(), and unload_module().

{
   struct ast_module *cur;

   if (ast_strlen_zero(name))
      return 0;       /* FALSE */

   cur = find_resource(name, 1);

   return (cur != NULL);
}

char* ast_module_helper	(	const char *	line,
		const char *	word,
		int	pos,
		int	state,
		int	rpos,
		int	needsreload
	)

Match modules names for the Asterisk cli.

Parameters:

line	Unused by this function, but this should be the line we are matching.
word	The partial name to match.
pos	The position the word we are completing is in.
state	The possible match to return.
rpos	The position we should be matching. This should be the same as pos.
needsreload	This should be 1 if we need to reload this module and 0 otherwise. This function will only return modules that are reloadble if this is 1.

Return values:

A	possible completion of the partial match.
NULL	if no matches were found.

Definition at line 565 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, ast_module::resource, ast_module::info, ast_module_info::reload, ast_strdup, AST_LIST_UNLOCK, reload_classes::name, and name.

Referenced by conf_run(), load_module(), handle_reload(), handle_unload(), and handle_modlist().

{
   struct ast_module *cur;
   int i, which=0, l = strlen(word);
   char *ret = NULL;

   if (pos != rpos)
      return NULL;

   AST_LIST_LOCK(&module_list);
   AST_LIST_TRAVERSE(&module_list, cur, entry) {
      if (!strncasecmp(word, cur->resource, l) &&
          (cur->info->reload || !needsreload) &&
          ++which > state) {
         ret = ast_strdup(cur->resource);
         break;
      }
   }
   AST_LIST_UNLOCK(&module_list);

   if (!ret) {
      for (i=0; !ret && reload_classes[i].name; i++) {
         if (!strncasecmp(word, reload_classes[i].name, l) && ++which > state)
            ret = ast_strdup(reload_classes[i].name);
      }
   }

   return ret;
}

struct ast_module* ast_module_ref

(

struct ast_module *

mod

)

[read]

Definition at line 1224 of file loader.c.

References ast_atomic_fetchadd_int(), ast_module::usecount, and ast_update_use_count().

Referenced by load_module(), find_best_technology(), alsa_new(), my_module_ref(), dahdi_new(), gtalk_new(), __oh323_new(), ast_iax2_new(), mgcp_new(), oss_new(), phone_new(), phone_check_exception(), sip_handle_cc(), sip_new(), skinny_new(), usbradio_new(), data_result_generate_node(), fn_wrapper(), ast_agi_register(), agi_handle_command(), handle_orig(), handle_cli_file_convert(), ast_fax_tech_register(), fax_session_reserve(), fax_session_new(), moh_files_alloc(), moh_alloc(), mute_add_audiohook(), smdi_load(), ast_srtp_create(), ast_rtp_instance_new(), ast_timer_open(), and newpvt().

{
   if (!mod) {
      return NULL;
   }

   ast_atomic_fetchadd_int(&mod->usecount, +1);
   ast_update_use_count();

   return mod;
}

void ast_module_register

(

const struct ast_module_info *

info

)

Definition at line 133 of file loader.c.

References embedding, ast_calloc, ast_module::resource, resource_being_loaded, ast_module::info, AST_LIST_HEAD_INIT, ast_module::users, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, and AST_LIST_UNLOCK.

{
   struct ast_module *mod;

   if (embedding) {
      if (!(mod = ast_calloc(1, sizeof(*mod) + strlen(info->name) + 1)))
         return;
      strcpy(mod->resource, info->name);
   } else {
      mod = resource_being_loaded;
   }

   mod->info = info;
   AST_LIST_HEAD_INIT(&mod->users);

   /* during startup, before the loader has been initialized,
      there are no threads, so there is no need to take the lock
      on this list to manipulate it. it is also possible that it
      might be unsafe to use the list lock at that point... so
      let's avoid it altogether
   */
   if (embedding) {
      AST_LIST_INSERT_TAIL(&embedded_module_list, mod, entry);
   } else {
      AST_LIST_LOCK(&module_list);
      /* it is paramount that the new entry be placed at the tail of
         the list, otherwise the code that uses dlopen() to load
         dynamic modules won't be able to find out if the module it
         just opened was registered or failed to load
      */
      AST_LIST_INSERT_TAIL(&module_list, mod, entry);
      AST_LIST_UNLOCK(&module_list);
   }

   /* give the module a copy of its own handle, for later use in registrations and the like */
   *((struct ast_module **) &(info->self)) = mod;
}

int ast_module_reload

(

const char *

name

)

Reload asterisk modules.

Parameters:

name	the name of the module to reload

This function reloads the specified module, or if no modules are specified, it will reload all loaded modules.

Note:

Modules are reloaded using their reload() functions, not unloading them and loading them again.

Returns:

0 if the specified module was not found.

Return values:

1	if the module was found but cannot be reloaded.
-1	if a reload operation is already in progress.
2	if the specfied module was found and reloaded.

Definition at line 660 of file loader.c.

References ast_fully_booted, queue_reload_request(), ast_mutex_trylock, ast_verbose(), ast_lastreloadtime, ast_tvnow(), ast_opt_lock_confdir, AST_LOCK_TIMEOUT, ast_lock_path(), ast_config_AST_CONFIG_DIR, ast_log(), LOG_WARNING, AST_LOCK_SUCCESS, ast_mutex_unlock, reload_classes::name, reload_classes::reload_fn, ast_unlock_path(), AST_LIST_LOCK, AST_LIST_TRAVERSE, ast_module::info, resource_name_match(), ast_module::resource, ast_module::flags, ast_module::running, ast_module::declined, LOG_NOTICE, ast_module_info::reload, ast_verb, ast_module_info::description, and AST_LIST_UNLOCK.

Referenced by monitor_sig_flags(), handle_reload(), handle_core_reload(), ast_process_pending_reloads(), action_updateconfig(), action_reload(), and manager_moduleload().

{
   struct ast_module *cur;
   int res = 0; /* return value. 0 = not found, others, see below */
   int i;

   /* If we aren't fully booted, we just pretend we reloaded but we queue this
      up to run once we are booted up. */
   if (!ast_fully_booted) {
      queue_reload_request(name);
      return 0;
   }

   if (ast_mutex_trylock(&reloadlock)) {
      ast_verbose("The previous reload command didn't finish yet\n");
      return -1;  /* reload already in progress */
   }
   ast_lastreloadtime = ast_tvnow();

   if (ast_opt_lock_confdir) {
      int try;
      int res;
      for (try = 1, res = AST_LOCK_TIMEOUT; try < 6 && (res == AST_LOCK_TIMEOUT); try++) {
         res = ast_lock_path(ast_config_AST_CONFIG_DIR);
         if (res == AST_LOCK_TIMEOUT) {
            ast_log(LOG_WARNING, "Failed to grab lock on %s, try %d\n", ast_config_AST_CONFIG_DIR, try);
         }
      }
      if (res != AST_LOCK_SUCCESS) {
         ast_verbose("Cannot grab lock on %s\n", ast_config_AST_CONFIG_DIR);
         ast_mutex_unlock(&reloadlock);
         return -1;
      }
   }

   /* Call "predefined" reload here first */
   for (i = 0; reload_classes[i].name; i++) {
      if (!name || !strcasecmp(name, reload_classes[i].name)) {
         reload_classes[i].reload_fn();   /* XXX should check error ? */
         res = 2; /* found and reloaded */
      }
   }

   if (name && res) {
      if (ast_opt_lock_confdir) {
         ast_unlock_path(ast_config_AST_CONFIG_DIR);
      }
      ast_mutex_unlock(&reloadlock);
      return res;
   }

   AST_LIST_LOCK(&module_list);
   AST_LIST_TRAVERSE(&module_list, cur, entry) {
      const struct ast_module_info *info = cur->info;

      if (name && resource_name_match(name, cur->resource))
         continue;

      if (!cur->flags.running || cur->flags.declined) {
         if (!name)
            continue;
         ast_log(LOG_NOTICE, "The module '%s' was not properly initialized.  "
            "Before reloading the module, you must run \"module load %s\" "
            "and fix whatever is preventing the module from being initialized.\n",
            name, name);
         res = 2; /* Don't report that the module was not found */
         break;
      }

      if (!info->reload) { /* cannot be reloaded */
         if (res < 1)   /* store result if possible */
            res = 1; /* 1 = no reload() method */
         continue;
      }

      res = 2;
      ast_verb(3, "Reloading module '%s' (%s)\n", cur->resource, info->description);
      info->reload();
   }
   AST_LIST_UNLOCK(&module_list);

   if (ast_opt_lock_confdir) {
      ast_unlock_path(ast_config_AST_CONFIG_DIR);
   }
   ast_mutex_unlock(&reloadlock);

   return res;
}

void ast_module_shutdown

(

void

)

Run the unload() callback for all loaded modules.

This function should be called when Asterisk is shutting down gracefully.

Note:

Some resources, like timers, are started up dynamically, and thus may be still in use, even if all channels are dead. We must therefore check the usecount before asking modules to unload.

If we go through the entire list without changing anything, ignore the usecounts and unload, then exit.

Definition at line 465 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE_SAFE_BEGIN, ast_module::usecount, AST_LIST_REMOVE_CURRENT, ast_module::flags, ast_module::running, ast_module::declined, ast_module::info, ast_module_info::unload, AST_LIST_HEAD_DESTROY, ast_module::users, free, AST_LIST_TRAVERSE_SAFE_END, and AST_LIST_UNLOCK.

Referenced by quit_handler().

{
   struct ast_module *mod;
   int somethingchanged = 1, final = 0;

   AST_LIST_LOCK(&module_list);

   /*!\note Some resources, like timers, are started up dynamically, and thus
    * may be still in use, even if all channels are dead.  We must therefore
    * check the usecount before asking modules to unload. */
   do {
      if (!somethingchanged) {
         /*!\note If we go through the entire list without changing
          * anything, ignore the usecounts and unload, then exit. */
         final = 1;
      }

      /* Reset flag before traversing the list */
      somethingchanged = 0;

      AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, mod, entry) {
         if (!final && mod->usecount) {
            continue;
         }
         AST_LIST_REMOVE_CURRENT(entry);
         if (mod->flags.running && !mod->flags.declined && mod->info->unload) {
            mod->info->unload();
         }
         AST_LIST_HEAD_DESTROY(&mod->users);
         free(mod);
         somethingchanged = 1;
      }
      AST_LIST_TRAVERSE_SAFE_END;
   } while (somethingchanged && !final);

   AST_LIST_UNLOCK(&module_list);
}

void ast_module_unref

(

struct ast_module *

mod

)

Definition at line 1236 of file loader.c.

References ast_atomic_fetchadd_int(), ast_module::usecount, and ast_update_use_count().

Referenced by destroy_bridge(), ast_bridge_check(), smart_bridge_operation(), alsa_hangup(), my_module_unref(), dahdi_hangup(), dahdi_destroy_channel_bynum(), gtalk_hangup(), oh323_hangup(), iax2_predestroy(), mgcp_hangup(), oss_hangup(), phone_hangup(), phone_check_exception(), sip_cc_monitor_destructor(), sip_hangup(), skinny_hangup(), usbradio_hangup(), data_result_generate_node(), filestream_destructor(), ast_agi_unregister(), agi_handle_command(), handle_orig(), handle_cli_file_convert(), ast_fax_tech_unregister(), destroy_session(), local_ast_moh_cleanup(), destroy_callback(), ast_smdi_interface_destroy(), ast_srtp_destroy(), instance_destructor(), ast_rtp_instance_new(), ast_timer_close(), and destroy().

{
   if (!mod) {
      return;
   }

   ast_atomic_fetchadd_int(&mod->usecount, -1);
   ast_update_use_count();
}

void ast_module_unregister

(

const struct ast_module_info *

info

)

Definition at line 171 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE_SAFE_BEGIN, ast_module::info, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, AST_LIST_HEAD_DESTROY, ast_module::users, and ast_free.

{
   struct ast_module *mod = NULL;

   /* it is assumed that the users list in the module structure
      will already be empty, or we cannot have gotten to this
      point
   */
   AST_LIST_LOCK(&module_list);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, mod, entry) {
      if (mod->info == info) {
         AST_LIST_REMOVE_CURRENT(entry);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&module_list);

   if (mod) {
      AST_LIST_HEAD_DESTROY(&mod->users);
      ast_free(mod);
   }
}

void ast_process_pending_reloads

(

void

)

Process reload requests received during startup.

This function requests that the loader execute the pending reload requests that were queued during server startup.

Note:

This function will do nothing if the server has not completely started up. Once called, the reload queue is emptied, and further invocations will have no affect.

Definition at line 595 of file loader.c.

References ast_fully_booted, AST_LIST_LOCK, do_full_reload, AST_LIST_UNLOCK, ast_log(), LOG_NOTICE, ast_module_reload(), AST_LIST_REMOVE_HEAD, reload_queue_item::module, and ast_free.

Referenced by main().

{
   struct reload_queue_item *item;

   if (!ast_fully_booted) {
      return;
   }

   AST_LIST_LOCK(&reload_queue);

   if (do_full_reload) {
      do_full_reload = 0;
      AST_LIST_UNLOCK(&reload_queue);
      ast_log(LOG_NOTICE, "Executing deferred reload request.\n");
      ast_module_reload(NULL);
      return;
   }

   while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
      ast_log(LOG_NOTICE, "Executing deferred reload request for module '%s'.\n", item->module);
      ast_module_reload(item->module);
      ast_free(item);
   }

   AST_LIST_UNLOCK(&reload_queue);
}

int ast_unload_resource	(	const char *	resource_name,
		enum	ast_module_unload_mode
	)

Unload a module.

Parameters:

resource_name	The name of the module to unload.
ast_module_unload_mode	The force flag. This should be set using one of the AST_FORCE flags.

This function unloads a module. It will only unload modules that are not in use (usecount not zero), unless AST_FORCE_FIRM or AST_FORCE_HARD is specified. Setting AST_FORCE_FIRM or AST_FORCE_HARD will unload the module regardless of consequences (NOT RECOMMENDED).

Return values:

0	on success.
-1	on error.

Definition at line 503 of file loader.c.

References AST_LIST_LOCK, find_resource(), AST_LIST_UNLOCK, ast_log(), LOG_WARNING, ast_module::flags, ast_module::running, ast_module::declined, ast_module::usecount, __ast_module_user_hangup_all(), ast_module::info, ast_module_info::unload, AST_FORCE_FIRM, ast_module::lib, ast_module_info::restore_globals, unload_dynamic_module(), and ast_update_use_count().

Referenced by handle_unload(), manager_moduleload(), and unload_module().

{
   struct ast_module *mod;
   int res = -1;
   int error = 0;

   AST_LIST_LOCK(&module_list);

   if (!(mod = find_resource(resource_name, 0))) {
      AST_LIST_UNLOCK(&module_list);
      ast_log(LOG_WARNING, "Unload failed, '%s' could not be found\n", resource_name);
      return -1;
   }

   if (!mod->flags.running || mod->flags.declined) {
      ast_log(LOG_WARNING, "Unload failed, '%s' is not loaded.\n", resource_name);
      error = 1;
   }

   if (!error && (mod->usecount > 0)) {
      if (force)
         ast_log(LOG_WARNING, "Warning:  Forcing removal of module '%s' with use count %d\n",
            resource_name, mod->usecount);
      else {
         ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name,
            mod->usecount);
         error = 1;
      }
   }

   if (!error) {
      __ast_module_user_hangup_all(mod);
      res = mod->info->unload();

      if (res) {
         ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
         if (force <= AST_FORCE_FIRM)
            error = 1;
         else
            ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
      }
   }

   if (!error)
      mod->flags.running = mod->flags.declined = 0;

   AST_LIST_UNLOCK(&module_list);

   if (!error && !mod->lib && mod->info && mod->info->restore_globals)
      mod->info->restore_globals();

#ifdef LOADABLE_MODULES
   if (!error)
      unload_dynamic_module(mod);
#endif

   if (!error)
      ast_update_use_count();

   return res;
}

int ast_update_module_list	(	int(*)(const char *module, const char *description, int usecnt, const char *like)	modentry,
		const char *	like
	)

Ask for a list of modules, descriptions, and use counts.

Parameters:

modentry	A callback to an updater function.
like	For each of the modules loaded, modentry will be executed with the resource, description, and usecount values of each particular module.

Returns:

the number of modules loaded

Definition at line 1158 of file loader.c.

References AST_LIST_TRYLOCK, AST_LIST_TRAVERSE, ast_module::resource, ast_module::info, ast_module_info::description, ast_module::usecount, and AST_LIST_UNLOCK.

Referenced by ast_var_Modules(), and handle_modlist().

{
   struct ast_module *cur;
   int unlock = -1;
   int total_mod_loaded = 0;

   if (AST_LIST_TRYLOCK(&module_list))
      unlock = 0;
 
   AST_LIST_TRAVERSE(&module_list, cur, entry) {
      total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount, like);
   }

   if (unlock)
      AST_LIST_UNLOCK(&module_list);

   return total_mod_loaded;
}

void ast_update_use_count

(

void

)

Notify when usecount has been changed.

This function calulates use counts and notifies anyone trying to keep track of them. It should be called whenever your module's usecount changes.

Note:

The ast_module_user_* functions take care of calling this function for you.

Definition at line 1146 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, loadupdate::updater, and AST_LIST_UNLOCK.

Referenced by oh323_request(), handle_request_do(), sip_request_call(), unistim_new(), __ast_module_user_add(), __ast_module_user_remove(), __ast_module_user_hangup_all(), ast_unload_resource(), start_resource(), ast_module_ref(), and ast_module_unref().

{
   /* Notify any module monitors that the use count for a
      resource has changed */
   struct loadupdate *m;

   AST_LIST_LOCK(&updaters);
   AST_LIST_TRAVERSE(&updaters, m, entry)
      m->updater();
   AST_LIST_UNLOCK(&updaters);
}

static struct ast_module* find_resource	(	const char *	resource,
		int	do_lock
	)		[static, read]

Definition at line 327 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, resource_name_match(), ast_module::resource, and AST_LIST_UNLOCK.

Referenced by load_dynamic_module(), ast_unload_resource(), load_resource(), load_modules(), and ast_module_check().

{
   struct ast_module *cur;

   if (do_lock)
      AST_LIST_LOCK(&module_list);

   AST_LIST_TRAVERSE(&module_list, cur, entry) {
      if (!resource_name_match(resource, cur->resource))
         break;
   }

   if (do_lock)
      AST_LIST_UNLOCK(&module_list);

   return cur;
}

static unsigned int inspect_module

(

const struct ast_module *

mod

)

[static]

Definition at line 749 of file loader.c.

References ast_module::info, ast_module_info::description, ast_log(), LOG_WARNING, ast_module::resource, ast_module_info::key, verify_key(), ast_strlen_zero(), ast_module_info::buildopt_sum, and buildopt_sum.

Referenced by load_resource().

{
   if (!mod->info->description) {
      ast_log(LOG_WARNING, "Module '%s' does not provide a description.\n", mod->resource);
      return 1;
   }

   if (!mod->info->key) {
      ast_log(LOG_WARNING, "Module '%s' does not provide a license key.\n", mod->resource);
      return 1;
   }

   if (verify_key((unsigned char *) mod->info->key)) {
      ast_log(LOG_WARNING, "Module '%s' did not provide a valid license key.\n", mod->resource);
      return 1;
   }

   if (!ast_strlen_zero(mod->info->buildopt_sum) &&
       strcmp(buildopt_sum, mod->info->buildopt_sum)) {
      ast_log(LOG_WARNING, "Module '%s' was not compiled with the same compile-time options as this version of Asterisk.\n", mod->resource);
      ast_log(LOG_WARNING, "Module '%s' will not be initialized as it may cause instability.\n", mod->resource);
      return 1;
   }

   return 0;
}

static int key_matches	(	const unsigned char *	key1,
		const unsigned char *	key2
	)		[static]

Definition at line 280 of file loader.c.

Referenced by verify_key().

{
   int x;

   for (x = 0; x < 16; x++) {
      if (key1[x] != key2[x])
         return 0;
   }

   return 1;
}

static struct ast_module* load_dynamic_module	(	const char *	resource_in,
		unsigned int	global_symbols_only
	)		[static, read]

Definition at line 358 of file loader.c.

References ast_module::lib, ast_config_AST_MODULE_DIR, resource_being_loaded, ast_calloc, ast_module::resource, RTLD_LOCAL, ast_log(), LOG_WARNING, ast_free, AST_LIST_LAST, ast_test_flag, ast_module::info, AST_MODFLAG_GLOBAL_SYMBOLS, ast_strlen_zero(), ast_module_info::nonoptreq, ast_strdupa, strsep(), ast_strip(), find_resource(), and RTLD_NOW.

Referenced by load_resource().

{
   char fn[PATH_MAX] = "";
   void *lib = NULL;
   struct ast_module *mod;
   unsigned int wants_global;
   int space;  /* room needed for the descriptor */
   int missing_so = 0;

   space = sizeof(*resource_being_loaded) + strlen(resource_in) + 1;
   if (strcasecmp(resource_in + strlen(resource_in) - 3, ".so")) {
      missing_so = 1;
      space += 3; /* room for the extra ".so" */
   }

   snprintf(fn, sizeof(fn), "%s/%s%s", ast_config_AST_MODULE_DIR, resource_in, missing_so ? ".so" : "");

   /* make a first load of the module in 'quiet' mode... don't try to resolve
      any symbols, and don't export any symbols. this will allow us to peek into
      the module's info block (if available) to see what flags it has set */

   resource_being_loaded = ast_calloc(1, space);
   if (!resource_being_loaded)
      return NULL;
   strcpy(resource_being_loaded->resource, resource_in);
   if (missing_so)
      strcat(resource_being_loaded->resource, ".so");

   if (!(lib = dlopen(fn, RTLD_LAZY | RTLD_LOCAL))) {
      ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
      ast_free(resource_being_loaded);
      return NULL;
   }

   /* the dlopen() succeeded, let's find out if the module
      registered itself */
   /* note that this will only work properly as long as
      ast_module_register() (which is called by the module's
      constructor) places the new module at the tail of the
      module_list
   */
   if (resource_being_loaded != (mod = AST_LIST_LAST(&module_list))) {
      ast_log(LOG_WARNING, "Module '%s' did not register itself during load\n", resource_in);
      /* no, it did not, so close it and return */
      while (!dlclose(lib));
      /* note that the module's destructor will call ast_module_unregister(),
         which will free the structure we allocated in resource_being_loaded */
      return NULL;
   }

   wants_global = ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS);

   /* if we are being asked only to load modules that provide global symbols,
      and this one does not, then close it and return */
   if (global_symbols_only && !wants_global) {
      while (!dlclose(lib));
      return NULL;
   }

   /* This section is a workaround for a gcc 4.1 bug that has already been
    * fixed in later versions.  Unfortunately, some distributions, such as
    * RHEL/CentOS 5, distribute gcc 4.1, so we're stuck with having to deal
    * with this issue.  This basically ensures that optional_api modules are
    * loaded before any module which requires their functionality. */
#if !defined(HAVE_ATTRIBUTE_weak_import) && !defined(HAVE_ATTRIBUTE_weakref)
   if (!ast_strlen_zero(mod->info->nonoptreq)) {
      /* Force any required dependencies to load */
      char *each, *required_resource = ast_strdupa(mod->info->nonoptreq);
      while ((each = strsep(&required_resource, ","))) {
         each = ast_strip(each);

         /* Is it already loaded? */
         if (!find_resource(each, 0)) {
            load_dynamic_module(each, global_symbols_only);
         }
      }
   }
#endif

   while (!dlclose(lib));
   resource_being_loaded = NULL;

   /* start the load process again */
   resource_being_loaded = ast_calloc(1, space);
   if (!resource_being_loaded)
      return NULL;
   strcpy(resource_being_loaded->resource, resource_in);
   if (missing_so)
      strcat(resource_being_loaded->resource, ".so");

   if (!(lib = dlopen(fn, wants_global ? RTLD_LAZY | RTLD_GLOBAL : RTLD_NOW | RTLD_LOCAL))) {
      ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
      ast_free(resource_being_loaded);
      return NULL;
   }

   /* since the module was successfully opened, and it registered itself
      the previous time we did that, we're going to assume it worked this
      time too :) */

   AST_LIST_LAST(&module_list)->lib = lib;
   resource_being_loaded = NULL;

   return AST_LIST_LAST(&module_list);
}

int load_modules

(

unsigned

int

)

Provided by loader.c

Definition at line 996 of file loader.c.

References embedding, ast_verb, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_LOCK, ast_config_load2(), AST_MODULE_CONFIG, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEINVALID, ast_log(), LOG_WARNING, ast_variable_browse(), ast_variable::next, ast_variable::name, add_to_load_order(), ast_variable::value, ast_debug, ast_true(), ast_variable_retrieve(), AST_LIST_TRAVERSE, ast_module::lib, ast_module::flags, ast_module::running, ast_module::resource, ast_config_AST_MODULE_DIR, find_resource(), ast_opt_quiet, AST_LIST_TRAVERSE_SAFE_BEGIN, resource_name_match(), load_order_entry::resource, AST_LIST_REMOVE_CURRENT, ast_free, AST_LIST_TRAVERSE_SAFE_END, ast_config_destroy(), LOG_NOTICE, load_resource_list(), AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, manager_event, and EVENT_FLAG_SYSTEM.

Referenced by main().

{
   struct ast_config *cfg;
   struct ast_module *mod;
   struct load_order_entry *order;
   struct ast_variable *v;
   unsigned int load_count;
   struct load_order load_order;
   int res = 0;
   struct ast_flags config_flags = { 0 };
   int modulecount = 0;

#ifdef LOADABLE_MODULES
   struct dirent *dirent;
   DIR *dir;
#endif

   /* all embedded modules have registered themselves by now */
   embedding = 0;

   ast_verb(1, "Asterisk Dynamic Loader Starting:\n");

   AST_LIST_HEAD_INIT_NOLOCK(&load_order);

   AST_LIST_LOCK(&module_list);

   if (embedded_module_list.first) {
      module_list.first = embedded_module_list.first;
      module_list.last = embedded_module_list.last;
      embedded_module_list.first = NULL;
   }

   cfg = ast_config_load2(AST_MODULE_CONFIG, "" /* core, can't reload */, config_flags);
   if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
      ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
      goto done;
   }

   /* first, find all the modules we have been explicitly requested to load */
   for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
      if (!strcasecmp(v->name, preload_only ? "preload" : "load")) {
         add_to_load_order(v->value, &load_order, 0);
      }
      if (!strcasecmp(v->name, preload_only ? "preload-require" : "require")) {
         /* Add the module to the list and make sure it's required */
         add_to_load_order(v->value, &load_order, 1);
         ast_debug(2, "Adding module to required list: %s (%s)\n", v->value, v->name);
      }

   }

   /* check if 'autoload' is on */
   if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
      /* if so, first add all the embedded modules that are not already running to the load order */
      AST_LIST_TRAVERSE(&module_list, mod, entry) {
         /* if it's not embedded, skip it */
         if (mod->lib)
            continue;

         if (mod->flags.running)
            continue;

         order = add_to_load_order(mod->resource, &load_order, 0);
      }

#ifdef LOADABLE_MODULES
      /* if we are allowed to load dynamic modules, scan the directory for
         for all available modules and add them as well */
      if ((dir  = opendir(ast_config_AST_MODULE_DIR))) {
         while ((dirent = readdir(dir))) {
            int ld = strlen(dirent->d_name);

            /* Must end in .so to load it.  */

            if (ld < 4)
               continue;

            if (strcasecmp(dirent->d_name + ld - 3, ".so"))
               continue;

            /* if there is already a module by this name in the module_list,
               skip this file */
            if (find_resource(dirent->d_name, 0))
               continue;

            add_to_load_order(dirent->d_name, &load_order, 0);
         }

         closedir(dir);
      } else {
         if (!ast_opt_quiet)
            ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
               ast_config_AST_MODULE_DIR);
      }
#endif
   }

   /* now scan the config for any modules we are prohibited from loading and
      remove them from the load order */
   for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
      if (strcasecmp(v->name, "noload"))
         continue;

      AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
         if (!resource_name_match(order->resource, v->value)) {
            AST_LIST_REMOVE_CURRENT(entry);
            ast_free(order->resource);
            ast_free(order);
         }
      }
      AST_LIST_TRAVERSE_SAFE_END;
   }

   /* we are done with the config now, all the information we need is in the
      load_order list */
   ast_config_destroy(cfg);

   load_count = 0;
   AST_LIST_TRAVERSE(&load_order, order, entry)
      load_count++;

   if (load_count)
      ast_log(LOG_NOTICE, "%d modules will be loaded.\n", load_count);

   /* first, load only modules that provide global symbols */
   if ((res = load_resource_list(&load_order, 1, &modulecount)) < 0) {
      goto done;
   }

   /* now load everything else */
   if ((res = load_resource_list(&load_order, 0, &modulecount)) < 0) {
      goto done;
   }

done:
   while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
      ast_free(order->resource);
      ast_free(order);
   }

   AST_LIST_UNLOCK(&module_list);
   
   /* Tell manager clients that are aggressive at logging in that we're done
      loading modules. If there's a DNS problem in chan_sip, we might not
      even reach this */
   manager_event(EVENT_FLAG_SYSTEM, "ModuleLoadReport", "ModuleLoadStatus: Done\r\nModuleSelection: %s\r\nModuleCount: %d\r\n", preload_only ? "Preload" : "All", modulecount);
   
   return res;
}

static enum ast_module_load_result load_resource	(	const char *	resource_name,
		unsigned int	global_symbols_only,
		struct ast_heap *	resource_heap,
		int	required
	)		[static]

loads a resource based upon resource_name. If global_symbols_only is set only modules with global symbols will be loaded.

If the ast_heap is provided (not NULL) the module is found and added to the heap without running the module's load() function. By doing this, modules added to the resource_heap can be initialized later in order by priority.

If the ast_heap is not provided, the module's load function will be executed immediately

Definition at line 822 of file loader.c.

References AST_MODULE_LOAD_SUCCESS, find_resource(), ast_module::flags, ast_module::running, ast_log(), LOG_WARNING, AST_MODULE_LOAD_DECLINE, ast_test_flag, ast_module::info, AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODULE_LOAD_SKIP, load_dynamic_module(), AST_MODULE_LOAD_FAILURE, inspect_module(), unload_dynamic_module(), ast_module::lib, ast_module_info::backup_globals, ast_module::declined, ast_heap_push(), AST_MODULE_LOAD_PRIORITY, and start_resource().

Referenced by ast_load_resource(), and load_resource_list().

{
   struct ast_module *mod;
   enum ast_module_load_result res = AST_MODULE_LOAD_SUCCESS;

   if ((mod = find_resource(resource_name, 0))) {
      if (mod->flags.running) {
         ast_log(LOG_WARNING, "Module '%s' already exists.\n", resource_name);
         return AST_MODULE_LOAD_DECLINE;
      }
      if (global_symbols_only && !ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS))
         return AST_MODULE_LOAD_SKIP;
   } else {
#ifdef LOADABLE_MODULES
      if (!(mod = load_dynamic_module(resource_name, global_symbols_only))) {
         /* don't generate a warning message during load_modules() */
         if (!global_symbols_only) {
            ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
            return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
         } else {
            return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SKIP;
         }
      }
#else
      ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
      return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
#endif
   }

   if (inspect_module(mod)) {
      ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
#ifdef LOADABLE_MODULES
      unload_dynamic_module(mod);
#endif
      return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
   }

   if (!mod->lib && mod->info->backup_globals && mod->info->backup_globals()) {
      ast_log(LOG_WARNING, "Module '%s' was unable to backup its global data.\n", resource_name);
      return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
   }

   mod->flags.declined = 0;

   if (resource_heap) {
      ast_heap_push(resource_heap, mod);
      res = AST_MODULE_LOAD_PRIORITY;
   } else {
      res = start_resource(mod);
   }

   return res;
}

static int load_resource_list	(	struct load_order *	load_order,
		unsigned int	global_symbols,
		int *	mod_count
	)		[static]

loads modules in order by load_pri, updates mod_count

Returns:

-1 on failure to load module, -2 on failure to load required module, otherwise 0

Definition at line 936 of file loader.c.

References ast_heap_create(), mod_load_cmp(), AST_LIST_TRAVERSE_SAFE_BEGIN, load_resource(), load_order_entry::resource, load_order_entry::required, AST_MODULE_LOAD_SUCCESS, AST_MODULE_LOAD_DECLINE, AST_LIST_REMOVE_CURRENT, ast_free, AST_MODULE_LOAD_FAILURE, ast_log(), LOG_ERROR, AST_MODULE_LOAD_SKIP, AST_MODULE_LOAD_PRIORITY, AST_LIST_TRAVERSE_SAFE_END, ast_heap_pop(), start_resource(), and ast_heap_destroy().

Referenced by load_modules().

{
   struct ast_heap *resource_heap;
   struct load_order_entry *order;
   struct ast_module *mod;
   int count = 0;
   int res = 0;

   if(!(resource_heap = ast_heap_create(8, mod_load_cmp, -1))) {
      return -1;
   }

   /* first, add find and add modules to heap */
   AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
      switch (load_resource(order->resource, global_symbols, resource_heap, order->required)) {
      case AST_MODULE_LOAD_SUCCESS:
      case AST_MODULE_LOAD_DECLINE:
         AST_LIST_REMOVE_CURRENT(entry);
         ast_free(order->resource);
         ast_free(order);
         break;
      case AST_MODULE_LOAD_FAILURE:
         ast_log(LOG_ERROR, "*** Failed to load module %s - %s\n", order->resource, order->required ? "Required" : "Not required");
         fprintf(stderr, "*** Failed to load module %s - %s\n", order->resource, order->required ? "Required" : "Not required");
         res = order->required ? -2 : -1;
         goto done;
      case AST_MODULE_LOAD_SKIP:
         break;
      case AST_MODULE_LOAD_PRIORITY:
         AST_LIST_REMOVE_CURRENT(entry);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

   /* second remove modules from heap sorted by priority */
   while ((mod = ast_heap_pop(resource_heap))) {
      switch (start_resource(mod)) {
      case AST_MODULE_LOAD_SUCCESS:
         count++;
      case AST_MODULE_LOAD_DECLINE:
         break;
      case AST_MODULE_LOAD_FAILURE:
         res = -1;
         goto done;
      case AST_MODULE_LOAD_SKIP:
      case AST_MODULE_LOAD_PRIORITY:
         break;
      }
   }

done:
   if (mod_count) {
      *mod_count += count;
   }
   ast_heap_destroy(resource_heap);

   return res;
}

static int mod_load_cmp	(	void *	a,
		void *	b
	)		[static]

Definition at line 917 of file loader.c.

References ast_test_flag, ast_module::info, AST_MODFLAG_LOAD_ORDER, and ast_module_info::load_pri.

Referenced by load_resource_list().

{
   struct ast_module *a_mod = (struct ast_module *) a;
   struct ast_module *b_mod = (struct ast_module *) b;
   int res = -1;
   /* if load_pri is not set, default is 128.  Lower is better*/
   unsigned char a_pri = ast_test_flag(a_mod->info, AST_MODFLAG_LOAD_ORDER) ? a_mod->info->load_pri : 128;
   unsigned char b_pri = ast_test_flag(b_mod->info, AST_MODFLAG_LOAD_ORDER) ? b_mod->info->load_pri : 128;
   if (a_pri == b_pri) {
      res = 0;
   } else if (a_pri < b_pri) {
      res = 1;
   }
   return res;
}

static int printdigest

(

const unsigned char *

d

)

[static]

Definition at line 267 of file loader.c.

References ast_debug.

Referenced by verify_key().

{
   int x, pos;
   char buf[256]; /* large enough so we don't have to worry */

   for (pos = 0, x = 0; x < 16; x++)
      pos += sprintf(buf + pos, " %02x", *d++);

   ast_debug(1, "Unexpected signature:%s\n", buf);

   return 0;
}

static void queue_reload_request

(

const char *

module

)

[static]

Definition at line 622 of file loader.c.

References AST_LIST_LOCK, do_full_reload, AST_LIST_UNLOCK, ast_strlen_zero(), AST_LIST_REMOVE_HEAD, ast_free, AST_LIST_TRAVERSE, reload_queue_item::module, ast_calloc, ast_log(), LOG_ERROR, and AST_LIST_INSERT_TAIL.

Referenced by ast_module_reload().

{
   struct reload_queue_item *item;

   AST_LIST_LOCK(&reload_queue);

   if (do_full_reload) {
      AST_LIST_UNLOCK(&reload_queue);
      return;
   }

   if (ast_strlen_zero(module)) {
      /* A full reload request (when module is NULL) wipes out any previous
         reload requests and causes the queue to ignore future ones */
      while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
         ast_free(item);
      }
      do_full_reload = 1;
   } else {
      /* No reason to add the same module twice */
      AST_LIST_TRAVERSE(&reload_queue, item, entry) {
         if (!strcasecmp(item->module, module)) {
            AST_LIST_UNLOCK(&reload_queue);
            return;
         }
      }
      item = ast_calloc(1, sizeof(*item) + strlen(module) + 1);
      if (!item) {
         ast_log(LOG_ERROR, "Failed to allocate reload queue item.\n");
         AST_LIST_UNLOCK(&reload_queue);
         return;
      }
      strcpy(item->module, module);
      AST_LIST_INSERT_TAIL(&reload_queue, item, entry);
   }
   AST_LIST_UNLOCK(&reload_queue);
}

static int resource_name_match	(	const char *	name1_in,
		const char *	name2_in
	)		[static]

Definition at line 309 of file loader.c.

References ast_strdupa.

Referenced by find_resource(), ast_module_reload(), add_to_load_order(), and load_modules().

{
   char *name1 = (char *) name1_in;
   char *name2 = (char *) name2_in;

   /* trim off any .so extensions */
   if (!strcasecmp(name1 + strlen(name1) - 3, ".so")) {
      name1 = ast_strdupa(name1);
      name1[strlen(name1) - 3] = '\0';
   }
   if (!strcasecmp(name2 + strlen(name2) - 3, ".so")) {
      name2 = ast_strdupa(name2);
      name2[strlen(name2) - 3] = '\0';
   }

   return strcasecmp(name1, name2);
}

static enum ast_module_load_result start_resource

(

struct ast_module *

mod

)

[static]

Definition at line 776 of file loader.c.

References ast_module::info, ast_module_info::load, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_fully_booted, ast_verb, ast_module::resource, term_color(), ast_module_info::description, COLOR_BROWN, COLOR_BLACK, ast_opt_console, option_verbose, ast_verbose(), ast_module::flags, ast_module::running, ast_update_use_count(), AST_MODULE_LOAD_DECLINE, ast_module::declined, AST_MODULE_LOAD_SKIP, and AST_MODULE_LOAD_PRIORITY.

Referenced by load_resource(), and load_resource_list().

{
   char tmp[256];
   enum ast_module_load_result res;

   if (!mod->info->load) {
      return AST_MODULE_LOAD_FAILURE;
   }

   res = mod->info->load();

   switch (res) {
   case AST_MODULE_LOAD_SUCCESS:
      if (!ast_fully_booted) {
         ast_verb(1, "%s => (%s)\n", mod->resource, term_color(tmp, mod->info->description, COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
         if (ast_opt_console && !option_verbose)
            ast_verbose( ".");
      } else {
         ast_verb(1, "Loaded %s => (%s)\n", mod->resource, mod->info->description);
      }

      mod->flags.running = 1;

      ast_update_use_count();
      break;
   case AST_MODULE_LOAD_DECLINE:
      mod->flags.declined = 1;
      break;
   case AST_MODULE_LOAD_FAILURE:
   case AST_MODULE_LOAD_SKIP: /* modules should never return this value */
   case AST_MODULE_LOAD_PRIORITY:
      break;
   }

   return res;
}

static void unload_dynamic_module

(

struct ast_module *

mod

)

[static]

Definition at line 346 of file loader.c.

References ast_module::lib.

Referenced by ast_unload_resource(), and load_resource().

{
   void *lib = mod->lib;

   /* WARNING: the structure pointed to by mod is going to
      disappear when this operation succeeds, so we can't
      dereference it */

   if (lib)
      while (!dlclose(lib));
}

static int verify_key

(

const unsigned char *

key

)

[static]

Definition at line 292 of file loader.c.

References MD5Init(), MD5Update(), MD5Final(), key_matches(), expected_key, and printdigest().

Referenced by inspect_module().

{
   struct MD5Context c;
   unsigned char digest[16];

   MD5Init(&c);
   MD5Update(&c, key, strlen((char *)key));
   MD5Final(digest, &c);

   if (key_matches(expected_key, digest))
      return 0;

   printdigest(digest);

   return -1;
}

---

Variable Documentation

char buildopt_sum[33] = AST_BUILDOPT_SUM [static]

Definition at line 78 of file loader.c.

Referenced by inspect_module().

int do_full_reload = 0 [static]

Definition at line 121 of file loader.c.

Referenced by ast_process_pending_reloads(), and queue_reload_request().

struct module_list embedded_module_list [static]

Definition at line 105 of file loader.c.

unsigned int embedding = 1 [static]

Definition at line 80 of file loader.c.

Referenced by ast_module_register(), and load_modules().

const unsigned char expected_key[] [static]

Initial value:

{ 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3,
  0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 }

Definition at line 74 of file loader.c.

Referenced by verify_key().

struct module_list module_list [static]

struct reload_classes reload_classes[] [static]

struct reload_queue reload_queue [static]

ast_mutex_t reloadlock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, 1 } [static]

Definition at line 114 of file loader.c.

struct ast_module* resource_being_loaded [static]

Definition at line 129 of file loader.c.

Referenced by ast_module_register(), and load_dynamic_module().

struct updaters updaters [static]