/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 1999 - 2006, Digium, Inc.
*
* Mark Spencer <markster@digium.com>
* Kevin P. Fleming <kpfleming@digium.com>
* Luigi Rizzo <rizzo@icir.org>
*
* 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>
* \author Kevin P. Fleming <kpfleming@digium.com>
* \author Luigi Rizzo <rizzo@icir.org>
* - See ModMngMnt
*/
/*** MODULEINFO
<support_level>core</support_level>
***/
#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/paths.h" /* use ast_config_AST_MODULE_DIR */
#include <dirent.h>
#include "asterisk/dlinkedlists.h"
#include "asterisk/module.h"
#include "asterisk/config.h"
#include "asterisk/channel.h"
#include "asterisk/term.h"
#include "asterisk/manager.h"
#include "asterisk/io.h"
#include "asterisk/lock.h"
#include "asterisk/vector.h"
#include "asterisk/app.h"
#include "asterisk/test.h"
#include "asterisk/cli.h"
#include <dlfcn.h>
#include "asterisk/md5.h"
#include "asterisk/utils.h"
/*** DOCUMENTATION
<managerEvent language="en_US" name="Reload">
<managerEventInstance class="EVENT_FLAG_SYSTEM">
<since>
<version>12.0.0</version>
</since>
<synopsis>Raised when a module has been reloaded in Asterisk.</synopsis>
<syntax>
<parameter name="Module">
<para>The name of the module that was reloaded, or
<literal>All</literal> if all modules were reloaded</para>
</parameter>
<parameter name="Status">
<para>The numeric status code denoting the success or failure
of the reload request.</para>
<enumlist>
<enum name="0"><para>Success</para></enum>
<enum name="1"><para>Request queued</para></enum>
<enum name="2"><para>Module not found</para></enum>
<enum name="3"><para>Error</para></enum>
<enum name="4"><para>Reload already in progress</para></enum>
<enum name="5"><para>Module uninitialized</para></enum>
<enum name="6"><para>Reload not supported</para></enum>
</enumlist>
</parameter>
</syntax>
</managerEventInstance>
</managerEvent>
<managerEvent language="en_US" name="Load">
<managerEventInstance class="EVENT_FLAG_SYSTEM">
<since>
<version>16.0.0</version>
</since>
<synopsis>Raised when a module has been loaded in Asterisk.</synopsis>
<syntax>
<parameter name="Module">
<para>The name of the module that was loaded</para>
</parameter>
<parameter name="Status">
<para>The result of the load request.</para>
<enumlist>
<enum name="Failure"><para>Module could not be loaded properly</para></enum>
<enum name="Success"><para>Module loaded and configured</para></enum>
<enum name="Decline"><para>Module is not configured</para></enum>
</enumlist>
</parameter>
</syntax>
</managerEventInstance>
</managerEvent>
<managerEvent language="en_US" name="Unload">
<managerEventInstance class="EVENT_FLAG_SYSTEM">
<since>
<version>16.0.0</version>
</since>
<synopsis>Raised when a module has been unloaded in Asterisk.</synopsis>
<syntax>
<parameter name="Module">
<para>The name of the module that was unloaded</para>
</parameter>
<parameter name="Status">
<para>The result of the unload request.</para>
<enumlist>
<enum name="Success"><para>Module unloaded successfully</para></enum>
</enumlist>
</parameter>
</syntax>
</managerEventInstance>
</managerEvent>
***/
#ifndef RTLD_NOW
#define RTLD_NOW 0
#endif
#ifndef RTLD_LOCAL
#define RTLD_LOCAL 0
#endif
struct ast_module_user {
struct ast_channel *chan;
AST_LIST_ENTRY(ast_module_user) entry;
};
AST_DLLIST_HEAD(module_user_list, ast_module_user);
static const unsigned char expected_key[] =
{ 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3,
0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 };
static char buildopt_sum[33] = AST_BUILDOPT_SUM;
AST_VECTOR(module_vector, struct ast_module *);
/*! Used with AST_VECTOR_CALLBACK_VOID to create a
* comma separated list of module names for error messages. */
#define STR_APPEND_TEXT(txt, str) \
ast_str_append(str, 0, "%s%s", \
ast_str_strlen(*(str)) > 0 ? ", " : "", \
txt)
/* Built-in module registrations need special handling at startup */
static unsigned int loader_ready;
/*! String container for deferring output of startup errors. */
static struct ast_vector_string startup_errors;
static struct ast_str *startup_error_builder;
#if defined(HAVE_PERMANENT_DLOPEN) || defined(AST_XML_DOCS)
static char *get_name_from_resource(const char *resource)
{
int len;
const char *last_three;
char *mod_name;
if (!resource) {
return NULL;
}
len = strlen(resource);
if (len > 3) {
last_three = &resource[len-3];
if (!strcasecmp(last_three, ".so")) {
mod_name = ast_calloc(1, len - 2);
if (mod_name) {
ast_copy_string(mod_name, resource, len - 2);
return mod_name;
} else {
/* Unable to allocate memory. */
return NULL;
}
}
}
/* Resource is the name - happens when manually unloading a module. */
mod_name = ast_calloc(1, len + 1);
if (mod_name) {
ast_copy_string(mod_name, resource, len + 1);
return mod_name;
}
/* Unable to allocate memory. */
return NULL;
}
#endif
#if defined(HAVE_PERMANENT_DLOPEN)
#define FIRST_DLOPEN 999
struct ao2_container *info_list = NULL;
struct info_list_obj {
const struct ast_module_info *info;
int dlopened;
char name[0];
};
static struct info_list_obj *info_list_obj_alloc(const char *name,
const struct ast_module_info *info)
{
struct info_list_obj *new_entry;
new_entry = ao2_alloc(sizeof(*new_entry) + strlen(name) + 1, NULL);
if (!new_entry) {
return NULL;
}
strcpy(new_entry->name, name); /* SAFE */
new_entry->info = info;
new_entry->dlopened = FIRST_DLOPEN;
return new_entry;
}
AO2_STRING_FIELD_CMP_FN(info_list_obj, name)
static void manual_mod_reg(const void *lib, const char *resource)
{
struct info_list_obj *obj_tmp;
char *mod_name;
if (lib) {
mod_name = get_name_from_resource(resource);
if (mod_name) {
obj_tmp = ao2_find(info_list, mod_name, OBJ_SEARCH_KEY);
if (obj_tmp) {
if (obj_tmp->dlopened == FIRST_DLOPEN) {
obj_tmp->dlopened = 1;
} else {
ast_module_register(obj_tmp->info);
}
ao2_ref(obj_tmp, -1);
}
ast_free(mod_name);
}
}
}
static void manual_mod_unreg(const char *resource)
{
struct info_list_obj *obj_tmp;
char *mod_name;
/* When Asterisk shuts down the destructor is called automatically. */
if (ast_shutdown_final()) {
return;
}
mod_name = get_name_from_resource(resource);
if (mod_name) {
obj_tmp = ao2_find(info_list, mod_name, OBJ_SEARCH_KEY);
if (obj_tmp) {
ast_module_unregister(obj_tmp->info);
ao2_ref(obj_tmp, -1);
}
ast_free(mod_name);
}
}
#endif
static __attribute__((format(printf, 1, 2))) void module_load_error(const char *fmt, ...)
{
char *copy = NULL;
va_list ap;
va_start(ap, fmt);
if (startup_error_builder) {
ast_str_set_va(&startup_error_builder, 0, fmt, ap);
copy = ast_strdup(ast_str_buffer(startup_error_builder));
if (!copy || AST_VECTOR_APPEND(&startup_errors, copy)) {
ast_log(LOG_ERROR, "%s", ast_str_buffer(startup_error_builder));
ast_free(copy);
}
} else {
ast_log_ap(LOG_ERROR, fmt, ap);
}
va_end(ap);
}
/*!
* \brief Internal flag to indicate all modules have been initially loaded.
*/
static int modules_loaded;
struct ast_module {
const struct ast_module_info *info;
/*! Used to get module references into refs log */
void *ref_debug;
/*! The shared lib. */
void *lib;
/*! Number of 'users' and other references currently holding the module. */
int usecount;
/*! List of users holding the module. */
struct module_user_list users;
/*! List of required module names. */
struct ast_vector_string requires;
/*! List of optional api modules. */
struct ast_vector_string optional_modules;
/*! List of modules this enhances. */
struct ast_vector_string enhances;
/*!
* \brief Vector holding pointers to modules we have a reference to.
*
* When one module requires another, the required module gets added
* to this list with a reference.
*/
struct module_vector reffed_deps;
struct {
/*! The module running and ready to accept requests. */
unsigned int running:1;
/*! The module has declined to start. */
unsigned int declined:1;
/*! This module is being held open until it's time to shutdown. */
unsigned int keepuntilshutdown:1;
/*! The module is built-in. */
unsigned int builtin:1;
/*! The admin has declared this module is required. */
unsigned int required:1;
/*! This module is marked for preload. */
unsigned int preload:1;
} flags;
AST_DLLIST_ENTRY(ast_module) entry;
char resource[0];
};
static AST_DLLIST_HEAD_STATIC(module_list, ast_module);
struct load_results_map {
int result;
const char *name;
};
static const struct load_results_map load_results[] = {
{ AST_MODULE_LOAD_SUCCESS, "Success" },
{ AST_MODULE_LOAD_DECLINE, "Decline" },
{ AST_MODULE_LOAD_SKIP, "Skip" },
{ AST_MODULE_LOAD_PRIORITY, "Priority" },
{ AST_MODULE_LOAD_FAILURE, "Failure" },
};
#define AST_MODULE_LOAD_UNKNOWN_STRING "Unknown" /* Status string for unknown load status */
static void publish_load_message_type(const char* type, const char *name, const char *status);
static void publish_reload_message(const char *name, enum ast_module_reload_result result);
static void publish_load_message(const char *name, enum ast_module_load_result result);
static void publish_unload_message(const char *name, const char* status);
/*
* module_list is cleared by its constructor possibly after
* we start accumulating built-in modules, so we need to
* use another list (without the lock) to accumulate them.
*/
static struct module_list builtin_module_list;
static int module_vector_strcasecmp(struct ast_module *a, struct ast_module *b)
{
return strcasecmp(a->resource, b->resource);
}
static int module_vector_cmp(struct ast_module *a, struct ast_module *b)
{
int preload_diff = (int)b->flags.preload - (int)a->flags.preload;
/* if load_pri is not set, default is 128. Lower is better */
int a_pri = ast_test_flag(a->info, AST_MODFLAG_LOAD_ORDER)
? a->info->load_pri : AST_MODPRI_DEFAULT;
int b_pri = ast_test_flag(b->info, AST_MODFLAG_LOAD_ORDER)
? b->info->load_pri : AST_MODPRI_DEFAULT;
if (preload_diff) {
/* -1 preload a but not b */
/* 0 preload both or neither */
/* 1 preload b but not a */
return preload_diff;
}
/*
* Returns comparison values for a vector sorted by priority.
* <0 a_pri < b_pri
* =0 a_pri == b_pri
* >0 a_pri > b_pri
*/
return a_pri - b_pri;
}
static struct ast_module *find_resource(const char *resource, int do_lock);
/*!
* \internal
* \brief Add a reference from mod to dep.
*
* \param mod Owner of the new reference.
* \param dep Module to reference
* \param missing Vector to store name of \a dep if it is not running.
*
* This function returns failure if \a dep is not running and \a missing
* is NULL. If \a missing is not NULL errors will only be returned for
* allocation failures.
*
* \retval 0 Success
* \retval -1 Failure
*
* \note Adding a second reference to the same dep will return success
* without doing anything.
*/
static int module_reffed_deps_add(struct ast_module *mod, struct ast_module *dep,
struct ast_vector_const_string *missing)
{
if (!dep->flags.running) {
return !missing ? -1 : AST_VECTOR_APPEND(missing, dep->info->name);
}
if (AST_VECTOR_GET_CMP(&mod->reffed_deps, dep, AST_VECTOR_ELEM_DEFAULT_CMP)) {
/* Skip duplicate. */
return 0;
}
if (AST_VECTOR_APPEND(&mod->reffed_deps, dep)) {
return -1;
}
ast_module_ref(dep);
return 0;
}
/*!
* \internal
* \brief Add references for modules that enhance a dependency.
*
* \param mod Owner of the new references.
* \param dep Module to check for enhancers.
* \param missing Vector to store name of any enhancer that is not running or declined.
*
* \retval 0 Success
* \retval -1 Failure
*/
static int module_reffed_deps_add_dep_enhancers(struct ast_module *mod,
struct ast_module *dep, struct ast_vector_const_string *missing)
{
struct ast_module *cur;
AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
if (cur->flags.declined) {
continue;
}
if (!AST_VECTOR_GET_CMP(&cur->enhances, dep->info->name, !strcasecmp)) {
/* dep is not enhanced by cur. */
continue;
}
/* dep is enhanced by cur, therefore mod requires cur. */
if (module_reffed_deps_add(mod, cur, missing)) {
return -1;
}
}
return 0;
}
/*!
* \internal
* \brief Add references to a list of dependencies.
*
* \param mod Owner of the new references.
* \param vec List of required modules to process
* \param missing Vector to store names of modules that are not running.
* \param ref_enhancers Reference all enhancers of each required module.
* \param isoptional Modules that are not loaded can be ignored.
*
* \retval 0 Success
* \retval -1 Failure
*/
static int module_deps_process_reqlist(struct ast_module *mod,
struct ast_vector_string *vec, struct ast_vector_const_string *missing,
int ref_enhancers, int isoptional)
{
int idx;
for (idx = 0; idx < AST_VECTOR_SIZE(vec); idx++) {
const char *depname = AST_VECTOR_GET(vec, idx);
struct ast_module *dep = find_resource(depname, 0);
if (!dep || !dep->flags.running) {
if (isoptional && !dep) {
continue;
}
if (missing && !AST_VECTOR_APPEND(missing, depname)) {
continue;
}
return -1;
}
if (module_reffed_deps_add(mod, dep, missing)) {
return -1;
}
if (ref_enhancers && module_reffed_deps_add_dep_enhancers(mod, dep, missing)) {
return -1;
}
}
return 0;
}
/*!
* \internal
* \brief Grab all references required to start the module.
*
* \param mod The module we're trying to start.
* \param missing Vector to store a list of missing dependencies.
*
* \retval 0 Success
* \retval -1 Failure
*
* \note module_list must be locked.
*
* \note Caller is responsible for initializing and freeing the vector.
* Elements are safely read only while module_list remains locked.
*/
static int module_deps_reference(struct ast_module *mod, struct ast_vector_const_string *missing)
{
int res = 0;
/* Grab references to modules we enhance but not other enhancements. */
res |= module_deps_process_reqlist(mod, &mod->enhances, missing, 0, 0);
/* Grab references to modules we require plus enhancements. */
res |= module_deps_process_reqlist(mod, &mod->requires, missing, 1, 0);
/* Grab references to optional modules including enhancements. */
res |= module_deps_process_reqlist(mod, &mod->optional_modules, missing, 1, 1);
return res;
}
/*!
* \brief Recursively find required dependencies that are not running.
*
* \param mod Module to scan for dependencies.
* \param missingdeps Vector listing modules that must be started first.
*
* \retval 0 All dependencies resolved.
* \retval -1 Failed to resolve some dependencies.
*
* An error from this function usually means a required module is not even
* loaded. This function is safe from infinite recursion, but dependency
* loops are not reported as an error from here. On success missingdeps
* will contain a list of every module that needs to be running before this
* module can start. missingdeps is sorted by load priority so any missing
* dependencies can be started if needed.
*/
static int module_deps_missing_recursive(struct ast_module *mod, struct module_vector *missingdeps)
{
int i = 0;
int res = -1;
struct ast_vector_const_string localdeps;
struct ast_module *dep;
/*
* localdeps stores a copy of all dependencies that mod could not reference.
* First we discard modules that we've already found. We add all newly found
* modules to the missingdeps vector then scan them recursively. This will
* ensure we quickly run out of stuff to do.
*/
AST_VECTOR_INIT(&localdeps, 0);
if (module_deps_reference(mod, &localdeps)) {
goto clean_return;
}
while (i < AST_VECTOR_SIZE(&localdeps)) {
dep = find_resource(AST_VECTOR_GET(&localdeps, i), 0);
if (!dep) {
goto clean_return;
}
if (AST_VECTOR_GET_CMP(missingdeps, dep, AST_VECTOR_ELEM_DEFAULT_CMP)) {
/* Skip common dependency. We have already searched it. */
AST_VECTOR_REMOVE(&localdeps, i, 0);
} else {
/* missingdeps is the real list so keep it sorted. */
if (AST_VECTOR_ADD_SORTED(missingdeps, dep, module_vector_cmp)) {
goto clean_return;
}
i++;
}
}
res = 0;
for (i = 0; !res && i < AST_VECTOR_SIZE(&localdeps); i++) {
dep = find_resource(AST_VECTOR_GET(&localdeps, i), 0);
/* We've already confirmed dep is loaded in the first loop. */
res = module_deps_missing_recursive(dep, missingdeps);
}
clean_return:
AST_VECTOR_FREE(&localdeps);
return res;
}
const char *ast_module_name(const struct ast_module *mod)
{
if (!mod || !mod->info) {
return NULL;
}
return mod->info->name;
}
struct loadupdate {
int (*updater)(void);
AST_LIST_ENTRY(loadupdate) entry;
};
static AST_DLLIST_HEAD_STATIC(updaters, loadupdate);
AST_MUTEX_DEFINE_STATIC(reloadlock);
struct reload_queue_item {
AST_LIST_ENTRY(reload_queue_item) entry;
char module[0];
};
static int do_full_reload = 0;
static AST_DLLIST_HEAD_STATIC(reload_queue, reload_queue_item);
/*!
* \internal
*
* This variable is set by load_dynamic_module so ast_module_register
* can know what pointer is being registered.
*
* This is protected by the module_list lock.
*/
static struct ast_module * volatile resource_being_loaded;
/*!
* \internal
* \brief Used by AST_MODULE_INFO to register with the module loader.
*
* This function is automatically called when each module is opened.
* It must never be used from outside AST_MODULE_INFO.
*/
void ast_module_register(const struct ast_module_info *info)
{
struct ast_module *mod;
if (!loader_ready) {
mod = ast_std_calloc(1, sizeof(*mod) + strlen(info->name) + 1);
if (!mod) {
/* We haven't even reached main() yet, if we can't
* allocate memory at this point just give up. */
fprintf(stderr, "Allocation failure during startup.\n");
exit(2);
}
strcpy(mod->resource, info->name); /* safe */
mod->info = info;
mod->flags.builtin = 1;
AST_DLLIST_INSERT_TAIL(&builtin_module_list, mod, entry);
/* ast_module_register for built-in modules is run again during module preload. */
return;
}
/*
* This lock protects resource_being_loaded as well as the module
* list. Normally we already have a lock on module_list when we
* begin the load but locking again from here prevents corruption
* if an asterisk module is dlopen'ed from outside the module loader.
*/
AST_DLLIST_LOCK(&module_list);
mod = resource_being_loaded;
if (!mod) {
AST_DLLIST_UNLOCK(&module_list);
return;
}
ast_debug(5, "Registering module %s\n", info->name);
/* This tells load_dynamic_module that we're registered. */
resource_being_loaded = NULL;
mod->info = info;
if (ast_opt_ref_debug) {
mod->ref_debug = ao2_t_alloc_options(0, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK, info->name);
}
AST_LIST_HEAD_INIT(&mod->users);
AST_VECTOR_INIT(&mod->requires, 0);
AST_VECTOR_INIT(&mod->optional_modules, 0);
AST_VECTOR_INIT(&mod->enhances, 0);
AST_VECTOR_INIT(&mod->reffed_deps, 0);
AST_DLLIST_INSERT_TAIL(&module_list, mod, entry);
AST_DLLIST_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;
#if defined(HAVE_PERMANENT_DLOPEN)
if (mod->flags.builtin != 1) {
struct info_list_obj *obj_tmp = ao2_find(info_list, info->name,
OBJ_SEARCH_KEY);
if (!obj_tmp) {
obj_tmp = info_list_obj_alloc(info->name, info);
if (obj_tmp) {
ao2_link(info_list, obj_tmp);
ao2_ref(obj_tmp, -1);
}
} else {
ao2_ref(obj_tmp, -1);
}
}
#endif
}
static int module_post_register(struct ast_module *mod)
{
int res;
/* Split lists from mod->info. */
res = ast_vector_string_split(&mod->requires, mod->info->requires, ",", 0, strcasecmp);
res |= ast_vector_string_split(&mod->optional_modules, mod->info->optional_modules, ",", 0, strcasecmp);
res |= ast_vector_string_split(&mod->enhances, mod->info->enhances, ",", 0, strcasecmp);
return res;
}
static void module_destroy(struct ast_module *mod)
{
AST_VECTOR_CALLBACK_VOID(&mod->requires, ast_free);
AST_VECTOR_FREE(&mod->requires);
AST_VECTOR_CALLBACK_VOID(&mod->optional_modules, ast_free);
AST_VECTOR_FREE(&mod->optional_modules);
AST_VECTOR_CALLBACK_VOID(&mod->enhances, ast_free);
AST_VECTOR_FREE(&mod->enhances);
/* Release references to all dependencies. */
AST_VECTOR_CALLBACK_VOID(&mod->reffed_deps, ast_module_unref);
AST_VECTOR_FREE(&mod->reffed_deps);
AST_LIST_HEAD_DESTROY(&mod->users);
ao2_cleanup(mod->ref_debug);
if (mod->flags.builtin) {
ast_std_free(mod);
} else {
ast_free(mod);
}
}
void ast_module_unregister(const struct ast_module_info *info)
{
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_DLLIST_LOCK(&module_list);
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&module_list, mod, entry) {
if (mod->info == info) {
AST_DLLIST_REMOVE_CURRENT(entry);
break;
}
}
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
AST_DLLIST_UNLOCK(&module_list);
if (mod && !mod->usecount) {
/*
* We are intentionally leaking mod if usecount is not zero.
* This is necessary if the module is being forcefully unloaded.
* In addition module_destroy is not safe to run after exit()
* is called. ast_module_unregister is run during cleanup of
* the process when libc releases each module's shared object
* library.
*/
ast_debug(5, "Unregistering module %s\n", info->name);
module_destroy(mod);
}
}
struct ast_module_user *__ast_module_user_add(struct ast_module *mod, struct ast_channel *chan)
{
struct ast_module_user *u;
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);
if (mod->ref_debug) {
ao2_ref(mod->ref_debug, +1);
}
ast_atomic_fetchadd_int(&mod->usecount, +1);
ast_update_use_count();
return u;
}
void __ast_module_user_remove(struct ast_module *mod, struct ast_module_user *u)
{
if (!u) {
return;
}
AST_LIST_LOCK(&mod->users);
u = AST_LIST_REMOVE(&mod->users, u, entry);
AST_LIST_UNLOCK(&mod->users);
if (!u) {
/*
* Was not in the list. Either a bad pointer or
* __ast_module_user_hangup_all() has been called.
*/
return;
}
if (mod->ref_debug) {
ao2_ref(mod->ref_debug, -1);
}
ast_atomic_fetchadd_int(&mod->usecount, -1);
ast_free(u);
ast_update_use_count();
}
void __ast_module_user_hangup_all(struct ast_module *mod)
{
struct ast_module_user *u;
AST_LIST_LOCK(&mod->users);
while ((u = AST_LIST_REMOVE_HEAD(&mod->users, entry))) {
if (u->chan) {
ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
}
if (mod->ref_debug) {
ao2_ref(mod->ref_debug, -1);
}
ast_atomic_fetchadd_int(&mod->usecount, -1);
ast_free(u);
}
AST_LIST_UNLOCK(&mod->users);
ast_update_use_count();
}
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, " %02hhx", *d++);
ast_debug(1, "Unexpected signature:%s\n", buf);
return 0;
}
#define key_matches(a, b) (memcmp((a), (b), 16) == 0)
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;
}
static size_t resource_name_baselen(const char *name)
{
size_t len = strlen(name);
if (len > 3 && !strcasecmp(name + len - 3, ".so")) {
return len - 3;
}
return len;
}
static int resource_name_match(const char *name1, size_t baselen1, const char *name2)
{
if (baselen1 != resource_name_baselen(name2)) {
return -1;
}
return strncasecmp(name1, name2, baselen1);
}
static struct ast_module *find_resource(const char *resource, int do_lock)
{
struct ast_module *cur;
size_t resource_baselen = resource_name_baselen(resource);
if (do_lock) {
AST_DLLIST_LOCK(&module_list);
}
AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
if (!resource_name_match(resource, resource_baselen, cur->resource)) {
break;
}
}
if (do_lock) {
AST_DLLIST_UNLOCK(&module_list);
}
return cur;
}
/*!
* \brief dlclose(), with failure logging.
*/
static void logged_dlclose(const char *name, void *lib)
{
char *error;
if (!lib) {
return;
}
/* Clear any existing error */
dlerror();
if (dlclose(lib)) {
error = dlerror();
ast_log(AST_LOG_ERROR, "Failure in dlclose for module '%s': %s\n",
S_OR(name, "unknown"), S_OR(error, "Unknown error"));
#if defined(HAVE_PERMANENT_DLOPEN)
} else {
manual_mod_unreg(name);
#endif
}
}
#if defined(HAVE_RTLD_NOLOAD)
/*!
* \brief Check to see if the given resource is loaded.
*
* \param resource_name Name of the resource, including .so suffix.
* \return False (0) if module is not loaded.
* \return True (non-zero) if module is loaded.
*/
static int is_module_loaded(const char *resource_name)
{
char fn[PATH_MAX] = "";
void *lib;
snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR,
resource_name);
lib = dlopen(fn, RTLD_LAZY | RTLD_NOLOAD);
if (lib) {
logged_dlclose(resource_name, lib);
return 1;
}
return 0;
}
#endif
static void unload_dynamic_module(struct ast_module *mod)
{
#if defined(HAVE_RTLD_NOLOAD)
char *name = ast_strdupa(ast_module_name(mod));
#endif
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 */
logged_dlclose(ast_module_name(mod), lib);
/* There are several situations where the module might still be resident
* in memory.
*
* If somehow there was another dlopen() on the same module (unlikely,
* since that all is supposed to happen in loader.c).
*
* Avoid the temptation of repeating the dlclose(). The other code that
* dlopened the module still has its module reference, and should close
* it itself. In other situations, dlclose() will happily return success
* for as many times as you wish to call it.
*/
#if defined(HAVE_RTLD_NOLOAD)
if (is_module_loaded(name)) {
ast_log(LOG_WARNING, "Module '%s' could not be completely unloaded\n", name);
}
#endif
}
static int load_dlopen_missing(struct ast_str **list, struct ast_vector_string *deps)
{
int i;
int c = 0;
for (i = 0; i < AST_VECTOR_SIZE(deps); i++) {
const char *dep = AST_VECTOR_GET(deps, i);
if (!find_resource(dep, 0)) {
STR_APPEND_TEXT(dep, list);
c++;
}
}
return c;
}
/*!
* \internal
* \brief Attempt to dlopen a module.
*
* \param resource_in The module name to load.
* \param so_ext ".so" or blank if ".so" is already part of resource_in.
* \param filename Passed directly to dlopen.
* \param flags Passed directly to dlopen.
* \param suppress_logging Do not log any error from dlopen.
*
* \return Pointer to opened module, NULL on error.
*
* \warning module_list must be locked before calling this function.
*/
static struct ast_module *load_dlopen(const char *resource_in, const char *so_ext,
const char *filename, int flags, unsigned int suppress_logging)
{
struct ast_module *mod;
ast_assert(!resource_being_loaded);
mod = ast_calloc(1, sizeof(*mod) + strlen(resource_in) + strlen(so_ext) + 1);
if (!mod) {
return NULL;
}
sprintf(mod->resource, "%s%s", resource_in, so_ext); /* safe */
resource_being_loaded = mod;
mod->lib = dlopen(filename, flags);
#if defined(HAVE_PERMANENT_DLOPEN)
manual_mod_reg(mod->lib, mod->resource);
#endif
if (resource_being_loaded) {
struct ast_str *list;
int c = 0;
const char *dlerror_msg = ast_strdupa(S_OR(dlerror(), ""));
resource_being_loaded = NULL;
if (mod->lib) {
module_load_error("Module '%s' did not register itself during load\n", resource_in);
logged_dlclose(resource_in, mod->lib);
goto error_return;
}
if (suppress_logging) {
goto error_return;
}
resource_being_loaded = mod;
mod->lib = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
#if defined(HAVE_PERMANENT_DLOPEN)
manual_mod_reg(mod->lib, mod->resource);
#endif
if (resource_being_loaded) {
resource_being_loaded = NULL;
module_load_error("Error loading module '%s': %s\n", resource_in, dlerror_msg);
logged_dlclose(resource_in, mod->lib);
goto error_return;
}
list = ast_str_create(64);
if (list) {
if (module_post_register(mod)) {
goto loaded_error;
}
c = load_dlopen_missing(&list, &mod->requires);
c += load_dlopen_missing(&list, &mod->enhances);
#ifndef OPTIONAL_API
c += load_dlopen_missing(&list, &mod->optional_modules);
#endif
}
if (list && ast_str_strlen(list)) {
module_load_error("Error loading module '%s', missing %s: %s\n",
resource_in, c == 1 ? "dependency" : "dependencies", ast_str_buffer(list));
} else {
module_load_error("Error loading module '%s': %s\n", resource_in, dlerror_msg);
}
loaded_error:
ast_free(list);
unload_dynamic_module(mod);
return NULL;
error_return:
ast_free(mod);
return NULL;
}
return mod;
}
static struct ast_module *load_dynamic_module(const char *resource_in, unsigned int suppress_logging)
{
char fn[PATH_MAX];
struct ast_module *mod;
size_t resource_in_len = strlen(resource_in);
const char *so_ext = "";
if (resource_in_len < 4 || strcasecmp(resource_in + resource_in_len - 3, ".so")) {
so_ext = ".so";
}
snprintf(fn, sizeof(fn), "%s/%s%s", ast_config_AST_MODULE_DIR, resource_in, so_ext);
/* Try loading in quiet mode first with RTLD_LOCAL. The majority of modules do not
* export symbols so this allows the least number of calls to dlopen. */
mod = load_dlopen(resource_in, so_ext, fn, RTLD_NOW | RTLD_LOCAL, suppress_logging);
if (!mod || !ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS)) {
return mod;
}
/* Close the module so we can reopen with correct flags. */
logged_dlclose(resource_in, mod->lib);
return load_dlopen(resource_in, so_ext, fn, RTLD_NOW | RTLD_GLOBAL, 0);
}
int modules_shutdown(void)
{
struct ast_module *mod;
int somethingchanged;
int res;
AST_DLLIST_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 {
/* Reset flag before traversing the list */
somethingchanged = 0;
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&module_list, mod, entry) {
if (mod->usecount) {
ast_debug(1, "Passing on %s: its use count is %d\n",
mod->resource, mod->usecount);
continue;
}
AST_DLLIST_REMOVE_CURRENT(entry);
if (mod->flags.running && !mod->flags.declined && mod->info->unload) {
ast_verb(4, "Unloading %s\n", mod->resource);
mod->info->unload();
}
module_destroy(mod);
somethingchanged = 1;
}
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
if (!somethingchanged) {
AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
if (mod->flags.keepuntilshutdown) {
ast_module_unref(mod);
mod->flags.keepuntilshutdown = 0;
somethingchanged = 1;
}
}
}
} while (somethingchanged);
res = AST_DLLIST_EMPTY(&module_list);
AST_DLLIST_UNLOCK(&module_list);
return !res;
}
/*!
* \brief Whether or not this module should be able to be unloaded successfully,
* if we recursively unload any modules that are dependent on it.
* \note module_list should be locked when calling this
* \retval 0 if not, 1 if likely possible
*/
static int graceful_unload_possible(struct ast_module *target, struct ast_vector_const_string *dependents)
{
struct ast_module *mod;
int usecount = target->usecount;
/* Check the reffed_deps of each module to see if we're one of them. */
AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
if (AST_VECTOR_GET_CMP(&mod->reffed_deps, target, AST_VECTOR_ELEM_DEFAULT_CMP)) {
const char *name;
/* This module is dependent on the target.
* If we can unload this module gracefully,
* then that would decrement our use count.
* If any single module could not be unloaded gracefully,
* then we don't proceed. */
int unloadable;
if (AST_VECTOR_GET_CMP(dependents, ast_module_name(mod), !strcasecmp)) {
/* Already in our list, we already checked this module,
* and we gave it the green light. */
ast_debug(3, "Skipping duplicate dependent %s\n", ast_module_name(mod));
if (!--usecount) {
break;
}
continue;
}
unloadable = graceful_unload_possible(mod, dependents);
if (!unloadable) {
ast_log(LOG_NOTICE, "Can't unload %s right now because %s is dependent on it\n", ast_module_name(target), ast_module_name(mod));
return 0;
}
/* Insert at beginning, so later if we're loading modules again automatically, we can do so in the same order. */
name = ast_strdup(ast_module_name(mod));
if (!name) {
return 0;
}
ast_debug(3, "Found new dependent %s\n", ast_module_name(mod));
if (AST_VECTOR_INSERT_AT(dependents, 0, name)) {
ast_log(LOG_ERROR, "Failed to add module '%s' to vector\n", ast_module_name(mod));
return 0;
}
if (!--usecount) {
break;
}
}
}
if (usecount) {
ast_log(LOG_NOTICE, "Module %s cannot be unloaded (would still have use count %d/%d after unloading dependents)\n", ast_module_name(target), usecount, target->usecount);
return 0;
}
return 1;
}
/*!
* \brief Unload a resource
* \param resource_name Module name
* \param force
* \param recursive Whether to attempt to recursively unload dependents of this module and load them again afterwards
* \param dependents. Can be NULL if autounload is 0.
* \retval 0 on success, -1 on failure
*/
static int auto_unload_resource(const char *resource_name, enum ast_module_unload_mode force, int recursive, struct ast_vector_const_string *dependents)
{
struct ast_module *mod;
int res = -1;
int error = 0;
AST_DLLIST_LOCK(&module_list);
if (!(mod = find_resource(resource_name, 0))) {
AST_DLLIST_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) {
/* If the user asks to unload a module that didn't load, obey.
* Otherwise, we never dlclose() modules that fail to load,
* which means if the module (shared object) is updated,
* we can't load the updated module since we never dlclose()'d it.
* Accordingly, obey the unload request so we can load the module
* from scratch next time.
*/
ast_log(LOG_NOTICE, "Unloading module '%s' that previously declined to load\n", resource_name);
error = 0;
res = 0;
goto exit; /* Skip all the intervening !error checks, only the last one is relevant. */
}
if (!error && mod->usecount > 0 && recursive) {
/* Try automatically unloading all modules dependent on the module we're trying to unload,
* and then, optionally, load them back again if we end up loading this module again.
* If any modules that have us as a dependency can't be unloaded, for whatever reason,
* then the entire unload operation will fail, so to try to make this an atomic operation
* and avoid leaving modules in a partial unload state, first check if we think we're going
* to be able to pull this off, and if not, abort.
*
* A race condition is technically still possible, if some depending module suddenly goes in use
* between this check and trying to unload it, but this takes care of the majority of
* easy-to-avoid cases that would fail eventually anyways.
*
* Note that we can encounter false negatives (e.g. unloading all the dependents would allow
* a module to unload, but graceful_unload_possible returns 0). This is because it's only
* checking direct module dependencies; other dependencies caused by a module registering
* a resource that cause its ref count to get bumped aren't accounted for here.
*/
if (graceful_unload_possible(mod, dependents)) {
int i, res = 0;
size_t num_deps = AST_VECTOR_SIZE(dependents);
ast_debug(1, "%lu module%s will need to be unloaded\n", AST_VECTOR_SIZE(dependents), ESS(AST_VECTOR_SIZE(dependents)));
/* Unload from the end, since the last module was the first one added, which means it isn't a dependency of anything else. */
for (i = AST_VECTOR_SIZE(dependents) - 1; i >= 0; i--) {
const char *depname = AST_VECTOR_GET(dependents, i);
res = ast_unload_resource(depname, force);
if (res) {
ast_log(LOG_WARNING, "Failed to unload %lu module%s automatically (%s could not be unloaded)\n", num_deps, ESS(num_deps), depname);
/* To be polite, load modules that we already unloaded,
* to try to leave things the way they were when we started. */
for (i++; i < num_deps; i++) {
const char *depname = AST_VECTOR_GET(dependents, i);
res = ast_load_resource(depname);
if (res) {
ast_log(LOG_WARNING, "Could not load module '%s' again automatically\n", depname);
}
}
break;
}
}
/* Either we failed, or we successfully unloaded everything.
* If we succeeded, we can now proceed and unload ourselves. */
}
}
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, "%s unload failed, '%s' has use count %d\n", recursive ? "Recursive soft" : "Soft", resource_name, mod->usecount);
error = 1;
}
}
if (!error) {
/* Request any channels attached to the module to hangup. */
__ast_module_user_hangup_all(mod);
ast_verb(4, "Unloading %s\n", mod->resource);
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) {
/*
* Request hangup on any channels that managed to get attached
* while we called the module unload function.
*/
__ast_module_user_hangup_all(mod);
sched_yield();
}
}
if (!error)
mod->flags.running = mod->flags.declined = 0;
exit:
AST_DLLIST_UNLOCK(&module_list);
if (!error) {
unload_dynamic_module(mod);
ast_test_suite_event_notify("MODULE_UNLOAD", "Message: %s", resource_name);
ast_update_use_count();
publish_unload_message(resource_name, "Success");
}
return res;
}
int ast_refresh_resource(const char *resource_name, enum ast_module_unload_mode force, int recursive)
{
if (recursive) {
/* Recursively unload dependents of this module and then load them back again */
int res, i;
struct ast_vector_const_string dependents;
AST_VECTOR_INIT(&dependents, 0);
res = auto_unload_resource(resource_name, force, recursive, &dependents);
if (res) {
AST_VECTOR_FREE(&dependents);
return 1;
}
/* Start by loading the target again. */
if (ast_load_resource(resource_name)) {
ast_log(LOG_WARNING, "Failed to load module '%s' again automatically\n", resource_name);
AST_VECTOR_FREE(&dependents);
return -1;
}
res = 0;
/* Finally, load again any modules we had to unload in order to refresh the target.
* We must load modules in the reverse order that we unloaded them,
* to preserve dependency requirements. */
for (i = 0; i < AST_VECTOR_SIZE(&dependents); i++) {
const char *depname = AST_VECTOR_GET(&dependents, i);
int mres = ast_load_resource(depname);
if (mres) {
ast_log(LOG_WARNING, "Could not load module '%s' again automatically\n", depname);
}
res |= mres;
}
AST_VECTOR_FREE(&dependents);
return res ? -1 : 0;
}
/* Simple case: just unload and load the module again */
if (ast_unload_resource(resource_name, force)) {
return 1;
}
return ast_load_resource(resource_name);
}
int ast_unload_resource(const char *resource_name, enum ast_module_unload_mode force)
{
return auto_unload_resource(resource_name, force, 0, NULL);
}
static int module_matches_helper_type(struct ast_module *mod, enum ast_module_helper_type type)
{
switch (type) {
case AST_MODULE_HELPER_UNLOAD:
return !mod->usecount && mod->flags.running && !mod->flags.declined;
case AST_MODULE_HELPER_RELOAD:
return mod->flags.running && mod->info->reload;
case AST_MODULE_HELPER_RUNNING:
return mod->flags.running;
case AST_MODULE_HELPER_LOADED:
/* if we have a 'struct ast_module' then we're loaded. */
return 1;
default:
/* This function is not called for AST_MODULE_HELPER_LOAD. */
/* Unknown ast_module_helper_type. Assume it doesn't match. */
ast_assert(0);
return 0;
}
}
struct module_load_word {
const char *word;
size_t len;
size_t moddir_len;
};
static int module_load_helper_on_file(const char *dir_name, const char *filename, void *obj)
{
struct module_load_word *word = obj;
struct ast_module *mod;
char *filename_merged = NULL;
/* dir_name will never be shorter than word->moddir_len. */
dir_name += word->moddir_len;
if (!ast_strlen_zero(dir_name)) {
ast_assert(dir_name[0] == '/');
dir_name += 1;
if (ast_asprintf(&filename_merged, "%s/%s", dir_name, filename) < 0) {
/* If we can't allocate the string just give up! */
return -1;
}
filename = filename_merged;
}
if (!strncasecmp(filename, word->word, word->len)) {
/* Don't list files that are already loaded! */
mod = find_resource(filename, 0);
if (!mod || !mod->flags.running) {
ast_cli_completion_add(ast_strdup(filename));
}
}
ast_free(filename_merged);
return 0;
}
static void module_load_helper(const char *word)
{
struct module_load_word word_l = {
.word = word,
.len = strlen(word),
.moddir_len = strlen(ast_config_AST_MODULE_DIR),
};
AST_DLLIST_LOCK(&module_list);
ast_file_read_dirs(ast_config_AST_MODULE_DIR, module_load_helper_on_file, &word_l, -1);
AST_DLLIST_UNLOCK(&module_list);
}
char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, enum ast_module_helper_type type)
{
struct ast_module *mod;
int which = 0;
int wordlen = strlen(word);
char *ret = NULL;
if (pos != rpos) {
return NULL;
}
/* Tab completion can't be used during startup, or CLI and loader will deadlock. */
if (!ast_test_flag(&ast_options, AST_OPT_FLAG_FULLY_BOOTED)) {
return NULL;
}
if (type == AST_MODULE_HELPER_LOAD) {
module_load_helper(word);
return NULL;
}
AST_DLLIST_LOCK(&module_list);
AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
if (!module_matches_helper_type(mod, type)) {
continue;
}
if (!strncasecmp(word, mod->resource, wordlen) && ++which > state) {
ret = ast_strdup(mod->resource);
break;
}
}
AST_DLLIST_UNLOCK(&module_list);
return ret;
}
void ast_process_pending_reloads(void)
{
struct reload_queue_item *item;
modules_loaded = 1;
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);
}
static void queue_reload_request(const char *module)
{
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);
}
/*!
* \since 12
* \internal
* \brief Publish a \ref stasis message regarding the type.
*/
static void publish_load_message_type(const char* type, const char *name, const char *status)
{
RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
RAII_VAR(struct ast_json *, event_object, NULL, ast_json_unref);
ast_assert(type != NULL);
ast_assert(!ast_strlen_zero(name));
ast_assert(!ast_strlen_zero(status));
if (!ast_manager_get_generic_type()) {
return;
}
event_object = ast_json_pack("{s:s, s:s}",
"Module", name,
"Status", status);
json_object = ast_json_pack("{s:s, s:i, s:o}",
"type", type,
"class_type", EVENT_FLAG_SYSTEM,
"event", ast_json_ref(event_object));
if (!json_object) {
return;
}
payload = ast_json_payload_create(json_object);
if (!payload) {
return;
}
message = stasis_message_create(ast_manager_get_generic_type(), payload);
if (!message) {
return;
}
stasis_publish(ast_manager_get_topic(), message);
}
static const char* loadresult2str(enum ast_module_load_result result)
{
int i;
for (i = 0; i < ARRAY_LEN(load_results); i++) {
if (load_results[i].result == result) {
return load_results[i].name;
}
}
ast_log(LOG_WARNING, "Failed to find correct load result status. result %d\n", result);
return AST_MODULE_LOAD_UNKNOWN_STRING;
}
/*!
* \internal
* \brief Publish a \ref stasis message regarding the load result
*/
static void publish_load_message(const char *name, enum ast_module_load_result result)
{
const char *status;
status = loadresult2str(result);
publish_load_message_type("Load", name, status);
}
/*!
* \internal
* \brief Publish a \ref stasis message regarding the unload result
*/
static void publish_unload_message(const char *name, const char* status)
{
publish_load_message_type("Unload", name, status);
}
/*!
* \since 12
* \internal
* \brief Publish a \ref stasis message regarding the reload result
*/
static void publish_reload_message(const char *name, enum ast_module_reload_result result)
{
char res_buffer[8];
snprintf(res_buffer, sizeof(res_buffer), "%u", result);
publish_load_message_type("Reload", S_OR(name, "All"), res_buffer);
}
enum ast_module_reload_result ast_module_reload(const char *name)
{
struct ast_module *cur;
enum ast_module_reload_result res = AST_MODULE_RELOAD_NOT_FOUND;
size_t name_baselen = name ? resource_name_baselen(name) : 0;
/* If we aren't fully booted, we just pretend we reloaded but we queue this
up to run once we are booted up. */
if (!modules_loaded) {
queue_reload_request(name);
res = AST_MODULE_RELOAD_QUEUED;
goto module_reload_exit;
}
if (ast_mutex_trylock(&reloadlock)) {
ast_verb(3, "The previous reload command didn't finish yet\n");
res = AST_MODULE_RELOAD_IN_PROGRESS;
goto module_reload_exit;
}
ast_sd_notify("RELOADING=1");
ast_lastreloadtime = ast_tvnow();
if (ast_opt_lock_confdir) {
int try;
int lockres;
for (try = 1, lockres = AST_LOCK_TIMEOUT; try < 6 && (lockres == AST_LOCK_TIMEOUT); try++) {
lockres = ast_lock_path(ast_config_AST_CONFIG_DIR);
if (lockres == AST_LOCK_TIMEOUT) {
ast_log(LOG_WARNING, "Failed to grab lock on %s, try %d\n", ast_config_AST_CONFIG_DIR, try);
}
}
if (lockres != AST_LOCK_SUCCESS) {
ast_log(AST_LOG_WARNING, "Cannot grab lock on %s\n", ast_config_AST_CONFIG_DIR);
res = AST_MODULE_RELOAD_ERROR;
goto module_reload_done;
}
}
AST_DLLIST_LOCK(&module_list);
AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
const struct ast_module_info *info = cur->info;
if (name && resource_name_match(name, name_baselen, cur->resource)) {
continue;
}
if (!cur->flags.running || cur->flags.declined) {
if (res == AST_MODULE_RELOAD_NOT_FOUND) {
res = AST_MODULE_RELOAD_UNINITIALIZED;
}
if (!name) {
continue;
}
break;
}
if (!info->reload) { /* cannot be reloaded */
if (res == AST_MODULE_RELOAD_NOT_FOUND) {
res = AST_MODULE_RELOAD_NOT_IMPLEMENTED;
}
if (!name) {
continue;
}
break;
}
ast_verb(3, "Reloading module '%s' (%s)\n", cur->resource, info->description);
if (info->reload() == AST_MODULE_LOAD_SUCCESS) {
res = AST_MODULE_RELOAD_SUCCESS;
} else if (res == AST_MODULE_RELOAD_NOT_FOUND) {
res = AST_MODULE_RELOAD_ERROR;
}
if (name) {
break;
}
}
AST_DLLIST_UNLOCK(&module_list);
if (ast_opt_lock_confdir) {
ast_unlock_path(ast_config_AST_CONFIG_DIR);
}
module_reload_done:
ast_mutex_unlock(&reloadlock);
ast_sd_notify("READY=1");
module_reload_exit:
publish_reload_message(name, res);
return res;
}
static unsigned int inspect_module(const struct ast_module *mod)
{
if (!mod->info->description) {
module_load_error("Module '%s' does not provide a description.\n", mod->resource);
return 1;
}
if (!mod->info->key) {
module_load_error("Module '%s' does not provide a license key.\n", mod->resource);
return 1;
}
if (verify_key((unsigned char *) mod->info->key)) {
module_load_error("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)) {
module_load_error("Module '%s' was not compiled with the same compile-time options as this version of Asterisk.\n", mod->resource);
module_load_error("Module '%s' will not be initialized as it may cause instability.\n", mod->resource);
return 1;
}
return 0;
}
static enum ast_module_load_result start_resource(struct ast_module *mod)
{
char tmp[256];
enum ast_module_load_result res;
if (mod->flags.running) {
return AST_MODULE_LOAD_SUCCESS;
}
if (!mod->info->load) {
mod->flags.declined = 1;
return mod->flags.required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
}
if (module_deps_reference(mod, NULL)) {
struct module_vector missing;
int i;
AST_VECTOR_INIT(&missing, 0);
if (module_deps_missing_recursive(mod, &missing)) {
module_load_error("%s has one or more unknown dependencies.\n", mod->info->name);
}
for (i = 0; i < AST_VECTOR_SIZE(&missing); i++) {
module_load_error("%s loaded before dependency %s!\n", mod->info->name,
AST_VECTOR_GET(&missing, i)->info->name);
}
AST_VECTOR_FREE(&missing);
return AST_MODULE_LOAD_DECLINE;
}
if (!ast_fully_booted) {
ast_verb(4, "Loading %s.\n", mod->resource);
}
res = mod->info->load();
switch (res) {
case AST_MODULE_LOAD_SUCCESS:
if (!ast_fully_booted) {
ast_verb(5, "%s => (%s)\n", mod->resource, term_color(tmp, mod->info->description, COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
} else {
ast_verb(4, "Loaded %s => (%s)\n", mod->resource, mod->info->description);
}
mod->flags.running = 1;
if (mod->flags.builtin) {
/* Built-in modules cannot be unloaded. */
ast_module_shutdown_ref(mod);
}
ast_update_use_count();
break;
case AST_MODULE_LOAD_DECLINE:
mod->flags.declined = 1;
if (mod->flags.required) {
res = AST_MODULE_LOAD_FAILURE;
}
break;
case AST_MODULE_LOAD_FAILURE:
mod->flags.declined = 1;
break;
case AST_MODULE_LOAD_SKIP: /* modules should never return this value */
case AST_MODULE_LOAD_PRIORITY:
break;
}
/* Make sure the newly started module is at the end of the list */
AST_DLLIST_LOCK(&module_list);
AST_DLLIST_REMOVE(&module_list, mod, entry);
AST_DLLIST_INSERT_TAIL(&module_list, mod, entry);
AST_DLLIST_UNLOCK(&module_list);
return res;
}
/*! loads a resource based upon resource_name. If global_symbols_only is set
* only modules with global symbols will be loaded.
*
* If the module_vector is provided (not NULL) the module is found and added to the
* vector without running the module's load() function. By doing this, modules
* can be initialized later in order by priority and dependencies.
*
* If the module_vector is not provided, the module's load function will be executed
* immediately */
static enum ast_module_load_result load_resource(const char *resource_name, unsigned int suppress_logging,
struct module_vector *module_priorities, int required, int preload)
{
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 loaded and running.\n", resource_name);
return AST_MODULE_LOAD_DECLINE;
}
} else {
mod = load_dynamic_module(resource_name, suppress_logging);
if (!mod) {
return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
}
if (module_post_register(mod)) {
goto prestart_error;
}
}
mod->flags.required |= required;
mod->flags.preload |= preload;
if (inspect_module(mod)) {
goto prestart_error;
}
mod->flags.declined = 0;
if (module_priorities) {
if (AST_VECTOR_ADD_SORTED(module_priorities, mod, module_vector_cmp)) {
goto prestart_error;
}
res = AST_MODULE_LOAD_PRIORITY;
} else {
res = start_resource(mod);
}
if (ast_fully_booted && !ast_shutdown_final()) {
publish_load_message(resource_name, res);
}
return res;
prestart_error:
module_load_error("Module '%s' could not be loaded.\n", resource_name);
unload_dynamic_module(mod);
res = required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
if (ast_fully_booted && !ast_shutdown_final()) {
publish_load_message(resource_name, res);
}
return res;
}
enum ast_module_load_result ast_load_resource(const char *resource_name)
{
struct ast_module *mod;
enum ast_module_load_result res;
/* If we're trying to load a module that previously declined to load,
* transparently unload it first so we dlclose, then dlopen it afresh.
* Otherwise, we won't actually load a (potentially) updated module. */
mod = find_resource(resource_name, 0);
if (mod && mod->flags.declined) {
ast_debug(1, "Module %s previously declined to load, unloading it first before loading again\n", resource_name);
ast_unload_resource(resource_name, 0);
}
AST_DLLIST_LOCK(&module_list);
res = load_resource(resource_name, 0, NULL, 0, 0);
if (!res) {
ast_test_suite_event_notify("MODULE_LOAD", "Message: %s", resource_name);
}
AST_DLLIST_UNLOCK(&module_list);
return res;
}
struct load_order_entry {
char *resource;
int required;
int preload;
int builtin;
AST_LIST_ENTRY(load_order_entry) entry;
};
AST_LIST_HEAD_NOLOCK(load_order, load_order_entry);
static struct load_order_entry *add_to_load_order(const char *resource, struct load_order *load_order, int required, int preload, int builtin)
{
struct load_order_entry *order;
size_t resource_baselen = resource_name_baselen(resource);
AST_LIST_TRAVERSE(load_order, order, entry) {
if (!resource_name_match(resource, resource_baselen, order->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;
order->preload |= preload;
return order;
}
}
order = ast_calloc(1, sizeof(*order));
if (!order) {
return NULL;
}
order->resource = ast_strdup(resource);
if (!order->resource) {
ast_free(order);
return NULL;
}
order->required = required;
order->preload = preload;
order->builtin = builtin;
AST_LIST_INSERT_TAIL(load_order, order, entry);
return order;
}
AST_LIST_HEAD_NOLOCK(load_retries, load_order_entry);
static enum ast_module_load_result start_resource_attempt(struct ast_module *mod, int *count)
{
enum ast_module_load_result lres;
/* Try to grab required references. */
if (module_deps_reference(mod, NULL)) {
/* We're likely to retry so not an error. */
ast_debug(1, "Module %s is missing dependencies\n", mod->resource);
return AST_MODULE_LOAD_SKIP;
}
lres = start_resource(mod);
ast_debug(3, "START: %-46s[%d] %d\n",
mod->resource,
ast_test_flag(mod->info, AST_MODFLAG_LOAD_ORDER) ? mod->info->load_pri : AST_MODPRI_DEFAULT,
lres);
if (lres == AST_MODULE_LOAD_SUCCESS) {
(*count)++;
} else if (lres == AST_MODULE_LOAD_FAILURE) {
module_load_error("*** Failed to load %smodule %s\n",
mod->flags.required ? "required " : "",
mod->resource);
}
return lres;
}
static int resource_list_recursive_decline(struct module_vector *resources, struct ast_module *mod,
struct ast_str **printmissing)
{
struct module_vector missingdeps;
struct ast_vector_const_string localdeps;
int i = 0;
int res = -1;
mod->flags.declined = 1;
if (mod->flags.required) {
module_load_error("Required module %s declined to load.\n", ast_module_name(mod));
return -2;
}
module_load_error("%s declined to load.\n", ast_module_name(mod));
if (!*printmissing) {
*printmissing = ast_str_create(64);
if (!*printmissing) {
return -1;
}
} else {
ast_str_reset(*printmissing);
}
AST_VECTOR_INIT(&missingdeps, 0);
AST_VECTOR_INIT(&localdeps, 0);
/* Decline everything that depends on 'mod' from resources so we can
* print a concise list. */
while (res != -2 && i < AST_VECTOR_SIZE(resources)) {
struct ast_module *dep = AST_VECTOR_GET(resources, i);
i++;
AST_VECTOR_RESET(&missingdeps, AST_VECTOR_ELEM_CLEANUP_NOOP);
if (dep->flags.declined || module_deps_missing_recursive(dep, &missingdeps)) {
continue;
}
if (AST_VECTOR_GET_CMP(&missingdeps, mod, AST_VECTOR_ELEM_DEFAULT_CMP)) {
dep->flags.declined = 1;
if (dep->flags.required) {
module_load_error("Cannot load required module %s that depends on %s\n",
ast_module_name(dep), ast_module_name(mod));
res = -2;
} else {
AST_VECTOR_APPEND(&localdeps, ast_module_name(dep));
}
}
}
AST_VECTOR_FREE(&missingdeps);
if (res != -2 && AST_VECTOR_SIZE(&localdeps)) {
AST_VECTOR_CALLBACK_VOID(&localdeps, STR_APPEND_TEXT, printmissing);
module_load_error("Declined modules which depend on %s: %s\n",
ast_module_name(mod), ast_str_buffer(*printmissing));
}
AST_VECTOR_FREE(&localdeps);
return res;
}
static int start_resource_list(struct module_vector *resources, int *mod_count)
{
struct module_vector missingdeps;
int res = 0;
struct ast_str *printmissing = NULL;
AST_VECTOR_INIT(&missingdeps, 0);
while (res != -2 && AST_VECTOR_SIZE(resources)) {
struct ast_module *mod = AST_VECTOR_REMOVE(resources, 0, 1);
enum ast_module_load_result lres;
if (mod->flags.declined) {
ast_debug(1, "%s is already declined, skipping\n", ast_module_name(mod));
continue;
}
retry_load:
lres = start_resource_attempt(mod, mod_count);
if (lres == AST_MODULE_LOAD_SUCCESS) {
/* No missing dependencies, successful. */
continue;
}
if (lres == AST_MODULE_LOAD_FAILURE) {
res = -2;
break;
}
if (lres == AST_MODULE_LOAD_DECLINE) {
res = resource_list_recursive_decline(resources, mod, &printmissing);
continue;
}
if (module_deps_missing_recursive(mod, &missingdeps)) {
AST_VECTOR_RESET(&missingdeps, AST_VECTOR_ELEM_CLEANUP_NOOP);
module_load_error("Failed to resolve dependencies for %s\n", ast_module_name(mod));
res = resource_list_recursive_decline(resources, mod, &printmissing);
continue;
}
if (!AST_VECTOR_SIZE(&missingdeps)) {
module_load_error("%s load function returned an invalid result. "
"This is a bug in the module.\n", ast_module_name(mod));
/* Dependencies were met but the module failed to start and the result
* code was not AST_MODULE_LOAD_FAILURE or AST_MODULE_LOAD_DECLINE. */
res = resource_list_recursive_decline(resources, mod, &printmissing);
continue;
}
ast_debug(1, "%s has %d dependencies\n",
ast_module_name(mod), (int)AST_VECTOR_SIZE(&missingdeps));
while (AST_VECTOR_SIZE(&missingdeps)) {
int didwork = 0;
int i = 0;
while (i < AST_VECTOR_SIZE(&missingdeps)) {
struct ast_module *dep = AST_VECTOR_GET(&missingdeps, i);
if (dep->flags.declined) {
ast_debug(1, "%s tried to start %s but it's already declined\n",
ast_module_name(mod), ast_module_name(dep));
i++;
continue;
}
ast_debug(1, "%s trying to start %s\n", ast_module_name(mod), ast_module_name(dep));
lres = start_resource_attempt(dep, mod_count);
if (lres == AST_MODULE_LOAD_SUCCESS) {
ast_debug(1, "%s started %s\n", ast_module_name(mod), ast_module_name(dep));
AST_VECTOR_REMOVE(&missingdeps, i, 1);
AST_VECTOR_REMOVE_CMP_ORDERED(resources, dep,
AST_VECTOR_ELEM_DEFAULT_CMP, AST_VECTOR_ELEM_CLEANUP_NOOP);
didwork++;
continue;
}
if (lres == AST_MODULE_LOAD_FAILURE) {
module_load_error("Failed to load %s.\n", ast_module_name(dep));
res = -2;
goto exitpoint;
}
ast_debug(1, "%s failed to start %s\n", ast_module_name(mod), ast_module_name(dep));
i++;
}
if (!didwork) {
break;
}
}
if (AST_VECTOR_SIZE(&missingdeps)) {
if (!printmissing) {
printmissing = ast_str_create(64);
} else {
ast_str_reset(printmissing);
}
if (printmissing) {
struct ast_vector_const_string localdeps;
AST_VECTOR_INIT(&localdeps, 0);
module_deps_reference(mod, &localdeps);
AST_VECTOR_CALLBACK_VOID(&localdeps, STR_APPEND_TEXT, &printmissing);
AST_VECTOR_FREE(&localdeps);
}
module_load_error("Failed to load %s due to dependencies: %s.\n",
ast_module_name(mod),
printmissing ? ast_str_buffer(printmissing) : "allocation failure creating list");
res = resource_list_recursive_decline(resources, mod, &printmissing);
AST_VECTOR_RESET(&missingdeps, AST_VECTOR_ELEM_CLEANUP_NOOP);
continue;
}
/* If we're here it means that we started with missingdeps and they're all loaded
* now. It's impossible to reach this point a second time for the same module. */
goto retry_load;
}
exitpoint:
ast_free(printmissing);
AST_VECTOR_FREE(&missingdeps);
return res;
}
/*! loads modules in order by load_pri, updates mod_count
\return -1 on failure to load module, -2 on failure to load required module, otherwise 0
*/
static int load_resource_list(struct load_order *load_order, int *mod_count)
{
struct module_vector module_priorities;
struct load_order_entry *order;
int attempt = 0;
int count = 0;
int res = 0;
int didwork;
int lasttry = 0;
if (AST_VECTOR_INIT(&module_priorities, 500)) {
ast_log(LOG_ERROR, "Failed to initialize module loader.\n");
return -1;
}
while (res != -2) {
didwork = 0;
AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
enum ast_module_load_result lres;
/* Suppress log messages unless this is the last pass */
lres = load_resource(order->resource, !lasttry, &module_priorities, order->required, order->preload);
ast_debug(3, "PASS %d: %-46s %d\n", attempt, order->resource, lres);
switch (lres) {
case AST_MODULE_LOAD_SUCCESS:
case AST_MODULE_LOAD_SKIP:
/* We're supplying module_priorities so SUCCESS isn't possible but we
* still have to test for it. SKIP is only used when we try to start a
* module that is missing dependencies. */
break;
case AST_MODULE_LOAD_DECLINE:
res = -1;
break;
case AST_MODULE_LOAD_FAILURE:
/* LOAD_FAILURE only happens for required modules */
if (lasttry) {
/* This run is just to print errors. */
module_load_error("*** Failed to load module %s - Required\n", order->resource);
fprintf(stderr, "*** Failed to load module %s - Required\n", order->resource);
res = -2;
}
break;
case AST_MODULE_LOAD_PRIORITY:
/* load_resource worked and the module was added to module_priorities */
AST_LIST_REMOVE_CURRENT(entry);
ast_free(order->resource);
ast_free(order);
didwork = 1;
break;
}
}
AST_LIST_TRAVERSE_SAFE_END;
if (!didwork) {
if (lasttry) {
break;
}
/* We know the next try is going to fail, it's only being performed
* so we can print errors. */
lasttry = 1;
}
attempt++;
}
if (res != -2) {
res = start_resource_list(&module_priorities, &count);
}
if (mod_count) {
*mod_count += count;
}
AST_VECTOR_FREE(&module_priorities);
return res;
}
static int loader_builtin_init(struct load_order *load_order)
{
struct ast_module *mod;
/*
* All built-in modules have registered the first time, now it's time to complete
* the registration and add them to the priority list.
*/
loader_ready = 1;
while ((resource_being_loaded = AST_DLLIST_REMOVE_HEAD(&builtin_module_list, entry))) {
/* ast_module_register doesn't finish when first run by built-in modules. */
ast_module_register(resource_being_loaded->info);
}
/* Add all built-in modules to the load order. */
AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
if (!mod->flags.builtin) {
continue;
}
/* Parse dependencies from mod->info. */
if (module_post_register(mod)) {
return -1;
}
/* Built-in modules are not preloaded, most have an early load priority. */
if (!add_to_load_order(mod->resource, load_order, 0, 0, 1)) {
return -1;
}
}
return 0;
}
static int loader_config_init(struct load_order *load_order)
{
int res = -1;
struct load_order_entry *order;
struct ast_config *cfg;
struct ast_variable *v;
struct ast_flags config_flags = { 0 };
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, "'%s' invalid or missing.\n", AST_MODULE_CONFIG);
return -1;
}
/* first, find all the modules we have been explicitly requested to load */
for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
int required;
int preload = 0;
if (!strncasecmp(v->name, "preload", strlen("preload"))) {
preload = 1;
if (!strcasecmp(v->name, "preload")) {
required = 0;
} else if (!strcasecmp(v->name, "preload-require")) {
required = 1;
} else {
ast_log(LOG_ERROR, "Unknown configuration option '%s'", v->name);
goto done;
}
} else if (!strcasecmp(v->name, "load")) {
required = 0;
} else if (!strcasecmp(v->name, "require")) {
required = 1;
} else if (!strcasecmp(v->name, "noload") || !strcasecmp(v->name, "autoload")) {
continue;
} else {
ast_log(LOG_ERROR, "Unknown configuration option '%s'", v->name);
goto done;
}
if (required) {
ast_debug(2, "Adding module to required list: %s (%s)\n", v->value, v->name);
}
if (!add_to_load_order(v->value, load_order, required, preload, 0)) {
goto done;
}
}
/* check if 'autoload' is on */
if (ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
/* if we are allowed to load dynamic modules, scan the directory for
for all available modules and add them as well */
DIR *dir = opendir(ast_config_AST_MODULE_DIR);
struct dirent *dirent;
if (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;
if (!add_to_load_order(dirent->d_name, load_order, 0, 0, 0)) {
closedir(dir);
goto done;
}
}
closedir(dir);
} else {
ast_log(LOG_ERROR, "Unable to open modules directory '%s'.\n", ast_config_AST_MODULE_DIR);
goto done;
}
}
/* 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) {
size_t baselen;
if (strcasecmp(v->name, "noload")) {
continue;
}
baselen = resource_name_baselen(v->value);
AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
if (!resource_name_match(v->value, baselen, order->resource)) {
if (order->builtin) {
ast_log(LOG_ERROR, "%s is a built-in module, you cannot specify 'noload'.\n", v->value);
goto done;
}
if (order->required) {
ast_log(LOG_ERROR, "%s is configured with '%s' and 'noload', this is impossible.\n",
v->value, order->preload ? "preload-require" : "require");
goto done;
}
AST_LIST_REMOVE_CURRENT(entry);
ast_free(order->resource);
ast_free(order);
}
}
AST_LIST_TRAVERSE_SAFE_END;
}
res = 0;
done:
ast_config_destroy(cfg);
return res;
}
int load_modules(void)
{
struct load_order_entry *order;
unsigned int load_count;
struct load_order load_order;
int res = 0;
int modulecount = 0;
int i;
struct ast_module *cur;
#ifdef AST_XML_DOCS
struct ast_str *warning_msg;
char deprecated_in[33];
char removed_in[33];
char replacement[129];
#endif
struct timeval start_time = ast_tvnow();
struct timeval end_time;
int64_t usElapsed;
ast_verb(1, "Asterisk Dynamic Loader Starting:\n");
#if defined(HAVE_PERMANENT_DLOPEN)
info_list = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL,
info_list_obj_cmp_fn); /* must not be cleaned at shutdown */
if (!info_list) {
fprintf(stderr, "Module info list allocation failure.\n");
return 1;
}
#endif
AST_LIST_HEAD_INIT_NOLOCK(&load_order);
AST_DLLIST_LOCK(&module_list);
AST_VECTOR_INIT(&startup_errors, 0);
startup_error_builder = ast_str_create(64);
res = loader_builtin_init(&load_order);
if (res) {
goto done;
}
res = loader_config_init(&load_order);
if (res) {
goto done;
}
load_count = 0;
AST_LIST_TRAVERSE(&load_order, order, entry)
load_count++;
if (load_count)
ast_log(LOG_NOTICE, "%u modules will be loaded.\n", load_count);
res = load_resource_list(&load_order, &modulecount);
if (res == -1) {
ast_log(LOG_WARNING, "Some non-required modules failed to load.\n");
res = 0;
}
done:
while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
ast_free(order->resource);
ast_free(order);
}
#ifdef AST_XML_DOCS
warning_msg = ast_str_create(512);
#endif
AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
#ifdef AST_XML_DOCS
char *mod_name = NULL;
struct ast_xml_xpath_results *results;
#endif
if (!cur->flags.running || cur->flags.declined) {
continue;
}
#ifdef AST_XML_DOCS
mod_name = get_name_from_resource(cur->resource);
if (!warning_msg || !mod_name) {
/* If we can't allocate memory, we have bigger issues */
ast_free(mod_name);
continue;
}
/* Clear out the previous values */
deprecated_in[0] = removed_in[0] = replacement[0] = 0;
results = ast_xmldoc_query("/docs/module[@name='%s']", mod_name);
if (results) {
struct ast_xml_node *deprecated_node, *removed_node, *replacement_node;
struct ast_xml_node *metadata_nodes = ast_xml_node_get_children(ast_xml_xpath_get_first_result(results));
deprecated_node = ast_xml_find_element(metadata_nodes, "deprecated_in", NULL, NULL);
if (deprecated_node) {
const char *result_tmp = ast_xml_get_text(deprecated_node);
if (!ast_strlen_zero(result_tmp)) {
ast_copy_string(deprecated_in, result_tmp, sizeof(deprecated_in));
}
}
removed_node = ast_xml_find_element(metadata_nodes, "removed_in", NULL, NULL);
if (removed_node) {
const char *result_tmp = ast_xml_get_text(removed_node);
if (!ast_strlen_zero(result_tmp)) {
ast_copy_string(removed_in, result_tmp, sizeof(removed_in));
}
}
replacement_node = ast_xml_find_element(metadata_nodes, "replacement", NULL, NULL);
if (replacement_node) {
const char *result_tmp = ast_xml_get_text(replacement_node);
if (!ast_strlen_zero(result_tmp)) {
ast_copy_string(replacement, result_tmp, sizeof(replacement));
}
}
ast_xml_xpath_results_free(results);
}
ast_str_reset(warning_msg);
if (cur->info->support_level == AST_MODULE_SUPPORT_DEPRECATED || !ast_strlen_zero(deprecated_in)
|| !ast_strlen_zero(removed_in) || !ast_strlen_zero(replacement)) {
int already_butted = 0;
ast_str_append(&warning_msg, -1, "Module '%s' has been loaded", mod_name);
if (!ast_strlen_zero(deprecated_in)) {
ast_str_append(&warning_msg, -1, " but %s deprecated in Asterisk version %s",
cur->info->support_level == AST_MODULE_SUPPORT_DEPRECATED ? "was" : "will be", deprecated_in);
already_butted = 1;
}
if (!ast_strlen_zero(removed_in)) {
ast_str_append(&warning_msg, -1, " %s will be removed in Asterisk version %s", already_butted ? "and" : "but", removed_in);
} else {
ast_str_append(&warning_msg, -1, " %s may be removed in a future release", already_butted ? "and" : "but");
}
ast_str_append(&warning_msg, -1, ".");
if (!ast_strlen_zero(replacement)) {
ast_str_append(&warning_msg, -1, " Its replacement is '%s'.", replacement);
}
}
if (ast_str_strlen(warning_msg)) {
ast_log(LOG_WARNING, "%s\n", ast_str_buffer(warning_msg));
}
ast_free(mod_name);
#else
if (cur->info->support_level == AST_MODULE_SUPPORT_DEPRECATED) {
ast_log(LOG_WARNING, "The deprecated module '%s' has been loaded and is running, it may be removed in a future version\n", cur->resource);
}
#endif
}
#ifdef AST_XML_DOCS
ast_free(warning_msg);
#endif
AST_DLLIST_UNLOCK(&module_list);
for (i = 0; i < AST_VECTOR_SIZE(&startup_errors); i++) {
char *str = AST_VECTOR_GET(&startup_errors, i);
ast_log(LOG_ERROR, "%s", str);
ast_free(str);
}
AST_VECTOR_FREE(&startup_errors);
ast_free(startup_error_builder);
startup_error_builder = NULL;
end_time = ast_tvnow();
usElapsed = ast_tvdiff_us(end_time, start_time);
#ifdef AST_XML_DOCS
ast_debug(1, "Loader time with AST_XML_DOCS: %" PRId64 ".%06" PRId64 "\n", usElapsed / 1000000, usElapsed % 1000000);
#else
ast_debug(1, "Loader time without AST_XML_DOCS: %" PRId64 ".%06" PRId64 "\n", usElapsed / 1000000, usElapsed % 1000000);
#endif
return res;
}
void ast_update_use_count(void)
{
/* 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);
}
/*!
* \internal
* \brief Build an alpha sorted list of modules.
*
* \param alpha_module_list Pointer to uninitialized module_vector.
*
* This function always initializes alpha_module_list.
*
* \pre module_list must be locked.
*/
static int alpha_module_list_create(struct module_vector *alpha_module_list)
{
struct ast_module *cur;
if (AST_VECTOR_INIT(alpha_module_list, 32)) {
return -1;
}
AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
if (AST_VECTOR_ADD_SORTED(alpha_module_list, cur, module_vector_strcasecmp)) {
return -1;
}
}
return 0;
}
int ast_update_module_list(int (*modentry)(const char *module, const char *description,
int usecnt, const char *status, const char *like,
enum ast_module_support_level support_level),
const char *like)
{
int total_mod_loaded = 0;
struct module_vector alpha_module_list;
AST_DLLIST_LOCK(&module_list);
if (!alpha_module_list_create(&alpha_module_list)) {
int idx;
for (idx = 0; idx < AST_VECTOR_SIZE(&alpha_module_list); idx++) {
struct ast_module *cur = AST_VECTOR_GET(&alpha_module_list, idx);
total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount,
cur->flags.running ? "Running" : "Not Running", like, cur->info->support_level);
}
}
AST_DLLIST_UNLOCK(&module_list);
AST_VECTOR_FREE(&alpha_module_list);
return total_mod_loaded;
}
int ast_update_module_list_data(int (*modentry)(const char *module, const char *description,
int usecnt, const char *status, const char *like,
enum ast_module_support_level support_level,
void *data),
const char *like, void *data)
{
int total_mod_loaded = 0;
struct module_vector alpha_module_list;
AST_DLLIST_LOCK(&module_list);
if (!alpha_module_list_create(&alpha_module_list)) {
int idx;
for (idx = 0; idx < AST_VECTOR_SIZE(&alpha_module_list); idx++) {
struct ast_module *cur = AST_VECTOR_GET(&alpha_module_list, idx);
total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount,
cur->flags.running? "Running" : "Not Running", like, cur->info->support_level, data);
}
}
AST_DLLIST_UNLOCK(&module_list);
AST_VECTOR_FREE(&alpha_module_list);
return total_mod_loaded;
}
int ast_update_module_list_condition(int (*modentry)(const char *module, const char *description,
int usecnt, const char *status,
const char *like,
enum ast_module_support_level support_level,
void *data, const char *condition),
const char *like, void *data, const char *condition)
{
int conditions_met = 0;
struct module_vector alpha_module_list;
AST_DLLIST_LOCK(&module_list);
if (!alpha_module_list_create(&alpha_module_list)) {
int idx;
for (idx = 0; idx < AST_VECTOR_SIZE(&alpha_module_list); idx++) {
struct ast_module *cur = AST_VECTOR_GET(&alpha_module_list, idx);
conditions_met += modentry(cur->resource, cur->info->description, cur->usecount,
cur->flags.running? "Running" : "Not Running", like, cur->info->support_level, data,
condition);
}
}
AST_DLLIST_UNLOCK(&module_list);
AST_VECTOR_FREE(&alpha_module_list);
return conditions_met;
}
/*! \brief Check if module exists */
int ast_module_check(const char *name)
{
struct ast_module *cur;
if (ast_strlen_zero(name))
return 0; /* FALSE */
cur = find_resource(name, 1);
return (cur != NULL);
}
int ast_loader_register(int (*v)(void))
{
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 (*v)(void))
{
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;
}
struct ast_module *__ast_module_ref(struct ast_module *mod, const char *file, int line, const char *func)
{
if (!mod) {
return NULL;
}
if (mod->ref_debug) {
__ao2_ref(mod->ref_debug, +1, "", file, line, func);
}
ast_atomic_fetchadd_int(&mod->usecount, +1);
ast_update_use_count();
return mod;
}
struct ast_module *__ast_module_running_ref(struct ast_module *mod,
const char *file, int line, const char *func)
{
if (!mod || !mod->flags.running) {
return NULL;
}
return __ast_module_ref(mod, file, line, func);
}
void __ast_module_shutdown_ref(struct ast_module *mod, const char *file, int line, const char *func)
{
if (!mod || mod->flags.keepuntilshutdown) {
return;
}
__ast_module_ref(mod, file, line, func);
mod->flags.keepuntilshutdown = 1;
}
void __ast_module_unref(struct ast_module *mod, const char *file, int line, const char *func)
{
if (!mod) {
return;
}
if (mod->ref_debug) {
__ao2_ref(mod->ref_debug, -1, "", file, line, func);
}
ast_atomic_fetchadd_int(&mod->usecount, -1);
ast_update_use_count();
}
const char *support_level_map [] = {
[AST_MODULE_SUPPORT_UNKNOWN] = "unknown",
[AST_MODULE_SUPPORT_CORE] = "core",
[AST_MODULE_SUPPORT_EXTENDED] = "extended",
[AST_MODULE_SUPPORT_DEPRECATED] = "deprecated",
};
const char *ast_module_support_level_to_string(enum ast_module_support_level support_level)
{
return support_level_map[support_level];
}