Sat Nov 1 06:31:06 2008

Asterisk developer's documentation

---

loader.c File Reference

Module Loader. More...

#include <stdio.h>
#include <dirent.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "asterisk.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/lock.h"
#include <dlfcn.h>
#include "asterisk/md5.h"

Include dependency graph for loader.c:

Go to the source code of this file.

Data Structures
struct	loadupdate
struct	module
Defines
#define	RTLD_NOW   0
Functions
static int	__load_resource (const char *resource_name, const struct ast_config *cfg)
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.
char *	ast_module_helper (char *line, char *word, int pos, int state, int rpos, int needsreload)
	Match modules names for the Asterisk cli.
int	ast_module_reload (const char *name)
	Reload asterisk modules.
	AST_MUTEX_DEFINE_STATIC (reloadlock)
	AST_MUTEX_DEFINE_STATIC (modlock)
static int	ast_resource_exists (char *resource)
int	ast_unload_resource (const char *resource_name, int force)
	Unloads 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 int	key_matches (unsigned char *key1, unsigned char *key2)
int	load_modules (const int preload_only)
static int	printdigest (unsigned char *d)
static int	verify_key (unsigned char *key)
Variables
static unsigned char	expected_key []
static const char *	loadorder []
static int	modlistver = 0
static struct module *	module_list = NULL
static struct loadupdate *	updaters

---

Detailed Description

Module Loader.

Definition in file loader.c.

---

Define Documentation

#define RTLD_NOW   0

Definition at line 54 of file loader.c.

Referenced by __load_resource(), dlopen(), and loadModule().

---

Function Documentation

static int __load_resource	(	const char *	resource_name,
		const struct ast_config *	cfg
	)			[static]

Definition at line 271 of file loader.c.

References ast_config_AST_MODULE_DIR, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_true(), ast_unload_resource(), ast_update_use_count(), ast_variable_retrieve(), ast_verbose(), cfg, COLOR_BLACK, COLOR_BROWN, module::description, dlclose(), dlerror(), dlopen(), dlsym(), free, fully_booted, module::key, key(), module::lib, module::load_module, LOG_WARNING, malloc, module_list, module::next, option_console, option_verbose, module::reload, module::resource, RTLD_GLOBAL, RTLD_LAZY, RTLD_NOW, term_color(), module::unload_module, module::usecount, VERBOSE_PREFIX_1, and verify_key().

Referenced by ast_load_resource(), and load_modules().

{
   static char fn[256];
   int errors=0;
   int res;
   struct module *m;
   int flags=RTLD_NOW;
#ifdef RTLD_GLOBAL
   char *val;
#endif
   unsigned char *key;
   char tmp[80];

   if (strncasecmp(resource_name, "res_", 4)) {
#ifdef RTLD_GLOBAL
      if (cfg) {
         if ((val = ast_variable_retrieve(cfg, "global", resource_name))
               && ast_true(val))
            flags |= RTLD_GLOBAL;
      }
#endif
   } else {
      /* Resource modules are always loaded global and lazy */
#ifdef RTLD_GLOBAL
      flags = (RTLD_GLOBAL | RTLD_LAZY);
#else
      flags = RTLD_LAZY;
#endif
   }
   
   if (ast_mutex_lock(&modlock))
      ast_log(LOG_WARNING, "Failed to lock\n");
   m = module_list;
   while(m) {
      if (!strcasecmp(m->resource, resource_name)) {
         ast_log(LOG_WARNING, "Module '%s' already exists\n", resource_name);
         ast_mutex_unlock(&modlock);
         return -1;
      }
      m = m->next;
   }
   m = malloc(sizeof(struct module));  
   if (!m) {
      ast_log(LOG_WARNING, "Out of memory\n");
      ast_mutex_unlock(&modlock);
      return -1;
   }
   strncpy(m->resource, resource_name, sizeof(m->resource)-1);
   if (resource_name[0] == '/') {
      strncpy(fn, resource_name, sizeof(fn)-1);
   } else {
      snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_MODULE_DIR, resource_name);
   }
   m->lib = dlopen(fn, flags);
   if (!m->lib) {
      ast_log(LOG_WARNING, "%s\n", dlerror());
      free(m);
      ast_mutex_unlock(&modlock);
      return -1;
   }
   m->load_module = dlsym(m->lib, "load_module");
   if (m->load_module == NULL)
      m->load_module = dlsym(m->lib, "_load_module");
   if (!m->load_module) {
      ast_log(LOG_WARNING, "No load_module in module %s\n", fn);
      errors++;
   }
   m->unload_module = dlsym(m->lib, "unload_module");
   if (m->unload_module == NULL)
      m->unload_module = dlsym(m->lib, "_unload_module");
   if (!m->unload_module) {
      ast_log(LOG_WARNING, "No unload_module in module %s\n", fn);
      errors++;
   }
   m->usecount = dlsym(m->lib, "usecount");
   if (m->usecount == NULL)
      m->usecount = dlsym(m->lib, "_usecount");
   if (!m->usecount) {
      ast_log(LOG_WARNING, "No usecount in module %s\n", fn);
      errors++;
   }
   m->description = dlsym(m->lib, "description");
   if (m->description == NULL)
      m->description = dlsym(m->lib, "_description");
   if (!m->description) {
      ast_log(LOG_WARNING, "No description in module %s\n", fn);
      errors++;
   }
   m->key = dlsym(m->lib, "key");
   if (m->key == NULL)
      m->key = dlsym(m->lib, "_key");
   if (!m->key) {
      ast_log(LOG_WARNING, "No key routine in module %s\n", fn);
      errors++;
   }

   m->reload = dlsym(m->lib, "reload");
   if (m->reload == NULL)
      m->reload = dlsym(m->lib, "_reload");

   if (!m->key || !(key = (unsigned char *) m->key())) {
      ast_log(LOG_WARNING, "Key routine returned NULL in module %s\n", fn);
      key = NULL;
      errors++;
   }
   if (key && verify_key(key)) {
      ast_log(LOG_WARNING, "Unexpected key returned by module %s\n", fn);
      errors++;
   }
   if (errors) {
      ast_log(LOG_WARNING, "%d error%s loading module %s, aborted\n", errors, (errors != 1) ? "s" : "", fn);
      dlclose(m->lib);
      free(m);
      ast_mutex_unlock(&modlock);
      return -1;
   }
   if (!fully_booted) {
      if (option_verbose) 
         ast_verbose( " => (%s)\n", term_color(tmp, m->description(), COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
      if (option_console && !option_verbose)
         ast_verbose( ".");
   } else {
      if (option_verbose)
         ast_verbose(VERBOSE_PREFIX_1 "Loaded %s => (%s)\n", fn, m->description());
   }

   /* add module 'm' to end of module_list chain
      so reload commands will be issued in same order modules were loaded */
   m->next = NULL;
   if (module_list == NULL) {
      /* empty list so far, add at front */
      module_list = m;
   }
   else {
      struct module *i;
      /* find end of chain, and add there */
      for (i = module_list; i->next; i = i->next)
         ;
      i->next = m;
   }
   
   modlistver = rand();
   ast_mutex_unlock(&modlock);
   if ((res = m->load_module())) {
      ast_log(LOG_WARNING, "%s: load_module failed, returning %d\n", m->resource, res);
      ast_unload_resource(resource_name, 0);
      return -1;
   }
   ast_update_use_count();
   return 0;
}

int ast_load_resource

(

const char *

resource_name

)

Load a module.

Parameters:

resource_name

The filename 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:

Zero on success, -1 on error.

Definition at line 423 of file loader.c.

References __load_resource(), ast_config_destroy(), ast_config_load(), AST_MODULE_CONFIG, cfg, and option_verbose.

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

{
   int o;
   struct ast_config *cfg = NULL;
   int res;

   /* Keep the module file parsing silent */
   o = option_verbose;
   option_verbose = 0;
   cfg = ast_config_load(AST_MODULE_CONFIG);
   option_verbose = o;
   res = __load_resource(resource_name, cfg);
   if (cfg)
      ast_config_destroy(cfg);
   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.

Returns:

Zero on success and -1 on failure.

Definition at line 609 of file loader.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_WARNING, malloc, loadupdate::next, loadupdate::updater, and updaters.

Referenced by show_console().

{
   struct loadupdate *tmp;
   /* XXX Should be more flexible here, taking > 1 verboser XXX */
   if ((tmp = malloc(sizeof (struct loadupdate)))) {
      tmp->updater = v;
      if (ast_mutex_lock(&modlock))
         ast_log(LOG_WARNING, "Failed to lock\n");
      tmp->next = updaters;
      updaters = tmp;
      ast_mutex_unlock(&modlock);
      return 0;
   }
   return -1;
}

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

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_WARNING, loadupdate::next, loadupdate::updater, and updaters.

Referenced by exit_now().

{
   int res = -1;
   struct loadupdate *tmp, *tmpl=NULL;
   if (ast_mutex_lock(&modlock))
      ast_log(LOG_WARNING, "Failed to lock\n");
   tmp = updaters;
   while(tmp) {
      if (tmp->updater == v)  {
         if (tmpl)
            tmpl->next = tmp->next;
         else
            updaters = tmp->next;
         break;
      }
      tmpl = tmp;
      tmp = tmp->next;
   }
   if (tmp)
      res = 0;
   ast_mutex_unlock(&modlock);
   return res;
}

char* ast_module_helper	(	char *	line,
		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 166 of file loader.c.

References ast_mutex_lock(), ast_mutex_unlock(), module_list, module::next, module::reload, module::resource, and strdup.

Referenced by complete_mod_2(), and complete_mod_4().

{
   struct module *m;
   int which=0;
   char *ret;

   if (pos != rpos)
      return NULL;
   ast_mutex_lock(&modlock);
   m = module_list;
   while(m) {
      if (!strncasecmp(word, m->resource, strlen(word)) && (m->reload || !needsreload)) {
         if (++which > state)
            break;
      }
      m = m->next;
   }
   if (m) {
      ret = strdup(m->resource);
   } else {
      ret = NULL;
      if (!strncasecmp(word, "extconfig", strlen(word))) {
         if (++which > state)
            ret = strdup("extconfig");
      } else if (!strncasecmp(word, "manager", strlen(word))) {
         if (++which > state)
            ret = strdup("manager");
      } else if (!strncasecmp(word, "enum", strlen(word))) {
         if (++which > state)
            ret = strdup("enum");
      } else if (!strncasecmp(word, "rtp", strlen(word))) {
         if (++which > state)
            ret = strdup("rtp");
      }
         
   }
   ast_mutex_unlock(&modlock);
   return ret;
}

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

References ast_cdr_engine_reload(), ast_enum_reload(), ast_lastreloadtime, ast_mutex_lock(), ast_mutex_trylock(), ast_mutex_unlock(), ast_rtp_reload(), ast_verbose(), module::description, dnsmgr_reload(), module_list, module::next, option_verbose, read_config_maps(), reload(), module::reload, reload_manager(), module::resource, and VERBOSE_PREFIX_3.

Referenced by handle_reload(), and monitor_sig_flags().

{
   struct module *m;
   int reloaded = 0;
   int oldversion;
   int (*reload)(void);
   /* We'll do the logger and manager the favor of calling its reload here first */

   if (ast_mutex_trylock(&reloadlock)) {
      ast_verbose("The previous reload command didn't finish yet\n");
      return -1;
   }
   time(&ast_lastreloadtime);

   if (!name || !strcasecmp(name, "extconfig")) {
      read_config_maps();
      reloaded = 2;
   }
   if (!name || !strcasecmp(name, "manager")) {
      reload_manager();
      reloaded = 2;
   }
   if (!name || !strcasecmp(name, "cdr")) {
      ast_cdr_engine_reload();
      reloaded = 2;
   }
   if (!name || !strcasecmp(name, "enum")) {
      ast_enum_reload();
      reloaded = 2;
   }
   if (!name || !strcasecmp(name, "rtp")) {
      ast_rtp_reload();
      reloaded = 2;
   }
   if (!name || !strcasecmp(name, "dnsmgr")) {
      dnsmgr_reload();
      reloaded = 2;
   }

   ast_mutex_lock(&modlock);
   oldversion = modlistver;
   m = module_list;
   while(m) {
      if (!name || !strcasecmp(name, m->resource)) {
         if (reloaded < 1)
            reloaded = 1;
         reload = m->reload;
         ast_mutex_unlock(&modlock);
         if (reload) {
            reloaded = 2;
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", m->resource, m->description());
            reload();
         }
         ast_mutex_lock(&modlock);
         if (oldversion != modlistver)
            break;
      }
      m = m->next;
   }
   ast_mutex_unlock(&modlock);
   ast_mutex_unlock(&reloadlock);
   return reloaded;
}

AST_MUTEX_DEFINE_STATIC

(

reloadlock

)

AST_MUTEX_DEFINE_STATIC

(

modlock

)

static int ast_resource_exists

(

char *

resource

)

[static]

Definition at line 440 of file loader.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_WARNING, module_list, module::next, and module::resource.

{
   struct module *m;
   if (ast_mutex_lock(&modlock))
      ast_log(LOG_WARNING, "Failed to lock\n");
   m = module_list;
   while(m) {
      if (!strcasecmp(resource, m->resource))
         break;
      m = m->next;
   }
   ast_mutex_unlock(&modlock);
   if (m)
      return -1;
   else
      return 0;
}

int ast_unload_resource	(	const char *	resource_name,
		int	force
	)

Unloads a module.

Parameters:

	resource_name	The name of the module to unload.
	force	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 122 of file loader.c.

References AST_FORCE_FIRM, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_update_use_count(), dlclose(), free, module::lib, LOG_WARNING, module_list, module::next, module::resource, module::unload_module, and module::usecount.

Referenced by __load_resource(), exit_now(), handle_unload(), reload_module(), and remove_module().

{
   struct module *m, *ml = NULL;
   int res = -1;
   if (ast_mutex_lock(&modlock))
      ast_log(LOG_WARNING, "Failed to lock\n");
   m = module_list;
   while(m) {
      if (!strcasecmp(m->resource, resource_name)) {
         if ((res = m->usecount()) > 0)  {
            if (force) 
               ast_log(LOG_WARNING, "Warning:  Forcing removal of module %s with use count %d\n", resource_name, res);
            else {
               ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name, res);
               ast_mutex_unlock(&modlock);
               return -1;
            }
         }
         res = m->unload_module();
         if (res) {
            ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
            if (force <= AST_FORCE_FIRM) {
               ast_mutex_unlock(&modlock);
               return -1;
            } else
               ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
         }
         if (ml)
            ml->next = m->next;
         else
            module_list = m->next;
         dlclose(m->lib);
         free(m);
         break;
      }
      ml = m;
      m = m->next;
   }
   modlistver = rand();
   ast_mutex_unlock(&modlock);
   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 589 of file loader.c.

References ast_mutex_trylock(), ast_mutex_unlock(), module::description, module_list, module::next, module::resource, and module::usecount.

Referenced by handle_modlist(), and mod_update().

{
   struct module *m;
   int unlock = -1;
   int total_mod_loaded = 0;

   if (ast_mutex_trylock(&modlock))
      unlock = 0;
   m = module_list;
   while (m) {
      total_mod_loaded += modentry(m->resource, m->description(), m->usecount(), like);
      m = m->next;
   }
   if (unlock)
      ast_mutex_unlock(&modlock);

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

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_WARNING, loadupdate::next, loadupdate::updater, and updaters.

Referenced by __load_resource(), __oh323_new(), adpcm_destroy(), adpcmtolin_new(), agent_new(), alaw_destroy(), alawtolin_new(), alawtoulaw_new(), alsa_new(), aopen_decusecnt(), aopen_incusecnt(), ast_iax2_new(), ast_modem_new(), ast_unload_resource(), au_close(), au_open(), au_rewrite(), bestdata_decusecnt(), bestdata_incusecnt(), exit_now(), features_new(), g723_close(), g723_destroy(), g723_open(), g723_rewrite(), g723tolin_new(), g726_16_open(), g726_16_rewrite(), g726_24_open(), g726_24_rewrite(), g726_32_open(), g726_32_rewrite(), g726_40_open(), g726_40_rewrite(), g726_close(), g726_destroy(), g726tolin_new(), g729_close(), g729_open(), g729_rewrite(), gsm_close(), gsm_open(), gsm_rewrite(), h263_close(), h263_open(), h263_rewrite(), i4l_decusecnt(), i4l_incusecnt(), iax2_predestroy(), ilbc_close(), ilbc_open(), ilbc_rewrite(), lintoadpcm_new(), lintoalaw_new(), lintog723_new(), lintog726_new(), lintoulaw_new(), load_module(), local_new(), mgcp_hangup(), mgcp_new(), modem_hangup(), nbs_new(), ogg_vorbis_close(), ogg_vorbis_open(), ogg_vorbis_rewrite(), oh323_hangup(), oh323_request(), oss_new(), pcm_close(), pcm_open(), pcm_rewrite(), phone_check_exception(), phone_hangup(), phone_new(), sip_hangup(), sip_new(), sip_request_call(), sipsock_read(), skinny_new(), slinear_close(), slinear_open(), slinear_rewrite(), ulaw_destroy(), ulawtoalaw_new(), ulawtolin_new(), vox_close(), vox_open(), vox_rewrite(), vpb_hangup(), vpb_new(), wav_close(), wav_open(), wav_rewrite(), zt_hangup(), and zt_new().

{
   /* Notify any module monitors that the use count for a 
      resource has changed */
   struct loadupdate *m;
   if (ast_mutex_lock(&modlock))
      ast_log(LOG_WARNING, "Failed to lock\n");
   m = updaters;
   while(m) {
      m->updater();
      m = m->next;
   }
   ast_mutex_unlock(&modlock);
   
}

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

Definition at line 99 of file loader.c.

References match().

Referenced by verify_key().

{
   int match = 1;
   int x;
   for (x=0; x<16; x++) {
      match &= (key1[x] == key2[x]);
   }
   return match;
}

int load_modules

(

const int

preload_only

)

Definition at line 466 of file loader.c.

References __load_resource(), ast_config_destroy(), ast_config_load(), ast_log(), AST_MODULE_CONFIG, ast_variable_browse(), ast_verbose(), cfg, COLOR_BRWHITE, LOG_DEBUG, LOG_WARNING, ast_variable::name, ast_variable::next, option_debug, option_verbose, term_color(), ast_variable::value, and VERBOSE_PREFIX_1.

Referenced by main().

{
   struct ast_config *cfg;
   struct ast_variable *v;
   char tmp[80];

   if (option_verbose) {
      if (preload_only)
         ast_verbose("Asterisk Dynamic Loader loading preload modules:\n");
      else
         ast_verbose("Asterisk Dynamic Loader Starting:\n");
   }

   cfg = ast_config_load(AST_MODULE_CONFIG);
   if (cfg) {
      int doload;

      /* Load explicitly defined modules */
      for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
         doload = 0;

         if (preload_only)
            doload = !strcasecmp(v->name, "preload");
         else
            doload = !strcasecmp(v->name, "load");

             if (doload) {
            if (option_debug && !option_verbose)
               ast_log(LOG_DEBUG, "Loading module %s\n", v->value);
            if (option_verbose) {
               ast_verbose(VERBOSE_PREFIX_1 "[%s]", term_color(tmp, v->value, COLOR_BRWHITE, 0, sizeof(tmp)));
               fflush(stdout);
            }
            if (__load_resource(v->value, cfg)) {
               ast_log(LOG_WARNING, "Loading module %s failed!\n", v->value);
               ast_config_destroy(cfg);
               return -1;
            }
         }
      }
   }

   if (preload_only) {
      ast_config_destroy(cfg);
      return 0;
   }

   if (!cfg || ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
      /* Load all modules */
      DIR *mods;
      struct dirent *d;
      int x;

      /* Loop through each order */
      for (x=0; x<sizeof(loadorder) / sizeof(loadorder[0]); x++) {
         mods = opendir((char *)ast_config_AST_MODULE_DIR);
         if (mods) {
            while((d = readdir(mods))) {
               /* Must end in .so to load it.  */
               if ((strlen(d->d_name) > 3) && 
                   (!loadorder[x] || !strncasecmp(d->d_name, loadorder[x], strlen(loadorder[x]))) && 
                   !strcasecmp(d->d_name + strlen(d->d_name) - 3, ".so") &&
                  !ast_resource_exists(d->d_name)) {
                  /* It's a shared library -- Just be sure we're allowed to load it -- kinda
                     an inefficient way to do it, but oh well. */
                  if (cfg) {
                     v = ast_variable_browse(cfg, "modules");
                     while(v) {
                        if (!strcasecmp(v->name, "noload") &&
                            !strcasecmp(v->value, d->d_name)) 
                           break;
                        v = v->next;
                     }
                     if (v) {
                        if (option_verbose) {
                           ast_verbose( VERBOSE_PREFIX_1 "[skipping %s]\n", d->d_name);
                           fflush(stdout);
                        }
                        continue;
                     }
                     
                  }
                  if (option_debug && !option_verbose)
                     ast_log(LOG_DEBUG, "Loading module %s\n", d->d_name);
                  if (option_verbose) {
                     ast_verbose( VERBOSE_PREFIX_1 "[%s]", term_color(tmp, d->d_name, COLOR_BRWHITE, 0, sizeof(tmp)));
                     fflush(stdout);
                  }
                  if (__load_resource(d->d_name, cfg)) {
                     ast_log(LOG_WARNING, "Loading module %s failed!\n", d->d_name);
                     if (cfg)
                        ast_config_destroy(cfg);
                     return -1;
                  }
               }
            }
            closedir(mods);
         } else {
            if (!option_quiet)
               ast_log(LOG_WARNING, "Unable to open modules directory %s.\n", (char *)ast_config_AST_MODULE_DIR);
         }
      }
   } 
   ast_config_destroy(cfg);
   return 0;
}

static int printdigest

(

unsigned char *

d

)

[static]

Definition at line 84 of file loader.c.

References ast_log(), and LOG_DEBUG.

Referenced by verify_key().

{
   int x;
   char buf[256];
   char buf2[16];
   snprintf(buf, sizeof(buf), "Unexpected signature:");
   for (x=0; x<16; x++) {
      snprintf(buf2, sizeof(buf2), " %02x", *(d++));
      strcat(buf, buf2);
   }
   strcat(buf, "\n");
   ast_log(LOG_DEBUG, "%s", buf);
   return 0;
}

static int verify_key

(

unsigned char *

key

)

[static]

Definition at line 109 of file loader.c.

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

Referenced by __load_resource().

{
   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 char expected_key[] [static]

Initial value:

{ 0x8e, 0x93, 0x22, 0x83, 0xf5, 0xc3, 0xc0, 0x75,
  0xff, 0x8b, 0xa9, 0xbe, 0x7c, 0x43, 0x74, 0x63 }

Definition at line 63 of file loader.c.

const char* loadorder[] [static]

Definition at line 458 of file loader.c.

int modlistver = 0 [static]

Definition at line 61 of file loader.c.

struct module* module_list = NULL [static]

Definition at line 60 of file loader.c.

Referenced by __load_resource(), ast_module_helper(), ast_module_reload(), ast_resource_exists(), ast_unload_resource(), and ast_update_module_list().

struct loadupdate * updaters [static]

Referenced by ast_loader_register(), ast_loader_unregister(), and ast_update_use_count().

---