diff options
Diffstat (limited to 'loader.c')
| -rw-r--r-- | loader.c | 1015 |
1 files changed, 0 insertions, 1015 deletions
diff --git a/loader.c b/loader.c deleted file mode 100644 index 790c678d2..000000000 --- a/loader.c +++ /dev/null @@ -1,1015 +0,0 @@ -/* - * Asterisk -- An open source telephony toolkit. - * - * Copyright (C) 1999 - 2006, Digium, Inc. - * - * Mark Spencer <markster@digium.com> - * - * See http://www.asterisk.org for more information about - * the Asterisk project. Please do not directly contact - * any of the maintainers of this project for assistance; - * the project provides a web site, mailing lists and IRC - * channels for your use. - * - * This program is free software, distributed under the terms of - * the GNU General Public License Version 2. See the LICENSE file - * at the top of the source tree. - */ - -/*! \file - * - * \brief Module Loader - * - * \author Mark Spencer <markster@digium.com> - * - See ModMngMnt - */ - -#define MOD_LOADER /* prevent some module-specific stuff from being compiled */ -#include "asterisk.h" - -ASTERISK_FILE_VERSION(__FILE__, "$Revision$") - -#include <stdio.h> -#include <dirent.h> -#include <unistd.h> -#include <stdlib.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" -#ifdef DLFCNCOMPAT -#include "asterisk/dlfcn-compat.h" -#else -#include <dlfcn.h> -#endif -#include "asterisk/md5.h" -#include "asterisk/utils.h" - -#ifndef RTLD_NOW -#define RTLD_NOW 0 -#endif - -static int modlistver = 0; /* increase whenever the list changes, to protect reload */ - -static unsigned char expected_key[] = -{ 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3, - 0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 }; - -/* - * Modules can be in a number of different states, as below: - * MS_FAILED attempt to load failed. This is final. - * MS_NEW just added to the list, symbols unresolved. - * MS_RESOLVED all symbols resolved, but supplier modules not active yet. - * MS_CANLOAD all symbols resolved and suppliers are all active - * (or we are in a cyclic dependency and we are breaking a loop) - * MS_ACTIVE load() returned successfully. - */ -enum st_t { /* possible states of a module */ - MS_FAILED = 0, /*!< cannot load */ - MS_NEW = 1, /*!< nothing known */ - MS_RESOLVED = 2, /*!< all required resolved */ - MS_CANLOAD = 3, /*!< as above, plus cyclic depend.*/ - MS_ACTIVE = 4, /*!< all done */ -}; - -/*! \note - * All module symbols are in module_symbols. - * Modules are then linked in a list of struct module, - * whereas updaters are in a list of struct loadupdate. - * - * Both lists (basically, the entire loader) are protected by - * the lock in module_list. - * - * A second lock, reloadlock, is used to prevent concurrent reloads - */ -struct module { - AST_LIST_ENTRY(module) next; - struct module_symbols *cb; - void *lib; /* the shared lib */ - char resource[256]; - - enum st_t state; - int export_refcount; /* how many users of exported symbols */ -}; - -struct loadupdate { - AST_LIST_ENTRY(loadupdate) next; - int (*updater)(void); -}; - -static AST_LIST_HEAD_STATIC(module_list, module); -static AST_LIST_HEAD_STATIC(updaters, loadupdate); -AST_MUTEX_DEFINE_STATIC(reloadlock); - -/*! \note - * helper localuser routines. - * All of these routines are extremely expensive, so the use of - * macros is totally unnecessary from the point of view of performance: - * the extra function call will be totally negligible in all cases. - */ - -struct localuser *ast_localuser_add(struct module_symbols *me, - struct ast_channel *chan) -{ - struct localuser *u = ast_calloc(1, sizeof(*u)); - if (u == NULL) - return NULL; - u->chan = chan; - ast_mutex_lock(&me->lock); - u->next = me->lu_head; - me->lu_head = u; - ast_mutex_unlock(&me->lock); - ast_atomic_fetchadd_int(&me->usecnt, +1); - ast_update_use_count(); - return u; -} - -void ast_localuser_remove(struct module_symbols *me, struct localuser *u) -{ - struct localuser *x, *prev = NULL; - ast_mutex_lock(&me->lock); - /* unlink from the list */ - for (x = me->lu_head; x; prev = x, x = x->next) { - if (x == u) { - if (prev) - prev->next = x->next; - else - me->lu_head = x->next; - break; - } - } - ast_mutex_unlock(&me->lock); - ast_atomic_fetchadd_int(&me->usecnt, -1); - free(u); - ast_update_use_count(); -} - -void ast_hangup_localusers(struct module_symbols *me) -{ - struct localuser *u, *next; - ast_mutex_lock(&me->lock); - for (u = me->lu_head; u; u = next) { - next = u->next; - ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD); - ast_atomic_fetchadd_int(&me->usecnt, -1); - free(u); - } - ast_mutex_unlock(&me->lock); - ast_update_use_count(); -} - -/*--- new-style loader routines ---*/ - -/* - * For backward compatibility, we have 3 types of loadable modules: - * - * MOD_0 these are the 'old style' modules, which export a number - * of callbacks, and their full interface, as globally visible - * symbols. The module needs to be loaded with RTLD_LAZY and - * RTLD_GLOBAL to make symbols visible to other modules, and - * to avoid load failures due to cross dependencies. - * - * MOD_1 The generic callbacks are all into a structure, mod_data. - * - * MOD_2 this is the 'new style' format for modules. The module must - * explictly declare which simbols are exported and which - * symbols from other modules are used, and the code in this - * loader will implement appropriate checks to load the modules - * in the correct order. Also this allows to load modules - * with RTLD_NOW and RTLD_LOCAL so there is no chance of run-time - * bugs due to unresolved symbols or name conflicts. - */ - -/* - * helper routine to print the symbolic name associated to a state - */ -static const char *st_name(enum st_t state) -{ - /* try to resolve required symbols */ - const char *st; - switch (state) { -#define ST(x) case x: st = # x; break; - ST(MS_NEW); - ST(MS_FAILED); - ST(MS_RESOLVED); - ST(MS_ACTIVE); - ST(MS_CANLOAD); - default: - st = "unknown"; - } - return st; -#undef ST -} - -/*! \brief - * Fetch/release an exported symbol - modify export_refcount by delta - * \param delta 1 to fetch a symbol, -1 to release it. - * \return on success, return symbol value. - * \note Note, modules in MS_FAIL will never match in a 'get' request. - * If src is non-NULL, on exit *src points to the source module. - * - * Must be called with the lock held. - */ -static void *module_symbol_helper(const char *name, - int delta, struct module **src) -{ - void *ret = NULL; - struct module *m; - - AST_LIST_TRAVERSE(&module_list, m, next) { - struct symbol_entry *es; - if (delta > 0 && m->state == MS_FAILED) - continue; /* cannot 'get' a symbol from a failed module */ - for (es = m->cb->exported_symbols; ret == NULL && es && es->name; es++) { - if (!strcmp(es->name, name)) { - ret = es->value; - m->export_refcount += delta; - if (src) - *src = m; - break; - } - } - if (ret) - break; - } - if (ret == NULL) - ast_log(LOG_WARNING, "symbol %s not found\n", name); - return ret; -} - -static void *release_module_symbol(const char *name) -{ - return module_symbol_helper(name, -1, NULL); -} - -static void *get_module_symbol(const char *name, struct module **src) -{ - return module_symbol_helper(name, +1, src); -} - -/*! - * \brief Release refcounts to all imported symbols, - * and change module state to MS_FAILED. - */ -static void release_module(struct module *m) -{ - struct symbol_entry *s; - - for (s = m->cb->required_symbols; s && s->name != NULL; s++) { - if (s->value != NULL) { - release_module_symbol(s->name); - s->value = NULL; - } - } - m->state = MS_FAILED; -} - -/*! \brief check that no NULL symbols are exported - the algorithms rely on that. */ -static int check_exported(struct module *m) -{ - struct symbol_entry *es = m->cb->exported_symbols; - int errors = 0; - - if (es == NULL) - return 0; - ast_log(LOG_WARNING, "module %s exports the following symbols\n", - es->name); - for (; es->name; es++) { - void **p = es->value; - int i; - - ast_log(LOG_WARNING, "\taddr %p size %8d %s\n", - es->value, es->size, es->name); - for (i = 0; i < es->size / sizeof(void *); i++, p++) { - if (*p == NULL) { - ast_log(LOG_WARNING, "\t *** null field at offset %d\n", i); - errors++; - } - } - } - return errors; -} - -/*! - * \brief Resolve symbols and change state accordingly. - * \return Return 1 if state changed, 0 otherwise. - * \note If MS_FAILED, MS_ACTIVE or MS_CANLOAD there is nothing to do. - * If a symbol cannot be resolved (no supplier or supplier in MS_FAIL), - * move to MS_FAIL and release all symbols; - * If all suppliers are MS_ACTIVE, move to MS_CANLOAD - * otherwise move to MS_RESOLVED. - */ -static int resolve(struct module *m) -{ - struct symbol_entry *s; - - if (m->state == MS_FAILED || m->state == MS_ACTIVE || m->state == MS_CANLOAD) - return 0; /* already decided what to do */ - /* now it's either MS_NEW or MS_RESOLVED. - * Be optimistic and put it in MS_CANLOAD, then try to - * resolve and verify symbols, and downgrade as appropriate. - */ - m->state = MS_CANLOAD; - for (s = m->cb->required_symbols; s && s->name != NULL; s++) { - void **p = (void **)(s->value); - - if (*p == NULL) /* symbol not resolved yet */ - *p = get_module_symbol(s->name, &s->src); - if (*p == NULL || s->src->state == MS_FAILED) { /* fail */ - ast_log(LOG_WARNING, - "Unresolved symbol %s for module %s\n", - s->name, m->resource); - release_module(m); /* and set to MS_FAILED */ - break; - } - if (s->src->state != MS_ACTIVE) - m->state = MS_RESOLVED; /* downgrade */ - } - return 1; -} - -/*! - * \brief Fixup references and load modules according to their dependency order. - * Called when new modules are added to the list. - * The algorithm is as follows: - * - all modules MS_FAILED are changed to MS_NEW, in case something - * happened that could help them. - * - first try to resolve symbols. If successful, change the - * module's state to MS_RESOLVED otherwise to MS_FAILED - * - repeat on all modules until there is progress: - * - if it is MS_ACTIVE or MS_FAILED, continue (no progress) - * - if one has all required modules in MS_ACTIVE, try to load it. - * If successful it becomes MS_ACTIVE itself, otherwise - * MS_FAILED and releases all symbols. - * In any case, we have progress. - * - if one of the dependencies is MS_FAILED, release and set to - * MS_FAILED here too. We have progress. - * - if we have no progress there is a cyclic dependency. - * Take first and change to MS_CANLOAD, i.e. as if all required are - * MS_ACTIVE. we have progress, so repeat. - * \par NOTE: - * - must be called with lock held - * - recursive calls simply return success. - */ -static int fixup(const char *caller) -{ - struct module *m; - int total = 0, new = 0, cycle = 0; - static int in_fixup = 0; /* disable recursive calls */ - - if (in_fixup) - return 0; - in_fixup++; - AST_LIST_TRAVERSE(&module_list, m, next) { - total++; - if (m->state == MS_FAILED) - m->state = MS_NEW; - if (m->state == MS_NEW) - new++; - /* print some debugging info for new modules */ - if (m->state == MS_NEW && - (m->cb->exported_symbols || m->cb->required_symbols)) - ast_log(LOG_NOTICE, - "module %-30s exports %p requires %p state %s(%d)\n", - m->resource, m->cb->exported_symbols, - m->cb->required_symbols, - st_name(m->state), m->state); - } - ast_log(LOG_DEBUG, "---- fixup (%s): %d modules, %d new ---\n", - caller, total, new); - for (;;cycle++) { - int again = 0; /* set if we need another round */ - - ast_log(LOG_DEBUG, "---- fixup: cycle %d ---\n", cycle); - AST_LIST_TRAVERSE(&module_list, m, next) { - if (resolve(m)) - again = 1; /* something changed */ - if (m->state != MS_CANLOAD) /* for now, done with this module */ - continue; - /* try to run the load routine */ - if (m->cb->load_module(m)) { /* error */ - ast_log(LOG_WARNING, "load_module %s fail\n", - m->resource); - release_module(m); /* and set to MS_FAIL */ - } else { - ast_log(LOG_WARNING, "load_module %s success\n", - m->resource); - m->state = MS_ACTIVE; - } - again = 1; /* something has changed */ - } - /* Modules in MS_RESOLVED mean a possible cyclic dependency. - * Break the indecision by setting one to CANLOAD, and repeat. - */ - AST_LIST_TRAVERSE(&module_list, m, next) { - if (m->state == MS_RESOLVED) { - m->state = MS_CANLOAD; - again = 1; - break; - } - } - if (!again) /* we are done */ - break; - } - ast_log(LOG_DEBUG, "---- fixup complete ---\n"); - in_fixup--; - return 0; -} - -/* test routines to see which modules depend on global symbols - * exported by other modules. - */ -static void check_symbols(void) -{ - struct dirent *d; - DIR *mods = opendir(ast_config_AST_MODULE_DIR); - void *lib; - char buf[1024]; - - ast_log(LOG_WARNING, "module dir <%s>\n", ast_config_AST_MODULE_DIR); - if (!mods) - return; - while((d = readdir(mods))) { - int ld = strlen(d->d_name); - /* Must end in .so to load it. */ - if (ld <= 3 || strcasecmp(d->d_name + ld - 3, ".so")) - continue; - snprintf(buf, sizeof(buf), "%s/%s", ast_config_AST_MODULE_DIR, d->d_name); - lib = dlopen(buf, RTLD_NOW | RTLD_LOCAL); - if (lib == NULL) { - ast_log(LOG_WARNING, "(notice only) module %s error %s\n", d->d_name, dlerror()); - } - dlclose(lib); - } -} -/*--- end new-style routines ---*/ - -/*! \note - * In addition to modules, the reload command handles some extra keywords - * which are listed here together with the corresponding handlers. - * This table is also used by the command completion code. - */ -static struct reload_classes_t { - const char *name; - int (*reload_fn)(void); -} reload_classes[] = { /* list in alpha order, longest match first */ - { "cdr", ast_cdr_engine_reload }, - { "dnsmgr", dnsmgr_reload }, - { "extconfig", read_config_maps }, - { "enum", ast_enum_reload }, - { "manager", reload_manager }, - { "rtp", ast_rtp_reload }, - { "http", ast_http_reload }, - { NULL, NULL } -}; - -static int printdigest(const unsigned char *d) -{ - 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 key_matches(const unsigned char *key1, const unsigned char *key2) -{ - int x; - for (x=0; x<16; x++) { - if (key1[x] != key2[x]) /* mismatch - fail now. */ - return 0; - } - return 1; -} - -static int verify_key(const unsigned char *key) -{ - 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; -} - -int ast_unload_resource(const char *resource_name, enum unload_mode force) -{ - struct module *cur; - int res = -1; - int error = 0; - if (AST_LIST_LOCK(&module_list)) /* XXX should fail here ? */ - ast_log(LOG_WARNING, "Failed to lock\n"); - AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, cur, next) { - struct module_symbols *m = cur->cb; - - if (strcasecmp(cur->resource, resource_name)) /* not us */ - continue; - if (m->usecnt > 0 || m->flags & NO_UNLOAD) { - 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); - error = 1; - break; - } - } - ast_hangup_localusers(m); - res = m->unload_module(m); - if (res) { - ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name); - if (force <= AST_FORCE_FIRM) { - error = 1; - break; - } else - ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n"); - } - release_module(cur); /* XXX */ - AST_LIST_REMOVE_CURRENT(&module_list, next); - dlclose(cur->lib); - free(cur); - break; - } - AST_LIST_TRAVERSE_SAFE_END; - if (!error) - modlistver++; - AST_LIST_UNLOCK(&module_list); - if (!error) /* XXX maybe within the lock ? */ - ast_update_use_count(); - return res; -} - -char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload) -{ - struct 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, next) { - if (!strncasecmp(word, cur->resource, l) && (cur->cb->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; -} - -int ast_module_reload(const char *name) -{ - struct module *cur; - int res = 0; /* return value. 0 = not found, others, see below */ - int i, oldversion; - - if (ast_mutex_trylock(&reloadlock)) { - ast_verbose("The previous reload command didn't finish yet\n"); - return -1; /* reload already in progress */ - } - /* 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 */ - } - } - ast_lastreloadtime = time(NULL); - - AST_LIST_LOCK(&module_list); - oldversion = modlistver; - AST_LIST_TRAVERSE(&module_list, cur, next) { - struct module_symbols *m = cur->cb; - if (name && strcasecmp(name, cur->resource)) /* not ours */ - continue; - if (!m->reload) { /* cannot be reloaded */ - if (res < 1) /* store result if possible */ - res = 1; /* 1 = no reload() method */ - continue; - } - /* drop the lock and try a reload. if successful, break */ - AST_LIST_UNLOCK(&module_list); - res = 2; - if (option_verbose > 2) - ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", cur->resource, m->description()); - m->reload(m); - AST_LIST_LOCK(&module_list); - if (oldversion != modlistver) /* something changed, abort */ - break; - } - AST_LIST_UNLOCK(&module_list); - ast_mutex_unlock(&reloadlock); - return res; -} - -static int resource_exists(const char *resource, int do_lock) -{ - struct module *cur; - if (do_lock && AST_LIST_LOCK(&module_list)) - ast_log(LOG_WARNING, "Failed to lock\n"); - AST_LIST_TRAVERSE(&module_list, cur, next) { - if (!strcasecmp(resource, cur->resource)) - break; - } - if (do_lock) - AST_LIST_UNLOCK(&module_list); - return cur ? -1 : 0; -} - -/* lookup a symbol with or without leading '_', accept either form in input */ -static void *find_symbol(struct module *m, const char *name, int verbose) -{ - char *n1; - void *s; - - if (name[0] == '_') - name++; - n1 = alloca(strlen(name) + 2); /* room for leading '_' and final '\0' */ - n1[0] = '_'; - strcpy(n1+1, name); - s = dlsym(m->lib, n1+1); /* try without '_' */ - if (s == NULL) - s = dlsym(m->lib, n1); - if (verbose && s == NULL) - ast_log(LOG_WARNING, "No symbol '%s' in module '%s\n", - n1, m->resource); - return s; -} - -/* XXX cfg is only used for !res_* and #ifdef RTLD_GLOBAL */ -static struct module * __load_resource(const char *resource_name, - const struct ast_config *cfg) -{ - static char fn[256]; - int errors=0; - int res; - struct module *cur; - struct module_symbols *m = NULL; - int flags = RTLD_NOW; - unsigned char *key; - char tmp[80]; - -#ifndef RTLD_GLOBAL -#define RTLD_GLOBAL 0 /* so it is a No-op */ -#endif - if (strncasecmp(resource_name, "res_", 4) && cfg) { - char *val = ast_variable_retrieve(cfg, "global", resource_name); - if (val && ast_true(val)) - flags |= RTLD_GLOBAL; - } else { - /* Resource modules are always loaded global and lazy */ - flags = (RTLD_GLOBAL | RTLD_LAZY); - } - - if (AST_LIST_LOCK(&module_list)) - ast_log(LOG_WARNING, "Failed to lock\n"); - if (resource_exists(resource_name, 0)) { - ast_log(LOG_WARNING, "Module '%s' already exists\n", resource_name); - AST_LIST_UNLOCK(&module_list); - return NULL; - } - if (!(cur = ast_calloc(1, sizeof(*cur)))) { - AST_LIST_UNLOCK(&module_list); - return NULL; - } - ast_copy_string(cur->resource, resource_name, sizeof(cur->resource)); - if (resource_name[0] == '/') - ast_copy_string(fn, resource_name, sizeof(fn)); - else - snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR, resource_name); - - /* open in a sane way */ - cur->lib = dlopen(fn, RTLD_NOW | RTLD_LOCAL); - if (cur->lib && - ((m = find_symbol(cur, "mod_data", 0)) == NULL || (m->flags & MOD_MASK) == MOD_0)) { - /* old-style module, close and reload with standard flags */ - dlclose(cur->lib); - cur->lib = NULL; - m = NULL; - } - if (cur->lib == NULL) /* try reopen with the old style */ - cur->lib = dlopen(fn, flags); - - if (!cur->lib) { - ast_log(LOG_WARNING, "%s\n", dlerror()); - free(cur); - AST_LIST_UNLOCK(&module_list); - return NULL; - } - if (m == NULL) /* MOD_0 modules may still have a mod_data entry */ - m = find_symbol(cur, "mod_data", 0); - if (m != NULL) { /* new style module */ - cur->cb = m; /* use the mod_data from the module itself */ - errors = check_exported(cur); - } else { - ast_log(LOG_WARNING, "missing mod_data for %s\n", - resource_name); - errors++; - } - if (!m->load_module) - errors++; - if (!m->unload_module && !(m->flags & NO_UNLOAD) ) - errors++; - if (!m->description) - errors++; - if (!m->key) - errors++; - 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(cur->lib); - free(cur); - AST_LIST_UNLOCK(&module_list); - return NULL; - } - /* init mutex and usecount */ - ast_mutex_init(&cur->cb->lock); - cur->cb->lu_head = NULL; - - if (!ast_fully_booted) { - if (option_verbose) - ast_verbose( " => (%s)\n", term_color(tmp, m->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", fn, m->description()); - } - - AST_LIST_INSERT_TAIL(&module_list, cur, next); - /* add module to end of module_list chain - so reload commands will be issued in same order modules were loaded */ - - modlistver++; - if ( (m->flags & MOD_MASK) == MOD_2) { - ast_log(LOG_WARNING, "new-style module %s, deferring load()\n", - resource_name); - cur->state = MS_NEW; - } else - cur->state = MS_CANLOAD; - /* XXX make sure the usecount is 1 before releasing the lock */ - AST_LIST_UNLOCK(&module_list); - - if (cur->state == MS_CANLOAD && (res = m->load_module(m))) { - ast_log(LOG_WARNING, "%s: load_module failed, returning %d\n", resource_name, res); - ast_unload_resource(resource_name, 0); - return NULL; - } - cur->state = MS_ACTIVE; - ast_update_use_count(); - return cur; -} - -/*! - * \brief load a single module (API call). - * (recursive calls from load_module() succeed. - * \return Returns 0 on success, -1 on error. - */ -int ast_load_resource(const char *resource_name) -{ - int o = option_verbose; - struct ast_config *cfg = NULL; - struct module *m; - - option_verbose = 0; /* Keep the module file parsing silent */ - cfg = ast_config_load(AST_MODULE_CONFIG); - option_verbose = o; /* restore verbosity */ - m = __load_resource(resource_name, cfg); - if (cfg) - ast_config_destroy(cfg); - return m ? 0 : -1; -} - -#if 0 -/* - * load a single module (API call). - * (recursive calls from load_module() succeed. - */ -int ast_load_resource(const char *resource_name) -{ - struct module *m; - int ret; - - ast_mutex_lock(&modlock); - m = __load_resource(resource_name, 0); - fixup(resource_name); - ret = (m->state == MS_FAILED) ? -1 : 0; - ast_mutex_unlock(&modlock); - return ret; -} -#endif - -/*! \brief if enabled, log and output on console the module's name, and try load it */ -static int print_and_load(const char *s, struct ast_config *cfg) -{ - char tmp[80]; - - if (option_debug && !option_verbose) - ast_log(LOG_DEBUG, "Loading module %s\n", s); - if (option_verbose) { - ast_verbose(VERBOSE_PREFIX_1 "[%s]", - term_color(tmp, s, COLOR_BRWHITE, 0, sizeof(tmp))); - fflush(stdout); - } - if (__load_resource(s, cfg)) - return 0; /* success */ - ast_log(LOG_WARNING, "Loading module %s failed!\n", s); - return -1; -} - -static const char *loadorder[] = -{ - "res_", - "pbx_", - "chan_", - NULL, -}; - -int load_modules(const int preload_only) -{ - struct ast_config *cfg; - int x; - - if (option_verbose) { - ast_verbose(preload_only ? - "Asterisk Dynamic Loader loading preload modules:\n" : - "Asterisk Dynamic Loader Starting:\n"); - } - - if (0) - check_symbols(); - - cfg = ast_config_load(AST_MODULE_CONFIG); - - if (cfg) { - const char *cmd = preload_only ? "preload" : "load"; - struct ast_variable *v; - /* Load explicitly defined modules */ - for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) { - if (strcasecmp(v->name, cmd)) /* not what we are looking for */ - continue; - if (print_and_load(v->value, cfg)) { /* XXX really fatal ? */ - ast_config_destroy(cfg); - return -1; - } - } - } - - if (preload_only) - goto done; - - if (cfg && !ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) - /* no autoload */ - goto done; - /* - * Load all modules. To help resolving dependencies, we load modules - * in the order defined by loadorder[], with the final step for - * all modules with other prefixes. - * (XXX the new loader does not need this). - */ - - for (x=0; x<sizeof(loadorder) / sizeof(loadorder[0]); x++) { - struct dirent *d; - DIR *mods = opendir(ast_config_AST_MODULE_DIR); - const char *base = loadorder[x]; - int lx = base ? strlen(base) : 0; - - if (!mods) { - if (!ast_opt_quiet) - ast_log(LOG_WARNING, "Unable to open modules directory %s.\n", - ast_config_AST_MODULE_DIR); - break; /* suffices to try once! */ - } - while((d = readdir(mods))) { - int ld = strlen(d->d_name); - /* Must end in .so to load it. */ - if (ld > 3 && (!base || !strncasecmp(d->d_name, base, lx)) && - !strcasecmp(d->d_name + ld - 3, ".so") && - !resource_exists(d->d_name, 1)) { - /* It's a shared library, check if we are allowed to load it - * (very inefficient, but oh well). - */ - if (cfg) { - struct ast_variable *v; - for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) { - if (!strcasecmp(v->name, "noload") && - !strcasecmp(v->value, d->d_name)) - break; - } - if (v) { - if (option_verbose) { - ast_verbose( VERBOSE_PREFIX_1 "[skipping %s]\n", - d->d_name); - fflush(stdout); - } - continue; - } - - } - if (print_and_load(d->d_name, cfg)) { - ast_config_destroy(cfg); - return -1; - } - } - } - closedir(mods); - } -done: - fixup("load_modules"); - ast_config_destroy(cfg); - return 0; -} - -#include <errno.h> /* for errno... */ - -void ast_update_use_count(void) -{ - /* Notify any module monitors that the use count for a - resource has changed */ - struct loadupdate *m; - if (AST_LIST_LOCK(&module_list)) - ast_log(LOG_WARNING, "Failed to lock, errno %d\n", errno); - AST_LIST_TRAVERSE(&updaters, m, next) - m->updater(); - AST_LIST_UNLOCK(&module_list); -} - -int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like), - const char *like) -{ - struct module *cur; - int unlock = -1; - int total_mod_loaded = 0; - - if (ast_mutex_trylock(&module_list.lock)) - unlock = 0; - AST_LIST_TRAVERSE(&module_list, cur, next) { - total_mod_loaded += modentry(cur->resource, cur->cb->description(), cur->cb->usecnt, like); - } - if (unlock) - AST_LIST_UNLOCK(&module_list); - - return total_mod_loaded; -} - -int ast_loader_register(int (*v)(void)) -{ - /* XXX Should be more flexible here, taking > 1 verboser XXX */ - struct loadupdate *tmp; - if (!(tmp = ast_malloc(sizeof(*tmp)))) - return -1; - tmp->updater = v; - if (AST_LIST_LOCK(&module_list)) - ast_log(LOG_WARNING, "Failed to lock\n"); - AST_LIST_INSERT_HEAD(&updaters, tmp, next); - AST_LIST_UNLOCK(&module_list); - return 0; -} - -int ast_loader_unregister(int (*v)(void)) -{ - struct loadupdate *cur; - - if (AST_LIST_LOCK(&module_list)) - ast_log(LOG_WARNING, "Failed to lock\n"); - AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, next) { - if (cur->updater == v) { - AST_LIST_REMOVE_CURRENT(&updaters, next); - break; - } - } - AST_LIST_TRAVERSE_SAFE_END; - AST_LIST_UNLOCK(&module_list); - return cur ? 0 : -1; -} |