Mon Apr 30 07:44:05 2007

Asterisk developer's documentation

---

loader.c File Reference

Module Loader. More...

#include "asterisk.h"
#include <stdio.h>
#include <dirent.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/options.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/term.h"
#include "asterisk/manager.h"
#include "asterisk/cdr.h"
#include "asterisk/enum.h"
#include "asterisk/rtp.h"
#include "asterisk/http.h"
#include "asterisk/lock.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_entry
struct	loadupdate
struct	reload_classes
Defines
#define	RTLD_NOW   0
Enumerations
enum	flags { FLAG_RUNNING = (1 << 1), FLAG_DECLINED = (1 << 2) }
Functions
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)
	AST_LIST_HEAD (module_user_list, ast_module_user)
	AST_LIST_HEAD_NOLOCK (load_order, load_order_entry)
static	AST_LIST_HEAD_STATIC (updaters, loadupdate)
static	AST_LIST_HEAD_STATIC (module_list, ast_module)
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 (char *name)
	Check if module with the name given is loaded.
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.
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_unref (struct ast_module *mod)
void	ast_module_unregister (const struct ast_module_info *info)
	AST_MUTEX_DEFINE_STATIC (reloadlock)
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)
int	load_modules (unsigned int preload_only)
static enum ast_module_load_result	load_resource (const char *resource_name, unsigned int global_symbols_only)
static int	printdigest (const unsigned char *d)
static int	resource_name_match (const char *name1_in, const char *name2_in)
static int	verify_key (const unsigned char *key)
Variables
static unsigned int	embedding = 1
static unsigned char	expected_key []
ast_module *	resource_being_loaded

---

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_NOW   0

Definition at line 65 of file loader.c.

Referenced by dlopen(), and loadModule().

---

Enumeration Type Documentation

enum flags

Enumerator:

FLAG_RUNNING
FLAG_DECLINED

Definition at line 83 of file loader.c.

           {
   FLAG_RUNNING = (1 << 1),      /* module successfully initialized */
   FLAG_DECLINED = (1 << 2),     /* module declined to initialize */
};

---

Function Documentation

struct ast_module_user* __ast_module_user_add	(	struct ast_module *	mod,
		struct ast_channel *	chan
	)

Definition at line 179 of file loader.c.

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

{
   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 211 of file loader.c.

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

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);
      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 200 of file loader.c.

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

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

   ast_update_use_count();
}

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

Definition at line 684 of file loader.c.

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

Referenced by load_modules().

{
   struct load_order_entry *order;

   AST_LIST_TRAVERSE(load_order, order, entry) {
      if (!resource_name_match(order->resource, resource))
         return NULL;
   }

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

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

   return order;
}

AST_LIST_HEAD	(	module_user_list	,
		ast_module_user
	)

AST_LIST_HEAD_NOLOCK	(	load_order	,
		load_order_entry
	)

static AST_LIST_HEAD_STATIC	(	updaters	,
		loadupdate
	)			[static]

static AST_LIST_HEAD_STATIC	(	module_list	,
		ast_module
	)			[static]

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 initilization 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 668 of file loader.c.

References AST_LIST_LOCK, AST_LIST_UNLOCK, and load_resource().

Referenced by file_ok_sel(), handle_load(), handle_load_deprecated(), and reload_module().

{
       AST_LIST_LOCK(&module_list);
       load_resource(resource_name, 0);
       AST_LIST_UNLOCK(&module_list);

       return 0;
}

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.

Returns:

Zero on success and -1 on failure.

Definition at line 899 of file loader.c.

References AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, and ast_malloc.

Referenced by show_console().

{
   struct loadupdate *tmp;

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

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

   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.

Returns:

Zero on success, -1 on failure.

Definition at line 914 of file loader.c.

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

Referenced by exit_now().

{
   struct loadupdate *cur;

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

   return cur ? 0 : -1;
}

int ast_module_check

(

char *

name

)

Check if module with the name given is loaded.

Parameters:

name

Module name, like "chan_sip.so"

Returns:

0 if false, 1 if true

Definition at line 880 of file loader.c.

References AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_trylock(), and ast_strlen_zero().

Referenced by ifmodule_read().

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

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

   if (ast_mutex_trylock(&module_list.lock))
      unlock = 0;
   AST_LIST_TRAVERSE(&module_list, cur, entry)
      if (!res && !strcasecmp(name, cur->resource))
         res = 1;
   if (unlock)
      AST_LIST_UNLOCK(&module_list);
   return res;
}

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.

Returns:

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

Definition at line 493 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_module::info, name, ast_module_info::reload, and strdup.

Referenced by complete_mod_2(), complete_mod_3(), complete_mod_3_nr(), and complete_mod_4().

{
   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 = 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 = strdup(reload_classes[i].name);
      }
   }

   return ret;
}

struct ast_module* ast_module_ref

(

struct ast_module *

mod

)

Definition at line 931 of file loader.c.

References ast_update_use_count(), and ast_module::usecount.

Referenced by __oh323_new(), alsa_new(), ast_iax2_new(), cli_audio_convert(), cli_audio_convert_deprecated(), complete_orig(), features_new(), fn_wrapper(), gtalk_new(), handle_orig(), mgcp_new(), newpvt(), oss_new(), phone_check_exception(), phone_new(), sip_new(), skinny_new(), and zt_new().

{
   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 117 of file loader.c.

References ast_calloc, AST_LIST_HEAD_INIT, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, embedding, ast_module::info, ast_module_info::name, resource_being_loaded, ast_module_info::self, and ast_module::users.

{
   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_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);

   if (!embedding)
      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:

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

Definition at line 523 of file loader.c.

References ast_lastreloadtime, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_trylock(), ast_mutex_unlock(), ast_test_flag, ast_verbose(), ast_module_info::description, FLAG_DECLINED, FLAG_RUNNING, ast_module::info, option_verbose, ast_module_info::reload, resource_name_match(), and VERBOSE_PREFIX_3.

Referenced by action_updateconfig(), handle_reload(), handle_reload_deprecated(), and monitor_sig_flags().

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

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

   /* 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) {
      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 (!ast_test_flag(cur, FLAG_RUNNING | FLAG_DECLINED))
         continue;

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

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

   ast_mutex_unlock(&reloadlock);

   return res;
}

void ast_module_unref

(

struct ast_module *

mod

)

Definition at line 939 of file loader.c.

References ast_update_use_count(), and ast_module::usecount.

Referenced by alsa_hangup(), ast_closestream(), ast_smdi_interface_destroy(), cli_audio_convert(), cli_audio_convert_deprecated(), complete_orig(), destroy(), gtalk_hangup(), handle_orig(), iax2_predestroy(), mgcp_hangup(), oh323_hangup(), oss_hangup(), phone_check_exception(), phone_hangup(), sip_hangup(), and zt_hangup().

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

void ast_module_unregister

(

const struct ast_module_info *

info

)

Definition at line 155 of file loader.c.

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

{
   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(&module_list, entry);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&module_list);

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

AST_MUTEX_DEFINE_STATIC

(

reloadlock

)

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).

Returns:

Zero on success, -1 on error.

Definition at line 432 of file loader.c.

References __ast_module_user_hangup_all(), ast_clear_flag, AST_FORCE_FIRM, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_test_flag, ast_update_use_count(), error(), find_resource(), FLAG_DECLINED, FLAG_RUNNING, ast_module::lib, and ast_module::usecount.

Referenced by exit_now(), handle_unload(), handle_unload_deprecated(), reload_module(), and remove_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);
      return 0;
   }

   if (!ast_test_flag(mod, FLAG_RUNNING | FLAG_DECLINED))
      error = 1;

   if (!mod->lib) {
      ast_log(LOG_WARNING, "Unloading embedded modules is not supported.\n");
      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)
      ast_clear_flag(mod, FLAG_RUNNING | FLAG_DECLINED);

   AST_LIST_UNLOCK(&module_list);

#if 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 860 of file loader.c.

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

Referenced by handle_modlist(), and mod_update().

{
   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 LOCAL_USER macros take care of calling this function for you.

Definition at line 848 of file loader.c.

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

Referenced by __ast_module_user_add(), __ast_module_user_hangup_all(), __ast_module_user_remove(), agent_new(), ast_module_ref(), ast_module_unref(), ast_unload_resource(), exit_now(), load_module(), load_resource(), oh323_request(), sip_request_call(), and sipsock_read().

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

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

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

Definition at line 305 of file loader.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, and resource_name_match().

Referenced by ast_unload_resource(), and load_resource().

{
   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 576 of file loader.c.

References ast_log(), ast_module_info::description, ast_module::info, ast_module_info::key, and verify_key().

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

   return 0;
}

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

Definition at line 258 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;
}

int load_modules

(

unsigned

int

)

Provided by loader.c

Definition at line 702 of file loader.c.

References add_to_load_order(), ast_config_AST_MODULE_DIR, ast_config_load(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), AST_MODULE_CONFIG, ast_opt_quiet, ast_true(), ast_variable_browse(), ast_variable_retrieve(), ast_verbose(), embedding, free, LOG_DEBUG, ast_variable::name, ast_variable::next, option_debug, option_verbose, load_order_entry::resource, resource_name_match(), and ast_variable::value.

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;
#if LOADABLE_MODULES
   struct dirent *dirent;
   DIR *dir;
#endif

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

   if (option_verbose)
      ast_verbose("Asterisk Dynamic Loader Starting:\n");

   AST_LIST_TRAVERSE(&module_list, mod, entry) {
      if (option_debug > 1)
         ast_log(LOG_DEBUG, "Embedded module found: %s\n", mod->resource);
   }

   if (!(cfg = ast_config_load(AST_MODULE_CONFIG))) {
      ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
      return 0;
   }

   AST_LIST_HEAD_INIT_NOLOCK(&load_order);

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

   /* check if 'autoload' is on */
   if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
      /* if so, first add all the embedded modules to the load order */
      AST_LIST_TRAVERSE(&module_list, mod, entry)
         order = add_to_load_order(mod->resource, &load_order);

#if 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;

            add_to_load_order(dirent->d_name, &load_order);

         }

         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(&load_order, entry);
            free(order->resource);
            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 */
   AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
      switch (load_resource(order->resource, 1)) {
      case AST_MODULE_LOAD_SUCCESS:
      case AST_MODULE_LOAD_DECLINE:
         AST_LIST_REMOVE_CURRENT(&load_order, entry);
         free(order->resource);
         free(order);
         break;
      case AST_MODULE_LOAD_FAILURE:
         res = -1;
         goto done;
      case AST_MODULE_LOAD_SKIP:
         /* try again later */
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

   /* now load everything else */
   AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
      switch (load_resource(order->resource, 0)) {
      case AST_MODULE_LOAD_SUCCESS:
      case AST_MODULE_LOAD_DECLINE:
         AST_LIST_REMOVE_CURRENT(&load_order, entry);
         free(order->resource);
         free(order);
         break;
      case AST_MODULE_LOAD_FAILURE:
         res = -1;
         goto done;
      case AST_MODULE_LOAD_SKIP:
         /* should not happen */
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

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

   return res;
}

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

Definition at line 596 of file loader.c.

References ast_clear_flag, ast_fully_booted, ast_log(), AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SKIP, AST_MODULE_LOAD_SUCCESS, ast_opt_console, ast_set_flag, ast_test_flag, ast_update_use_count(), ast_verbose(), COLOR_BLACK, COLOR_BROWN, ast_module_info::description, find_resource(), FLAG_DECLINED, FLAG_RUNNING, ast_module::info, inspect_module(), ast_module_info::load, option_verbose, term_color(), and VERBOSE_PREFIX_1.

Referenced by ast_load_resource().

{
   struct ast_module *mod;
   enum ast_module_load_result res = AST_MODULE_LOAD_SUCCESS;
   char tmp[256];

   if ((mod = find_resource(resource_name, 0))) {
      if (ast_test_flag(mod, FLAG_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 {
#if 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 AST_MODULE_LOAD_DECLINE;
         } else {
            return AST_MODULE_LOAD_SKIP;
         }
      }
#else
      ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
      return AST_MODULE_LOAD_DECLINE;
#endif
   }

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

   ast_clear_flag(mod, FLAG_DECLINED);

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

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

      ast_set_flag(mod, FLAG_RUNNING);

      ast_update_use_count();
      break;
   case AST_MODULE_LOAD_DECLINE:
      ast_set_flag(mod, FLAG_DECLINED);
      break;
   case AST_MODULE_LOAD_FAILURE:
      break;
   case AST_MODULE_LOAD_SKIP:
      /* modules should never return this value */
      break;
   }

   return res;
}

static int printdigest

(

const unsigned char *

d

)

[static]

Definition at line 245 of file loader.c.

References ast_log(), and LOG_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_log(LOG_DEBUG, "Unexpected signature:%s\n", buf);

   return 0;
}

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

Definition at line 287 of file loader.c.

References ast_strdupa.

Referenced by add_to_load_order(), ast_module_reload(), find_resource(), 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 int verify_key

(

const unsigned char *

key

)

[static]

Definition at line 270 of file loader.c.

References expected_key, key_matches(), MD5Final(), MD5Init(), MD5Update(), 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

unsigned int embedding = 1 [static]

Definition at line 79 of file loader.c.

Referenced by ast_module_register(), and load_modules().

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 75 of file loader.c.

Referenced by verify_key().

struct ast_module* resource_being_loaded

Definition at line 113 of file loader.c.

Referenced by ast_module_register().

---