Merge "loader: support for permanent dlopen()"
[asterisk/asterisk.git] / main / loader.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  * Kevin P. Fleming <kpfleming@digium.com>
8  * Luigi Rizzo <rizzo@icir.org>
9  *
10  * See http://www.asterisk.org for more information about
11  * the Asterisk project. Please do not directly contact
12  * any of the maintainers of this project for assistance;
13  * the project provides a web site, mailing lists and IRC
14  * channels for your use.
15  *
16  * This program is free software, distributed under the terms of
17  * the GNU General Public License Version 2. See the LICENSE file
18  * at the top of the source tree.
19  */
20
21 /*! \file
22  *
23  * \brief Module Loader
24  * \author Mark Spencer <markster@digium.com>
25  * \author Kevin P. Fleming <kpfleming@digium.com>
26  * \author Luigi Rizzo <rizzo@icir.org>
27  * - See ModMngMnt
28  */
29
30 /*** MODULEINFO
31         <support_level>core</support_level>
32  ***/
33
34 #include "asterisk.h"
35
36 #include "asterisk/_private.h"
37 #include "asterisk/paths.h"     /* use ast_config_AST_MODULE_DIR */
38 #include <dirent.h>
39
40 #include "asterisk/dlinkedlists.h"
41 #include "asterisk/module.h"
42 #include "asterisk/config.h"
43 #include "asterisk/channel.h"
44 #include "asterisk/term.h"
45 #include "asterisk/manager.h"
46 #include "asterisk/io.h"
47 #include "asterisk/lock.h"
48 #include "asterisk/vector.h"
49 #include "asterisk/app.h"
50 #include "asterisk/test.h"
51 #include "asterisk/cli.h"
52
53 #include <dlfcn.h>
54
55 #include "asterisk/md5.h"
56 #include "asterisk/utils.h"
57
58 /*** DOCUMENTATION
59         <managerEvent language="en_US" name="Reload">
60                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
61                         <synopsis>Raised when a module has been reloaded in Asterisk.</synopsis>
62                         <syntax>
63                                 <parameter name="Module">
64                                         <para>The name of the module that was reloaded, or
65                                         <literal>All</literal> if all modules were reloaded</para>
66                                 </parameter>
67                                 <parameter name="Status">
68                                         <para>The numeric status code denoting the success or failure
69                                         of the reload request.</para>
70                                         <enumlist>
71                                                 <enum name="0"><para>Success</para></enum>
72                                                 <enum name="1"><para>Request queued</para></enum>
73                                                 <enum name="2"><para>Module not found</para></enum>
74                                                 <enum name="3"><para>Error</para></enum>
75                                                 <enum name="4"><para>Reload already in progress</para></enum>
76                                                 <enum name="5"><para>Module uninitialized</para></enum>
77                                                 <enum name="6"><para>Reload not supported</para></enum>
78                                         </enumlist>
79                                 </parameter>
80                         </syntax>
81                 </managerEventInstance>
82         </managerEvent>
83         <managerEvent language="en_US" name="Load">
84                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
85                         <synopsis>Raised when a module has been loaded in Asterisk.</synopsis>
86                         <syntax>
87                                 <parameter name="Module">
88                                         <para>The name of the module that was loaded</para>
89                                 </parameter>
90                                 <parameter name="Status">
91                                         <para>The result of the load request.</para>
92                                         <enumlist>
93                                                 <enum name="Failure"><para>Module could not be loaded properly</para></enum>
94                                                 <enum name="Success"><para>Module loaded and configured</para></enum>
95                                                 <enum name="Decline"><para>Module is not configured</para></enum>
96                                         </enumlist>
97                                 </parameter>
98                         </syntax>
99                 </managerEventInstance>
100         </managerEvent>
101         <managerEvent language="en_US" name="Unload">
102                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
103                         <synopsis>Raised when a module has been unloaded in Asterisk.</synopsis>
104                         <syntax>
105                                 <parameter name="Module">
106                                         <para>The name of the module that was unloaded</para>
107                                 </parameter>
108                                 <parameter name="Status">
109                                         <para>The result of the unload request.</para>
110                                         <enumlist>
111                                                 <enum name="Success"><para>Module unloaded successfully</para></enum>
112                                         </enumlist>
113                                 </parameter>
114                         </syntax>
115                 </managerEventInstance>
116         </managerEvent>
117  ***/
118
119 #ifndef RTLD_NOW
120 #define RTLD_NOW 0
121 #endif
122
123 #ifndef RTLD_LOCAL
124 #define RTLD_LOCAL 0
125 #endif
126
127 struct ast_module_user {
128         struct ast_channel *chan;
129         AST_LIST_ENTRY(ast_module_user) entry;
130 };
131
132 AST_DLLIST_HEAD(module_user_list, ast_module_user);
133
134 static const unsigned char expected_key[] =
135 { 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3,
136   0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 };
137
138 static char buildopt_sum[33] = AST_BUILDOPT_SUM;
139
140 AST_VECTOR(module_vector, struct ast_module *);
141
142 /*! Used with AST_VECTOR_CALLBACK_VOID to create a
143  * comma separated list of module names for error messages. */
144 #define STR_APPEND_TEXT(txt, str) \
145         ast_str_append(str, 0, "%s%s", \
146                 ast_str_strlen(*(str)) > 0 ? ", " : "", \
147                 txt)
148
149 /* Built-in module registrations need special handling at startup */
150 static unsigned int loader_ready;
151
152 /*! String container for deferring output of startup errors. */
153 static struct ast_vector_string startup_errors;
154 static struct ast_str *startup_error_builder;
155
156 #if defined(HAVE_PERMANENT_DLOPEN)
157 #define FIRST_DLOPEN 999
158
159 struct ao2_container *info_list = NULL;
160
161 struct info_list_obj {
162         const struct ast_module_info *info;
163         int dlopened;
164         char name[0];
165 };
166
167 static struct info_list_obj *info_list_obj_alloc(const char *name,
168         const struct ast_module_info *info)
169 {
170         struct info_list_obj *new_entry;
171
172         new_entry = ao2_alloc(sizeof(*new_entry) + strlen(name) + 1, NULL);
173
174         if (!new_entry) {
175                 return NULL;
176         }
177
178         strcpy(new_entry->name, name); /* SAFE */
179         new_entry->info = info;
180         new_entry->dlopened = FIRST_DLOPEN;
181
182         return new_entry;
183 }
184
185 AO2_STRING_FIELD_CMP_FN(info_list_obj, name)
186
187 static char *get_name_from_resource(const char *resource)
188 {
189         int len;
190         const char *last_three;
191         char *mod_name;
192
193         if (!resource) {
194                 return NULL;
195         }
196
197         len = strlen(resource);
198         if (len > 3) {
199                 last_three = &resource[len-3];
200                 if (!strcasecmp(last_three, ".so")) {
201                         mod_name = ast_calloc(1, len - 2);
202                         if (mod_name) {
203                                 ast_copy_string(mod_name, resource, len - 2);
204                                 return mod_name;
205                         } else {
206                                 /* Unable to allocate memory. */
207                                 return NULL;
208                         }
209                 }
210         }
211
212         /* Resource is the name - happens when manually unloading a module. */
213         mod_name = ast_calloc(1, len + 1);
214         if (mod_name) {
215                 ast_copy_string(mod_name, resource, len + 1);
216                 return mod_name;
217         }
218
219         /* Unable to allocate memory. */
220         return NULL;
221 }
222
223 static void manual_mod_reg(const void *lib, const char *resource)
224 {
225         struct info_list_obj *obj_tmp;
226         char *mod_name;
227
228         if (lib) {
229                 mod_name = get_name_from_resource(resource);
230                 if (mod_name) {
231                         obj_tmp = ao2_find(info_list, mod_name, OBJ_SEARCH_KEY);
232                         if (obj_tmp) {
233                                 if (obj_tmp->dlopened == FIRST_DLOPEN) {
234                                         obj_tmp->dlopened = 1;
235                                 } else {
236                                         ast_module_register(obj_tmp->info);
237                                 }
238                                 ao2_ref(obj_tmp, -1);
239                         }
240                         ast_free(mod_name);
241                 }
242         }
243 }
244
245 static void manual_mod_unreg(const char *resource)
246 {
247         struct info_list_obj *obj_tmp;
248         char *mod_name;
249
250         /* When Asterisk shuts down the destructor is called automatically. */
251         if (ast_shutdown_final()) {
252                 return;
253         }
254
255         mod_name = get_name_from_resource(resource);
256         if (mod_name) {
257                 obj_tmp = ao2_find(info_list, mod_name, OBJ_SEARCH_KEY);
258                 if (obj_tmp) {
259                         ast_module_unregister(obj_tmp->info);
260                         ao2_ref(obj_tmp, -1);
261                 }
262                 ast_free(mod_name);
263         }
264 }
265 #endif
266
267 static __attribute__((format(printf, 1, 2))) void module_load_error(const char *fmt, ...)
268 {
269         char *copy = NULL;
270         va_list ap;
271
272         va_start(ap, fmt);
273         if (startup_error_builder) {
274                 ast_str_set_va(&startup_error_builder, 0, fmt, ap);
275                 copy = ast_strdup(ast_str_buffer(startup_error_builder));
276                 if (!copy || AST_VECTOR_APPEND(&startup_errors, copy)) {
277                         ast_log(LOG_ERROR, "%s", ast_str_buffer(startup_error_builder));
278                         ast_free(copy);
279                 }
280         } else {
281                 ast_log_ap(LOG_ERROR, fmt, ap);
282         }
283         va_end(ap);
284 }
285
286 /*!
287  * \brief Internal flag to indicate all modules have been initially loaded.
288  */
289 static int modules_loaded;
290
291 struct ast_module {
292         const struct ast_module_info *info;
293         /*! Used to get module references into refs log */
294         void *ref_debug;
295         /*! The shared lib. */
296         void *lib;
297         /*! Number of 'users' and other references currently holding the module. */
298         int usecount;
299         /*! List of users holding the module. */
300         struct module_user_list users;
301
302         /*! List of required module names. */
303         struct ast_vector_string requires;
304         /*! List of optional api modules. */
305         struct ast_vector_string optional_modules;
306         /*! List of modules this enhances. */
307         struct ast_vector_string enhances;
308
309         /*!
310          * \brief Vector holding pointers to modules we have a reference to.
311          *
312          * When one module requires another, the required module gets added
313          * to this list with a reference.
314          */
315         struct module_vector reffed_deps;
316         struct {
317                 /*! The module running and ready to accept requests. */
318                 unsigned int running:1;
319                 /*! The module has declined to start. */
320                 unsigned int declined:1;
321                 /*! This module is being held open until it's time to shutdown. */
322                 unsigned int keepuntilshutdown:1;
323                 /*! The module is built-in. */
324                 unsigned int builtin:1;
325                 /*! The admin has declared this module is required. */
326                 unsigned int required:1;
327                 /*! This module is marked for preload. */
328                 unsigned int preload:1;
329         } flags;
330         AST_DLLIST_ENTRY(ast_module) entry;
331         char resource[0];
332 };
333
334 static AST_DLLIST_HEAD_STATIC(module_list, ast_module);
335
336
337 struct load_results_map {
338         int result;
339         const char *name;
340 };
341
342 static const struct load_results_map load_results[] = {
343         { AST_MODULE_LOAD_SUCCESS, "Success" },
344         { AST_MODULE_LOAD_DECLINE, "Decline" },
345         { AST_MODULE_LOAD_SKIP, "Skip" },
346         { AST_MODULE_LOAD_PRIORITY, "Priority" },
347         { AST_MODULE_LOAD_FAILURE, "Failure" },
348 };
349 #define AST_MODULE_LOAD_UNKNOWN_STRING          "Unknown"               /* Status string for unknown load status */
350
351 static void publish_load_message_type(const char* type, const char *name, const char *status);
352 static void publish_reload_message(const char *name, enum ast_module_reload_result result);
353 static void publish_load_message(const char *name, enum ast_module_load_result result);
354 static void publish_unload_message(const char *name, const char* status);
355
356
357 /*
358  * module_list is cleared by its constructor possibly after
359  * we start accumulating built-in modules, so we need to
360  * use another list (without the lock) to accumulate them.
361  */
362 static struct module_list builtin_module_list;
363
364 static int module_vector_strcasecmp(struct ast_module *a, struct ast_module *b)
365 {
366         return strcasecmp(a->resource, b->resource);
367 }
368
369 static int module_vector_cmp(struct ast_module *a, struct ast_module *b)
370 {
371         int preload_diff = (int)b->flags.preload - (int)a->flags.preload;
372         /* if load_pri is not set, default is 128.  Lower is better */
373         int a_pri = ast_test_flag(a->info, AST_MODFLAG_LOAD_ORDER)
374                 ? a->info->load_pri : AST_MODPRI_DEFAULT;
375         int b_pri = ast_test_flag(b->info, AST_MODFLAG_LOAD_ORDER)
376                 ? b->info->load_pri : AST_MODPRI_DEFAULT;
377
378         if (preload_diff) {
379                 /* -1 preload a but not b */
380                 /*  0 preload both or neither */
381                 /*  1 preload b but not a */
382                 return preload_diff;
383         }
384
385         /*
386          * Returns comparison values for a vector sorted by priority.
387          * <0 a_pri < b_pri
388          * =0 a_pri == b_pri
389          * >0 a_pri > b_pri
390          */
391         return a_pri - b_pri;
392 }
393
394 static struct ast_module *find_resource(const char *resource, int do_lock);
395
396 /*!
397  * \internal
398  * \brief Add a reference from mod to dep.
399  *
400  * \param mod Owner of the new reference.
401  * \param dep Module to reference
402  * \param missing Vector to store name of \a dep if it is not running.
403  *
404  * This function returns failure if \a dep is not running and \a missing
405  * is NULL.  If \a missing is not NULL errors will only be returned for
406  * allocation failures.
407  *
408  * \retval 0 Success
409  * \retval -1 Failure
410  *
411  * \note Adding a second reference to the same dep will return success
412  *       without doing anything.
413  */
414 static int module_reffed_deps_add(struct ast_module *mod, struct ast_module *dep,
415         struct ast_vector_const_string *missing)
416 {
417         if (!dep->flags.running) {
418                 return !missing ? -1 : AST_VECTOR_APPEND(missing, dep->info->name);
419         }
420
421         if (AST_VECTOR_GET_CMP(&mod->reffed_deps, dep, AST_VECTOR_ELEM_DEFAULT_CMP)) {
422                 /* Skip duplicate. */
423                 return 0;
424         }
425
426         if (AST_VECTOR_APPEND(&mod->reffed_deps, dep)) {
427                 return -1;
428         }
429
430         ast_module_ref(dep);
431
432         return 0;
433 }
434
435 /*!
436  * \internal
437  * \brief Add references for modules that enhance a dependency.
438  *
439  * \param mod Owner of the new references.
440  * \param dep Module to check for enhancers.
441  * \param missing Vector to store name of any enhancer that is not running or declined.
442  *
443  * \retval 0 Success
444  * \retval -1 Failure
445  */
446 static int module_reffed_deps_add_dep_enhancers(struct ast_module *mod,
447         struct ast_module *dep, struct ast_vector_const_string *missing)
448 {
449         struct ast_module *cur;
450
451         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
452                 if (cur->flags.declined) {
453                         continue;
454                 }
455
456                 if (!AST_VECTOR_GET_CMP(&cur->enhances, dep->info->name, !strcasecmp)) {
457                         /* dep is not enhanced by cur. */
458                         continue;
459                 }
460
461                 /* dep is enhanced by cur, therefore mod requires cur. */
462                 if (module_reffed_deps_add(mod, cur, missing)) {
463                         return -1;
464                 }
465         }
466
467         return 0;
468 }
469
470 /*!
471  * \internal
472  * \brief Add references to a list of dependencies.
473  *
474  * \param mod Owner of the new references.
475  * \param vec List of required modules to process
476  * \param missing Vector to store names of modules that are not running.
477  * \param ref_enhancers Reference all enhancers of each required module.
478  * \param isoptional Modules that are not loaded can be ignored.
479  *
480  * \retval 0 Success
481  * \retval -1 Failure
482  */
483 static int module_deps_process_reqlist(struct ast_module *mod,
484         struct ast_vector_string *vec, struct ast_vector_const_string *missing,
485         int ref_enhancers, int isoptional)
486 {
487         int idx;
488
489         for (idx = 0; idx < AST_VECTOR_SIZE(vec); idx++) {
490                 const char *depname = AST_VECTOR_GET(vec, idx);
491                 struct ast_module *dep = find_resource(depname, 0);
492
493                 if (!dep || !dep->flags.running) {
494                         if (isoptional && !dep) {
495                                 continue;
496                         }
497
498                         if (missing && !AST_VECTOR_APPEND(missing, depname)) {
499                                 continue;
500                         }
501
502                         return -1;
503                 }
504
505                 if (module_reffed_deps_add(mod, dep, missing)) {
506                         return -1;
507                 }
508
509                 if (ref_enhancers && module_reffed_deps_add_dep_enhancers(mod, dep, missing)) {
510                         return -1;
511                 }
512         }
513
514         return 0;
515 }
516
517 /*!
518  * \internal
519  * \brief Grab all references required to start the module.
520  *
521  * \param mod The module we're trying to start.
522  * \param missing Vector to store a list of missing dependencies.
523  *
524  * \retval 0 Success
525  * \retval -1 Failure
526  *
527  * \note module_list must be locked.
528  *
529  * \note Caller is responsible for initializing and freeing the vector.
530  *       Elements are safely read only while module_list remains locked.
531  */
532 static int module_deps_reference(struct ast_module *mod, struct ast_vector_const_string *missing)
533 {
534         int res = 0;
535
536         /* Grab references to modules we enhance but not other enhancements. */
537         res |= module_deps_process_reqlist(mod, &mod->enhances, missing, 0, 0);
538
539         /* Grab references to modules we require plus enhancements. */
540         res |= module_deps_process_reqlist(mod, &mod->requires, missing, 1, 0);
541
542         /* Grab references to optional modules including enhancements. */
543         res |= module_deps_process_reqlist(mod, &mod->optional_modules, missing, 1, 1);
544
545         return res;
546 }
547
548 /*!
549  * \brief Recursively find required dependencies that are not running.
550  *
551  * \param mod Module to scan for dependencies.
552  * \param missingdeps Vector listing modules that must be started first.
553  *
554  * \retval 0 All dependencies resolved.
555  * \retval -1 Failed to resolve some dependencies.
556  *
557  * An error from this function usually means a required module is not even
558  * loaded.  This function is safe from infinite recursion, but dependency
559  * loops are not reported as an error from here.  On success missingdeps
560  * will contain a list of every module that needs to be running before this
561  * module can start.  missingdeps is sorted by load priority so any missing
562  * dependencies can be started if needed.
563  */
564 static int module_deps_missing_recursive(struct ast_module *mod, struct module_vector *missingdeps)
565 {
566         int i = 0;
567         int res = -1;
568         struct ast_vector_const_string localdeps;
569         struct ast_module *dep;
570
571         /*
572          * localdeps stores a copy of all dependencies that mod could not reference.
573          * First we discard modules that we've already found. We add all newly found
574          * modules to the missingdeps vector then scan them recursively.  This will
575          * ensure we quickly run out of stuff to do.
576          */
577         AST_VECTOR_INIT(&localdeps, 0);
578         if (module_deps_reference(mod, &localdeps)) {
579                 goto clean_return;
580         }
581
582         while (i < AST_VECTOR_SIZE(&localdeps)) {
583                 dep = find_resource(AST_VECTOR_GET(&localdeps, i), 0);
584                 if (!dep) {
585                         goto clean_return;
586                 }
587
588                 if (AST_VECTOR_GET_CMP(missingdeps, dep, AST_VECTOR_ELEM_DEFAULT_CMP)) {
589                         /* Skip common dependency.  We have already searched it. */
590                         AST_VECTOR_REMOVE(&localdeps, i, 0);
591                 } else {
592                         /* missingdeps is the real list so keep it sorted. */
593                         if (AST_VECTOR_ADD_SORTED(missingdeps, dep, module_vector_cmp)) {
594                                 goto clean_return;
595                         }
596                         i++;
597                 }
598         }
599
600         res = 0;
601         for (i = 0; !res && i < AST_VECTOR_SIZE(&localdeps); i++) {
602                 dep = find_resource(AST_VECTOR_GET(&localdeps, i), 0);
603                 /* We've already confirmed dep is loaded in the first loop. */
604                 res = module_deps_missing_recursive(dep, missingdeps);
605         }
606
607 clean_return:
608         AST_VECTOR_FREE(&localdeps);
609
610         return res;
611 }
612
613 const char *ast_module_name(const struct ast_module *mod)
614 {
615         if (!mod || !mod->info) {
616                 return NULL;
617         }
618
619         return mod->info->name;
620 }
621
622 struct loadupdate {
623         int (*updater)(void);
624         AST_LIST_ENTRY(loadupdate) entry;
625 };
626
627 static AST_DLLIST_HEAD_STATIC(updaters, loadupdate);
628
629 AST_MUTEX_DEFINE_STATIC(reloadlock);
630
631 struct reload_queue_item {
632         AST_LIST_ENTRY(reload_queue_item) entry;
633         char module[0];
634 };
635
636 static int do_full_reload = 0;
637
638 static AST_DLLIST_HEAD_STATIC(reload_queue, reload_queue_item);
639
640 /*!
641  * \internal
642  *
643  * This variable is set by load_dynamic_module so ast_module_register
644  * can know what pointer is being registered.
645  *
646  * This is protected by the module_list lock.
647  */
648 static struct ast_module * volatile resource_being_loaded;
649
650 /*!
651  * \internal
652  * \brief Used by AST_MODULE_INFO to register with the module loader.
653  *
654  * This function is automatically called when each module is opened.
655  * It must never be used from outside AST_MODULE_INFO.
656  */
657 void ast_module_register(const struct ast_module_info *info)
658 {
659         struct ast_module *mod;
660
661         if (!loader_ready) {
662                 mod = ast_std_calloc(1, sizeof(*mod) + strlen(info->name) + 1);
663                 if (!mod) {
664                         /* We haven't even reached main() yet, if we can't
665                          * allocate memory at this point just give up. */
666                         fprintf(stderr, "Allocation failure during startup.\n");
667                         exit(2);
668                 }
669                 strcpy(mod->resource, info->name); /* safe */
670                 mod->info = info;
671                 mod->flags.builtin = 1;
672                 AST_DLLIST_INSERT_TAIL(&builtin_module_list, mod, entry);
673
674                 /* ast_module_register for built-in modules is run again during module preload. */
675                 return;
676         }
677
678         /*
679          * This lock protects resource_being_loaded as well as the module
680          * list.  Normally we already have a lock on module_list when we
681          * begin the load but locking again from here prevents corruption
682          * if an asterisk module is dlopen'ed from outside the module loader.
683          */
684         AST_DLLIST_LOCK(&module_list);
685         mod = resource_being_loaded;
686         if (!mod) {
687                 AST_DLLIST_UNLOCK(&module_list);
688                 return;
689         }
690
691         ast_debug(5, "Registering module %s\n", info->name);
692
693         /* This tells load_dynamic_module that we're registered. */
694         resource_being_loaded = NULL;
695
696         mod->info = info;
697         if (ast_opt_ref_debug) {
698                 mod->ref_debug = ao2_t_alloc_options(0, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK, info->name);
699         }
700         AST_LIST_HEAD_INIT(&mod->users);
701         AST_VECTOR_INIT(&mod->requires, 0);
702         AST_VECTOR_INIT(&mod->optional_modules, 0);
703         AST_VECTOR_INIT(&mod->enhances, 0);
704         AST_VECTOR_INIT(&mod->reffed_deps, 0);
705
706         AST_DLLIST_INSERT_TAIL(&module_list, mod, entry);
707         AST_DLLIST_UNLOCK(&module_list);
708
709         /* give the module a copy of its own handle, for later use in registrations and the like */
710         *((struct ast_module **) &(info->self)) = mod;
711
712 #if defined(HAVE_PERMANENT_DLOPEN)
713         if (mod->flags.builtin != 1) {
714                 struct info_list_obj *obj_tmp = ao2_find(info_list, info->name,
715                         OBJ_SEARCH_KEY);
716
717                 if (!obj_tmp) {
718                         obj_tmp = info_list_obj_alloc(info->name, info);
719                         if (obj_tmp) {
720                                 ao2_link(info_list, obj_tmp);
721                                 ao2_ref(obj_tmp, -1);
722                         }
723                 } else {
724                         ao2_ref(obj_tmp, -1);
725                 }
726         }
727 #endif
728 }
729
730 static int module_post_register(struct ast_module *mod)
731 {
732         int res;
733
734         /* Split lists from mod->info. */
735         res  = ast_vector_string_split(&mod->requires, mod->info->requires, ",", 0, strcasecmp);
736         res |= ast_vector_string_split(&mod->optional_modules, mod->info->optional_modules, ",", 0, strcasecmp);
737         res |= ast_vector_string_split(&mod->enhances, mod->info->enhances, ",", 0, strcasecmp);
738
739         return res;
740 }
741
742 static void module_destroy(struct ast_module *mod)
743 {
744         AST_VECTOR_CALLBACK_VOID(&mod->requires, ast_free);
745         AST_VECTOR_FREE(&mod->requires);
746
747         AST_VECTOR_CALLBACK_VOID(&mod->optional_modules, ast_free);
748         AST_VECTOR_FREE(&mod->optional_modules);
749
750         AST_VECTOR_CALLBACK_VOID(&mod->enhances, ast_free);
751         AST_VECTOR_FREE(&mod->enhances);
752
753         /* Release references to all dependencies. */
754         AST_VECTOR_CALLBACK_VOID(&mod->reffed_deps, ast_module_unref);
755         AST_VECTOR_FREE(&mod->reffed_deps);
756
757         AST_LIST_HEAD_DESTROY(&mod->users);
758         ao2_cleanup(mod->ref_debug);
759         if (mod->flags.builtin) {
760                 ast_std_free(mod);
761         } else {
762                 ast_free(mod);
763         }
764 }
765
766 void ast_module_unregister(const struct ast_module_info *info)
767 {
768         struct ast_module *mod = NULL;
769
770         /* it is assumed that the users list in the module structure
771            will already be empty, or we cannot have gotten to this
772            point
773         */
774         AST_DLLIST_LOCK(&module_list);
775         AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&module_list, mod, entry) {
776                 if (mod->info == info) {
777                         AST_DLLIST_REMOVE_CURRENT(entry);
778                         break;
779                 }
780         }
781         AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
782         AST_DLLIST_UNLOCK(&module_list);
783
784         if (mod && !mod->usecount) {
785                 /*
786                  * We are intentionally leaking mod if usecount is not zero.
787                  * This is necessary if the module is being forcefully unloaded.
788                  * In addition module_destroy is not safe to run after exit()
789                  * is called.  ast_module_unregister is run during cleanup of
790                  * the process when libc releases each module's shared object
791                  * library.
792                  */
793                 ast_debug(5, "Unregistering module %s\n", info->name);
794                 module_destroy(mod);
795         }
796 }
797
798 struct ast_module_user *__ast_module_user_add(struct ast_module *mod, struct ast_channel *chan)
799 {
800         struct ast_module_user *u;
801
802         u = ast_calloc(1, sizeof(*u));
803         if (!u) {
804                 return NULL;
805         }
806
807         u->chan = chan;
808
809         AST_LIST_LOCK(&mod->users);
810         AST_LIST_INSERT_HEAD(&mod->users, u, entry);
811         AST_LIST_UNLOCK(&mod->users);
812
813         if (mod->ref_debug) {
814                 ao2_ref(mod->ref_debug, +1);
815         }
816
817         ast_atomic_fetchadd_int(&mod->usecount, +1);
818
819         ast_update_use_count();
820
821         return u;
822 }
823
824 void __ast_module_user_remove(struct ast_module *mod, struct ast_module_user *u)
825 {
826         if (!u) {
827                 return;
828         }
829
830         AST_LIST_LOCK(&mod->users);
831         u = AST_LIST_REMOVE(&mod->users, u, entry);
832         AST_LIST_UNLOCK(&mod->users);
833         if (!u) {
834                 /*
835                  * Was not in the list.  Either a bad pointer or
836                  * __ast_module_user_hangup_all() has been called.
837                  */
838                 return;
839         }
840
841         if (mod->ref_debug) {
842                 ao2_ref(mod->ref_debug, -1);
843         }
844
845         ast_atomic_fetchadd_int(&mod->usecount, -1);
846         ast_free(u);
847
848         ast_update_use_count();
849 }
850
851 void __ast_module_user_hangup_all(struct ast_module *mod)
852 {
853         struct ast_module_user *u;
854
855         AST_LIST_LOCK(&mod->users);
856         while ((u = AST_LIST_REMOVE_HEAD(&mod->users, entry))) {
857                 if (u->chan) {
858                         ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
859                 }
860
861                 if (mod->ref_debug) {
862                         ao2_ref(mod->ref_debug, -1);
863                 }
864
865                 ast_atomic_fetchadd_int(&mod->usecount, -1);
866                 ast_free(u);
867         }
868         AST_LIST_UNLOCK(&mod->users);
869
870         ast_update_use_count();
871 }
872
873 static int printdigest(const unsigned char *d)
874 {
875         int x, pos;
876         char buf[256]; /* large enough so we don't have to worry */
877
878         for (pos = 0, x = 0; x < 16; x++)
879                 pos += sprintf(buf + pos, " %02hhx", *d++);
880
881         ast_debug(1, "Unexpected signature:%s\n", buf);
882
883         return 0;
884 }
885
886 static int key_matches(const unsigned char *key1, const unsigned char *key2)
887 {
888         int x;
889
890         for (x = 0; x < 16; x++) {
891                 if (key1[x] != key2[x])
892                         return 0;
893         }
894
895         return 1;
896 }
897
898 static int verify_key(const unsigned char *key)
899 {
900         struct MD5Context c;
901         unsigned char digest[16];
902
903         MD5Init(&c);
904         MD5Update(&c, key, strlen((char *)key));
905         MD5Final(digest, &c);
906
907         if (key_matches(expected_key, digest))
908                 return 0;
909
910         printdigest(digest);
911
912         return -1;
913 }
914
915 static size_t resource_name_baselen(const char *name)
916 {
917         size_t len = strlen(name);
918
919         if (len > 3 && !strcasecmp(name + len - 3, ".so")) {
920                 return len - 3;
921         }
922
923         return len;
924 }
925
926 static int resource_name_match(const char *name1, size_t baselen1, const char *name2)
927 {
928         if (baselen1 != resource_name_baselen(name2)) {
929                 return -1;
930         }
931
932         return strncasecmp(name1, name2, baselen1);
933 }
934
935 static struct ast_module *find_resource(const char *resource, int do_lock)
936 {
937         struct ast_module *cur;
938         size_t resource_baselen = resource_name_baselen(resource);
939
940         if (do_lock) {
941                 AST_DLLIST_LOCK(&module_list);
942         }
943
944         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
945                 if (!resource_name_match(resource, resource_baselen, cur->resource)) {
946                         break;
947                 }
948         }
949
950         if (do_lock) {
951                 AST_DLLIST_UNLOCK(&module_list);
952         }
953
954         return cur;
955 }
956
957 /*!
958  * \brief dlclose(), with failure logging.
959  */
960 static void logged_dlclose(const char *name, void *lib)
961 {
962         char *error;
963
964         if (!lib) {
965                 return;
966         }
967
968         /* Clear any existing error */
969         dlerror();
970         if (dlclose(lib)) {
971                 error = dlerror();
972                 ast_log(AST_LOG_ERROR, "Failure in dlclose for module '%s': %s\n",
973                         S_OR(name, "unknown"), S_OR(error, "Unknown error"));
974 #if defined(HAVE_PERMANENT_DLOPEN)
975         } else {
976                 manual_mod_unreg(name);
977 #endif
978         }
979 }
980
981 #if defined(HAVE_RTLD_NOLOAD)
982 /*!
983  * \brief Check to see if the given resource is loaded.
984  *
985  * \param resource_name Name of the resource, including .so suffix.
986  * \return False (0) if module is not loaded.
987  * \return True (non-zero) if module is loaded.
988  */
989 static int is_module_loaded(const char *resource_name)
990 {
991         char fn[PATH_MAX] = "";
992         void *lib;
993
994         snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR,
995                 resource_name);
996
997         lib = dlopen(fn, RTLD_LAZY | RTLD_NOLOAD);
998
999         if (lib) {
1000                 logged_dlclose(resource_name, lib);
1001                 return 1;
1002         }
1003
1004         return 0;
1005 }
1006 #endif
1007
1008 static void unload_dynamic_module(struct ast_module *mod)
1009 {
1010 #if defined(HAVE_RTLD_NOLOAD)
1011         char *name = ast_strdupa(ast_module_name(mod));
1012 #endif
1013         void *lib = mod->lib;
1014
1015         /* WARNING: the structure pointed to by mod is going to
1016            disappear when this operation succeeds, so we can't
1017            dereference it */
1018         logged_dlclose(ast_module_name(mod), lib);
1019
1020         /* There are several situations where the module might still be resident
1021          * in memory.
1022          *
1023          * If somehow there was another dlopen() on the same module (unlikely,
1024          * since that all is supposed to happen in loader.c).
1025          *
1026          * Avoid the temptation of repeating the dlclose(). The other code that
1027          * dlopened the module still has its module reference, and should close
1028          * it itself. In other situations, dlclose() will happily return success
1029          * for as many times as you wish to call it.
1030          */
1031 #if defined(HAVE_RTLD_NOLOAD)
1032         if (is_module_loaded(name)) {
1033                 ast_log(LOG_WARNING, "Module '%s' could not be completely unloaded\n", name);
1034         }
1035 #endif
1036 }
1037
1038 static int load_dlopen_missing(struct ast_str **list, struct ast_vector_string *deps)
1039 {
1040         int i;
1041         int c = 0;
1042
1043         for (i = 0; i < AST_VECTOR_SIZE(deps); i++) {
1044                 const char *dep = AST_VECTOR_GET(deps, i);
1045                 if (!find_resource(dep, 0)) {
1046                         STR_APPEND_TEXT(dep, list);
1047                         c++;
1048                 }
1049         }
1050
1051         return c;
1052 }
1053
1054 /*!
1055  * \internal
1056  * \brief Attempt to dlopen a module.
1057  *
1058  * \param resource_in The module name to load.
1059  * \param so_ext ".so" or blank if ".so" is already part of resource_in.
1060  * \param filename Passed directly to dlopen.
1061  * \param flags Passed directly to dlopen.
1062  * \param suppress_logging Do not log any error from dlopen.
1063  *
1064  * \return Pointer to opened module, NULL on error.
1065  *
1066  * \warning module_list must be locked before calling this function.
1067  */
1068 static struct ast_module *load_dlopen(const char *resource_in, const char *so_ext,
1069         const char *filename, int flags, unsigned int suppress_logging)
1070 {
1071         struct ast_module *mod;
1072
1073         ast_assert(!resource_being_loaded);
1074
1075         mod = ast_calloc(1, sizeof(*mod) + strlen(resource_in) + strlen(so_ext) + 1);
1076         if (!mod) {
1077                 return NULL;
1078         }
1079
1080         sprintf(mod->resource, "%s%s", resource_in, so_ext); /* safe */
1081
1082         resource_being_loaded = mod;
1083         mod->lib = dlopen(filename, flags);
1084 #if defined(HAVE_PERMANENT_DLOPEN)
1085         manual_mod_reg(mod->lib, mod->resource);
1086 #endif
1087         if (resource_being_loaded) {
1088                 struct ast_str *list;
1089                 int c = 0;
1090                 const char *dlerror_msg = ast_strdupa(dlerror());
1091
1092                 resource_being_loaded = NULL;
1093                 if (mod->lib) {
1094                         module_load_error("Module '%s' did not register itself during load\n", resource_in);
1095                         logged_dlclose(resource_in, mod->lib);
1096
1097                         goto error_return;
1098                 }
1099
1100                 if (suppress_logging) {
1101                         goto error_return;
1102                 }
1103
1104                 resource_being_loaded = mod;
1105                 mod->lib = dlopen(filename, RTLD_LAZY | RTLD_LOCAL);
1106 #if defined(HAVE_PERMANENT_DLOPEN)
1107                 manual_mod_reg(mod->lib, mod->resource);
1108 #endif
1109                 if (resource_being_loaded) {
1110                         resource_being_loaded = NULL;
1111
1112                         module_load_error("Error loading module '%s': %s\n", resource_in, dlerror_msg);
1113                         logged_dlclose(resource_in, mod->lib);
1114
1115                         goto error_return;
1116                 }
1117
1118                 list = ast_str_create(64);
1119                 if (list) {
1120                         if (module_post_register(mod)) {
1121                                 goto loaded_error;
1122                         }
1123
1124                         c = load_dlopen_missing(&list, &mod->requires);
1125                         c += load_dlopen_missing(&list, &mod->enhances);
1126 #ifndef OPTIONAL_API
1127                         c += load_dlopen_missing(&list, &mod->optional_modules);
1128 #endif
1129                 }
1130
1131                 if (list && ast_str_strlen(list)) {
1132                         module_load_error("Error loading module '%s', missing %s: %s\n",
1133                                 resource_in, c == 1 ? "dependency" : "dependencies", ast_str_buffer(list));
1134                 } else {
1135                         module_load_error("Error loading module '%s': %s\n", resource_in, dlerror_msg);
1136                 }
1137
1138 loaded_error:
1139                 ast_free(list);
1140                 unload_dynamic_module(mod);
1141
1142                 return NULL;
1143
1144 error_return:
1145                 ast_free(mod);
1146
1147                 return NULL;
1148         }
1149
1150         return mod;
1151 }
1152
1153 static struct ast_module *load_dynamic_module(const char *resource_in, unsigned int suppress_logging)
1154 {
1155         char fn[PATH_MAX];
1156         struct ast_module *mod;
1157         size_t resource_in_len = strlen(resource_in);
1158         const char *so_ext = "";
1159
1160         if (resource_in_len < 4 || strcasecmp(resource_in + resource_in_len - 3, ".so")) {
1161                 so_ext = ".so";
1162         }
1163
1164         snprintf(fn, sizeof(fn), "%s/%s%s", ast_config_AST_MODULE_DIR, resource_in, so_ext);
1165
1166         /* Try loading in quiet mode first with RTLD_LOCAL.  The majority of modules do not
1167          * export symbols so this allows the least number of calls to dlopen. */
1168         mod = load_dlopen(resource_in, so_ext, fn, RTLD_NOW | RTLD_LOCAL, suppress_logging);
1169
1170         if (!mod || !ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS)) {
1171                 return mod;
1172         }
1173
1174         /* Close the module so we can reopen with correct flags. */
1175         logged_dlclose(resource_in, mod->lib);
1176
1177         return load_dlopen(resource_in, so_ext, fn, RTLD_NOW | RTLD_GLOBAL, 0);
1178 }
1179
1180 int modules_shutdown(void)
1181 {
1182         struct ast_module *mod;
1183         int somethingchanged;
1184         int res;
1185
1186         AST_DLLIST_LOCK(&module_list);
1187
1188         /*!\note Some resources, like timers, are started up dynamically, and thus
1189          * may be still in use, even if all channels are dead.  We must therefore
1190          * check the usecount before asking modules to unload. */
1191         do {
1192                 /* Reset flag before traversing the list */
1193                 somethingchanged = 0;
1194
1195                 AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&module_list, mod, entry) {
1196                         if (mod->usecount) {
1197                                 ast_debug(1, "Passing on %s: its use count is %d\n",
1198                                         mod->resource, mod->usecount);
1199                                 continue;
1200                         }
1201                         AST_DLLIST_REMOVE_CURRENT(entry);
1202                         if (mod->flags.running && !mod->flags.declined && mod->info->unload) {
1203                                 ast_verb(1, "Unloading %s\n", mod->resource);
1204                                 mod->info->unload();
1205                         }
1206                         module_destroy(mod);
1207                         somethingchanged = 1;
1208                 }
1209                 AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
1210                 if (!somethingchanged) {
1211                         AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
1212                                 if (mod->flags.keepuntilshutdown) {
1213                                         ast_module_unref(mod);
1214                                         mod->flags.keepuntilshutdown = 0;
1215                                         somethingchanged = 1;
1216                                 }
1217                         }
1218                 }
1219         } while (somethingchanged);
1220
1221         res = AST_DLLIST_EMPTY(&module_list);
1222         AST_DLLIST_UNLOCK(&module_list);
1223
1224         return !res;
1225 }
1226
1227 int ast_unload_resource(const char *resource_name, enum ast_module_unload_mode force)
1228 {
1229         struct ast_module *mod;
1230         int res = -1;
1231         int error = 0;
1232
1233         AST_DLLIST_LOCK(&module_list);
1234
1235         if (!(mod = find_resource(resource_name, 0))) {
1236                 AST_DLLIST_UNLOCK(&module_list);
1237                 ast_log(LOG_WARNING, "Unload failed, '%s' could not be found\n", resource_name);
1238                 return -1;
1239         }
1240
1241         if (!mod->flags.running || mod->flags.declined) {
1242                 ast_log(LOG_WARNING, "Unload failed, '%s' is not loaded.\n", resource_name);
1243                 error = 1;
1244         }
1245
1246         if (!error && (mod->usecount > 0)) {
1247                 if (force)
1248                         ast_log(LOG_WARNING, "Warning:  Forcing removal of module '%s' with use count %d\n",
1249                                 resource_name, mod->usecount);
1250                 else {
1251                         ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name,
1252                                 mod->usecount);
1253                         error = 1;
1254                 }
1255         }
1256
1257         if (!error) {
1258                 /* Request any channels attached to the module to hangup. */
1259                 __ast_module_user_hangup_all(mod);
1260
1261                 ast_verb(1, "Unloading %s\n", mod->resource);
1262                 res = mod->info->unload();
1263                 if (res) {
1264                         ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
1265                         if (force <= AST_FORCE_FIRM) {
1266                                 error = 1;
1267                         } else {
1268                                 ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
1269                         }
1270                 }
1271
1272                 if (!error) {
1273                         /*
1274                          * Request hangup on any channels that managed to get attached
1275                          * while we called the module unload function.
1276                          */
1277                         __ast_module_user_hangup_all(mod);
1278                         sched_yield();
1279                 }
1280         }
1281
1282         if (!error)
1283                 mod->flags.running = mod->flags.declined = 0;
1284
1285         AST_DLLIST_UNLOCK(&module_list);
1286
1287         if (!error) {
1288                 unload_dynamic_module(mod);
1289                 ast_test_suite_event_notify("MODULE_UNLOAD", "Message: %s", resource_name);
1290                 ast_update_use_count();
1291                 publish_unload_message(resource_name, "Success");
1292         }
1293
1294         return res;
1295 }
1296
1297 static int module_matches_helper_type(struct ast_module *mod, enum ast_module_helper_type type)
1298 {
1299         switch (type) {
1300         case AST_MODULE_HELPER_UNLOAD:
1301                 return !mod->usecount && mod->flags.running && !mod->flags.declined;
1302
1303         case AST_MODULE_HELPER_RELOAD:
1304                 return mod->flags.running && mod->info->reload;
1305
1306         case AST_MODULE_HELPER_RUNNING:
1307                 return mod->flags.running;
1308
1309         case AST_MODULE_HELPER_LOADED:
1310                 /* if we have a 'struct ast_module' then we're loaded. */
1311                 return 1;
1312         default:
1313                 /* This function is not called for AST_MODULE_HELPER_LOAD. */
1314                 /* Unknown ast_module_helper_type. Assume it doesn't match. */
1315                 ast_assert(0);
1316
1317                 return 0;
1318         }
1319 }
1320
1321 struct module_load_word {
1322         const char *word;
1323         size_t len;
1324         size_t moddir_len;
1325 };
1326
1327 static int module_load_helper_on_file(const char *dir_name, const char *filename, void *obj)
1328 {
1329         struct module_load_word *word = obj;
1330         struct ast_module *mod;
1331         char *filename_merged = NULL;
1332
1333         /* dir_name will never be shorter than word->moddir_len. */
1334         dir_name += word->moddir_len;
1335         if (!ast_strlen_zero(dir_name)) {
1336                 ast_assert(dir_name[0] == '/');
1337
1338                 dir_name += 1;
1339                 if (ast_asprintf(&filename_merged, "%s/%s", dir_name, filename) < 0) {
1340                         /* If we can't allocate the string just give up! */
1341                         return -1;
1342                 }
1343                 filename = filename_merged;
1344         }
1345
1346         if (!strncasecmp(filename, word->word, word->len)) {
1347                 /* Don't list files that are already loaded! */
1348                 mod = find_resource(filename, 0);
1349                 if (!mod || !mod->flags.running) {
1350                         ast_cli_completion_add(ast_strdup(filename));
1351                 }
1352         }
1353
1354         ast_free(filename_merged);
1355
1356         return 0;
1357 }
1358
1359 static void module_load_helper(const char *word)
1360 {
1361         struct module_load_word word_l = {
1362                 .word = word,
1363                 .len = strlen(word),
1364                 .moddir_len = strlen(ast_config_AST_MODULE_DIR),
1365         };
1366
1367         AST_DLLIST_LOCK(&module_list);
1368         ast_file_read_dirs(ast_config_AST_MODULE_DIR, module_load_helper_on_file, &word_l, -1);
1369         AST_DLLIST_UNLOCK(&module_list);
1370 }
1371
1372 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, enum ast_module_helper_type type)
1373 {
1374         struct ast_module *mod;
1375         int which = 0;
1376         int wordlen = strlen(word);
1377         char *ret = NULL;
1378
1379         if (pos != rpos) {
1380                 return NULL;
1381         }
1382
1383         if (type == AST_MODULE_HELPER_LOAD) {
1384                 module_load_helper(word);
1385
1386                 return NULL;
1387         }
1388
1389         AST_DLLIST_LOCK(&module_list);
1390         AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
1391                 if (!module_matches_helper_type(mod, type)) {
1392                         continue;
1393                 }
1394
1395                 if (!strncasecmp(word, mod->resource, wordlen) && ++which > state) {
1396                         ret = ast_strdup(mod->resource);
1397                         break;
1398                 }
1399         }
1400         AST_DLLIST_UNLOCK(&module_list);
1401
1402         return ret;
1403 }
1404
1405 void ast_process_pending_reloads(void)
1406 {
1407         struct reload_queue_item *item;
1408
1409         modules_loaded = 1;
1410
1411         AST_LIST_LOCK(&reload_queue);
1412
1413         if (do_full_reload) {
1414                 do_full_reload = 0;
1415                 AST_LIST_UNLOCK(&reload_queue);
1416                 ast_log(LOG_NOTICE, "Executing deferred reload request.\n");
1417                 ast_module_reload(NULL);
1418                 return;
1419         }
1420
1421         while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
1422                 ast_log(LOG_NOTICE, "Executing deferred reload request for module '%s'.\n", item->module);
1423                 ast_module_reload(item->module);
1424                 ast_free(item);
1425         }
1426
1427         AST_LIST_UNLOCK(&reload_queue);
1428 }
1429
1430 static void queue_reload_request(const char *module)
1431 {
1432         struct reload_queue_item *item;
1433
1434         AST_LIST_LOCK(&reload_queue);
1435
1436         if (do_full_reload) {
1437                 AST_LIST_UNLOCK(&reload_queue);
1438                 return;
1439         }
1440
1441         if (ast_strlen_zero(module)) {
1442                 /* A full reload request (when module is NULL) wipes out any previous
1443                    reload requests and causes the queue to ignore future ones */
1444                 while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
1445                         ast_free(item);
1446                 }
1447                 do_full_reload = 1;
1448         } else {
1449                 /* No reason to add the same module twice */
1450                 AST_LIST_TRAVERSE(&reload_queue, item, entry) {
1451                         if (!strcasecmp(item->module, module)) {
1452                                 AST_LIST_UNLOCK(&reload_queue);
1453                                 return;
1454                         }
1455                 }
1456                 item = ast_calloc(1, sizeof(*item) + strlen(module) + 1);
1457                 if (!item) {
1458                         ast_log(LOG_ERROR, "Failed to allocate reload queue item.\n");
1459                         AST_LIST_UNLOCK(&reload_queue);
1460                         return;
1461                 }
1462                 strcpy(item->module, module);
1463                 AST_LIST_INSERT_TAIL(&reload_queue, item, entry);
1464         }
1465         AST_LIST_UNLOCK(&reload_queue);
1466 }
1467
1468 /*!
1469  * \since 12
1470  * \internal
1471  * \brief Publish a \ref stasis message regarding the type.
1472  */
1473 static void publish_load_message_type(const char* type, const char *name, const char *status)
1474 {
1475         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
1476         RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
1477         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
1478         RAII_VAR(struct ast_json *, event_object, NULL, ast_json_unref);
1479
1480         ast_assert(type != NULL);
1481         ast_assert(!ast_strlen_zero(name));
1482         ast_assert(!ast_strlen_zero(status));
1483
1484         if (!ast_manager_get_generic_type()) {
1485                 return;
1486         }
1487
1488         event_object = ast_json_pack("{s:s, s:s}",
1489                         "Module", name,
1490                         "Status", status);
1491         json_object = ast_json_pack("{s:s, s:i, s:o}",
1492                         "type", type,
1493                         "class_type", EVENT_FLAG_SYSTEM,
1494                         "event", ast_json_ref(event_object));
1495         if (!json_object) {
1496                 return;
1497         }
1498
1499         payload = ast_json_payload_create(json_object);
1500         if (!payload) {
1501                 return;
1502         }
1503
1504         message = stasis_message_create(ast_manager_get_generic_type(), payload);
1505         if (!message) {
1506                 return;
1507         }
1508
1509         stasis_publish(ast_manager_get_topic(), message);
1510 }
1511
1512 static const char* loadresult2str(enum ast_module_load_result result)
1513 {
1514         int i;
1515         for (i = 0; i < ARRAY_LEN(load_results); i++) {
1516                 if (load_results[i].result == result) {
1517                         return load_results[i].name;
1518                 }
1519         }
1520
1521         ast_log(LOG_WARNING, "Failed to find correct load result status. result %d\n", result);
1522         return AST_MODULE_LOAD_UNKNOWN_STRING;
1523 }
1524
1525 /*!
1526  * \internal
1527  * \brief Publish a \ref stasis message regarding the load result
1528  */
1529 static void publish_load_message(const char *name, enum ast_module_load_result result)
1530 {
1531         const char *status;
1532
1533         status = loadresult2str(result);
1534
1535         publish_load_message_type("Load", name, status);
1536 }
1537
1538 /*!
1539  * \internal
1540  * \brief Publish a \ref stasis message regarding the unload result
1541  */
1542 static void publish_unload_message(const char *name, const char* status)
1543 {
1544         publish_load_message_type("Unload", name, status);
1545 }
1546
1547 /*!
1548  * \since 12
1549  * \internal
1550  * \brief Publish a \ref stasis message regarding the reload result
1551  */
1552 static void publish_reload_message(const char *name, enum ast_module_reload_result result)
1553 {
1554         char res_buffer[8];
1555
1556         snprintf(res_buffer, sizeof(res_buffer), "%u", result);
1557         publish_load_message_type("Reload", S_OR(name, "All"), res_buffer);
1558 }
1559
1560 enum ast_module_reload_result ast_module_reload(const char *name)
1561 {
1562         struct ast_module *cur;
1563         enum ast_module_reload_result res = AST_MODULE_RELOAD_NOT_FOUND;
1564         size_t name_baselen = name ? resource_name_baselen(name) : 0;
1565
1566         /* If we aren't fully booted, we just pretend we reloaded but we queue this
1567            up to run once we are booted up. */
1568         if (!modules_loaded) {
1569                 queue_reload_request(name);
1570                 res = AST_MODULE_RELOAD_QUEUED;
1571                 goto module_reload_exit;
1572         }
1573
1574         if (ast_mutex_trylock(&reloadlock)) {
1575                 ast_verb(3, "The previous reload command didn't finish yet\n");
1576                 res = AST_MODULE_RELOAD_IN_PROGRESS;
1577                 goto module_reload_exit;
1578         }
1579         ast_sd_notify("RELOAD=1");
1580         ast_lastreloadtime = ast_tvnow();
1581
1582         if (ast_opt_lock_confdir) {
1583                 int try;
1584                 int lockres;
1585                 for (try = 1, lockres = AST_LOCK_TIMEOUT; try < 6 && (lockres == AST_LOCK_TIMEOUT); try++) {
1586                         lockres = ast_lock_path(ast_config_AST_CONFIG_DIR);
1587                         if (lockres == AST_LOCK_TIMEOUT) {
1588                                 ast_log(LOG_WARNING, "Failed to grab lock on %s, try %d\n", ast_config_AST_CONFIG_DIR, try);
1589                         }
1590                 }
1591                 if (lockres != AST_LOCK_SUCCESS) {
1592                         ast_log(AST_LOG_WARNING, "Cannot grab lock on %s\n", ast_config_AST_CONFIG_DIR);
1593                         res = AST_MODULE_RELOAD_ERROR;
1594                         goto module_reload_done;
1595                 }
1596         }
1597
1598         AST_DLLIST_LOCK(&module_list);
1599         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
1600                 const struct ast_module_info *info = cur->info;
1601
1602                 if (name && resource_name_match(name, name_baselen, cur->resource)) {
1603                         continue;
1604                 }
1605
1606                 if (!cur->flags.running || cur->flags.declined) {
1607                         if (res == AST_MODULE_RELOAD_NOT_FOUND) {
1608                                 res = AST_MODULE_RELOAD_UNINITIALIZED;
1609                         }
1610                         if (!name) {
1611                                 continue;
1612                         }
1613                         break;
1614                 }
1615
1616                 if (!info->reload) {    /* cannot be reloaded */
1617                         if (res == AST_MODULE_RELOAD_NOT_FOUND) {
1618                                 res = AST_MODULE_RELOAD_NOT_IMPLEMENTED;
1619                         }
1620                         if (!name) {
1621                                 continue;
1622                         }
1623                         break;
1624                 }
1625                 ast_verb(3, "Reloading module '%s' (%s)\n", cur->resource, info->description);
1626                 if (info->reload() == AST_MODULE_LOAD_SUCCESS) {
1627                         res = AST_MODULE_RELOAD_SUCCESS;
1628                 } else if (res == AST_MODULE_RELOAD_NOT_FOUND) {
1629                         res = AST_MODULE_RELOAD_ERROR;
1630                 }
1631                 if (name) {
1632                         break;
1633                 }
1634         }
1635         AST_DLLIST_UNLOCK(&module_list);
1636
1637         if (ast_opt_lock_confdir) {
1638                 ast_unlock_path(ast_config_AST_CONFIG_DIR);
1639         }
1640 module_reload_done:
1641         ast_mutex_unlock(&reloadlock);
1642         ast_sd_notify("READY=1");
1643
1644 module_reload_exit:
1645         publish_reload_message(name, res);
1646         return res;
1647 }
1648
1649 static unsigned int inspect_module(const struct ast_module *mod)
1650 {
1651         if (!mod->info->description) {
1652                 module_load_error("Module '%s' does not provide a description.\n", mod->resource);
1653                 return 1;
1654         }
1655
1656         if (!mod->info->key) {
1657                 module_load_error("Module '%s' does not provide a license key.\n", mod->resource);
1658                 return 1;
1659         }
1660
1661         if (verify_key((unsigned char *) mod->info->key)) {
1662                 module_load_error("Module '%s' did not provide a valid license key.\n", mod->resource);
1663                 return 1;
1664         }
1665
1666         if (!ast_strlen_zero(mod->info->buildopt_sum) &&
1667             strcmp(buildopt_sum, mod->info->buildopt_sum)) {
1668                 module_load_error("Module '%s' was not compiled with the same compile-time options as this version of Asterisk.\n", mod->resource);
1669                 module_load_error("Module '%s' will not be initialized as it may cause instability.\n", mod->resource);
1670                 return 1;
1671         }
1672
1673         return 0;
1674 }
1675
1676 static enum ast_module_load_result start_resource(struct ast_module *mod)
1677 {
1678         char tmp[256];
1679         enum ast_module_load_result res;
1680
1681         if (mod->flags.running) {
1682                 return AST_MODULE_LOAD_SUCCESS;
1683         }
1684
1685         if (!mod->info->load) {
1686                 mod->flags.declined = 1;
1687
1688                 return mod->flags.required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1689         }
1690
1691         if (module_deps_reference(mod, NULL)) {
1692                 struct module_vector missing;
1693                 int i;
1694
1695                 AST_VECTOR_INIT(&missing, 0);
1696                 if (module_deps_missing_recursive(mod, &missing)) {
1697                         module_load_error("%s has one or more unknown dependencies.\n", mod->info->name);
1698                 }
1699                 for (i = 0; i < AST_VECTOR_SIZE(&missing); i++) {
1700                         module_load_error("%s loaded before dependency %s!\n", mod->info->name,
1701                                 AST_VECTOR_GET(&missing, i)->info->name);
1702                 }
1703                 AST_VECTOR_FREE(&missing);
1704
1705                 return AST_MODULE_LOAD_DECLINE;
1706         }
1707
1708         if (!ast_fully_booted) {
1709                 ast_verb(1, "Loading %s.\n", mod->resource);
1710         }
1711         res = mod->info->load();
1712
1713         switch (res) {
1714         case AST_MODULE_LOAD_SUCCESS:
1715                 if (!ast_fully_booted) {
1716                         ast_verb(2, "%s => (%s)\n", mod->resource, term_color(tmp, mod->info->description, COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
1717                 } else {
1718                         ast_verb(1, "Loaded %s => (%s)\n", mod->resource, mod->info->description);
1719                 }
1720
1721                 mod->flags.running = 1;
1722                 if (mod->flags.builtin) {
1723                         /* Built-in modules cannot be unloaded. */
1724                         ast_module_shutdown_ref(mod);
1725                 }
1726
1727                 ast_update_use_count();
1728                 break;
1729         case AST_MODULE_LOAD_DECLINE:
1730                 mod->flags.declined = 1;
1731                 if (mod->flags.required) {
1732                         res = AST_MODULE_LOAD_FAILURE;
1733                 }
1734                 break;
1735         case AST_MODULE_LOAD_FAILURE:
1736                 mod->flags.declined = 1;
1737                 break;
1738         case AST_MODULE_LOAD_SKIP: /* modules should never return this value */
1739         case AST_MODULE_LOAD_PRIORITY:
1740                 break;
1741         }
1742
1743         /* Make sure the newly started module is at the end of the list */
1744         AST_DLLIST_LOCK(&module_list);
1745         AST_DLLIST_REMOVE(&module_list, mod, entry);
1746         AST_DLLIST_INSERT_TAIL(&module_list, mod, entry);
1747         AST_DLLIST_UNLOCK(&module_list);
1748
1749         return res;
1750 }
1751
1752 /*! loads a resource based upon resource_name. If global_symbols_only is set
1753  *  only modules with global symbols will be loaded.
1754  *
1755  *  If the module_vector is provided (not NULL) the module is found and added to the
1756  *  vector without running the module's load() function.  By doing this, modules
1757  *  can be initialized later in order by priority and dependencies.
1758  *
1759  *  If the module_vector is not provided, the module's load function will be executed
1760  *  immediately */
1761 static enum ast_module_load_result load_resource(const char *resource_name, unsigned int suppress_logging,
1762         struct module_vector *module_priorities, int required, int preload)
1763 {
1764         struct ast_module *mod;
1765         enum ast_module_load_result res = AST_MODULE_LOAD_SUCCESS;
1766
1767         if ((mod = find_resource(resource_name, 0))) {
1768                 if (mod->flags.running) {
1769                         ast_log(LOG_WARNING, "Module '%s' already loaded and running.\n", resource_name);
1770                         return AST_MODULE_LOAD_DECLINE;
1771                 }
1772         } else {
1773                 mod = load_dynamic_module(resource_name, suppress_logging);
1774                 if (!mod) {
1775                         return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1776                 }
1777
1778                 if (module_post_register(mod)) {
1779                         goto prestart_error;
1780                 }
1781         }
1782
1783         mod->flags.required |= required;
1784         mod->flags.preload |= preload;
1785
1786         if (inspect_module(mod)) {
1787                 goto prestart_error;
1788         }
1789
1790         mod->flags.declined = 0;
1791
1792         if (module_priorities) {
1793                 if (AST_VECTOR_ADD_SORTED(module_priorities, mod, module_vector_cmp)) {
1794                         goto prestart_error;
1795                 }
1796                 res = AST_MODULE_LOAD_PRIORITY;
1797         } else {
1798                 res = start_resource(mod);
1799         }
1800
1801         if (ast_fully_booted && !ast_shutdown_final()) {
1802                 publish_load_message(resource_name, res);
1803         }
1804
1805         return res;
1806
1807 prestart_error:
1808         module_load_error("Module '%s' could not be loaded.\n", resource_name);
1809         unload_dynamic_module(mod);
1810         res = required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1811         if (ast_fully_booted && !ast_shutdown_final()) {
1812                 publish_load_message(resource_name, res);
1813         }
1814         return res;
1815 }
1816
1817 int ast_load_resource(const char *resource_name)
1818 {
1819         int res;
1820         AST_DLLIST_LOCK(&module_list);
1821         res = load_resource(resource_name, 0, NULL, 0, 0);
1822         if (!res) {
1823                 ast_test_suite_event_notify("MODULE_LOAD", "Message: %s", resource_name);
1824         }
1825         AST_DLLIST_UNLOCK(&module_list);
1826
1827         return res;
1828 }
1829
1830 struct load_order_entry {
1831         char *resource;
1832         int required;
1833         int preload;
1834         int builtin;
1835         AST_LIST_ENTRY(load_order_entry) entry;
1836 };
1837
1838 AST_LIST_HEAD_NOLOCK(load_order, load_order_entry);
1839
1840 static struct load_order_entry *add_to_load_order(const char *resource, struct load_order *load_order, int required, int preload, int builtin)
1841 {
1842         struct load_order_entry *order;
1843         size_t resource_baselen = resource_name_baselen(resource);
1844
1845         AST_LIST_TRAVERSE(load_order, order, entry) {
1846                 if (!resource_name_match(resource, resource_baselen, order->resource)) {
1847                         /* Make sure we have the proper setting for the required field
1848                            (we might have both load= and required= lines in modules.conf) */
1849                         order->required |= required;
1850                         order->preload |= preload;
1851                         return order;
1852                 }
1853         }
1854
1855         order = ast_calloc(1, sizeof(*order));
1856         if (!order) {
1857                 return NULL;
1858         }
1859
1860         order->resource = ast_strdup(resource);
1861         if (!order->resource) {
1862                 ast_free(order);
1863
1864                 return NULL;
1865         }
1866         order->required = required;
1867         order->preload = preload;
1868         order->builtin = builtin;
1869         AST_LIST_INSERT_TAIL(load_order, order, entry);
1870
1871         return order;
1872 }
1873
1874 AST_LIST_HEAD_NOLOCK(load_retries, load_order_entry);
1875
1876 static enum ast_module_load_result start_resource_attempt(struct ast_module *mod, int *count)
1877 {
1878         enum ast_module_load_result lres;
1879
1880         /* Try to grab required references. */
1881         if (module_deps_reference(mod, NULL)) {
1882                 /* We're likely to retry so not an error. */
1883                 ast_debug(1, "Module %s is missing dependencies\n", mod->resource);
1884                 return AST_MODULE_LOAD_SKIP;
1885         }
1886
1887         lres = start_resource(mod);
1888         ast_debug(3, "START: %-46s[%d] %d\n",
1889                 mod->resource,
1890                 ast_test_flag(mod->info, AST_MODFLAG_LOAD_ORDER) ? mod->info->load_pri : AST_MODPRI_DEFAULT,
1891                 lres);
1892
1893         if (lres == AST_MODULE_LOAD_SUCCESS) {
1894                 (*count)++;
1895         } else if (lres == AST_MODULE_LOAD_FAILURE) {
1896                 module_load_error("*** Failed to load %smodule %s\n",
1897                         mod->flags.required ? "required " : "",
1898                         mod->resource);
1899         }
1900
1901         return lres;
1902 }
1903
1904 static int resource_list_recursive_decline(struct module_vector *resources, struct ast_module *mod,
1905         struct ast_str **printmissing)
1906 {
1907         struct module_vector missingdeps;
1908         struct ast_vector_const_string localdeps;
1909         int i = 0;
1910         int res = -1;
1911
1912         mod->flags.declined = 1;
1913         if (mod->flags.required) {
1914                 module_load_error("Required module %s declined to load.\n", ast_module_name(mod));
1915
1916                 return -2;
1917         }
1918
1919         module_load_error("%s declined to load.\n", ast_module_name(mod));
1920
1921         if (!*printmissing) {
1922                 *printmissing = ast_str_create(64);
1923                 if (!*printmissing) {
1924                         return -1;
1925                 }
1926         } else {
1927                 ast_str_reset(*printmissing);
1928         }
1929
1930         AST_VECTOR_INIT(&missingdeps, 0);
1931         AST_VECTOR_INIT(&localdeps, 0);
1932
1933         /* Decline everything that depends on 'mod' from resources so we can
1934          * print a concise list. */
1935         while (res != -2 && i < AST_VECTOR_SIZE(resources)) {
1936                 struct ast_module *dep = AST_VECTOR_GET(resources, i);
1937                 i++;
1938
1939                 AST_VECTOR_RESET(&missingdeps, AST_VECTOR_ELEM_CLEANUP_NOOP);
1940                 if (dep->flags.declined || module_deps_missing_recursive(dep, &missingdeps)) {
1941                         continue;
1942                 }
1943
1944                 if (AST_VECTOR_GET_CMP(&missingdeps, mod, AST_VECTOR_ELEM_DEFAULT_CMP)) {
1945                         dep->flags.declined = 1;
1946                         if (dep->flags.required) {
1947                                 module_load_error("Cannot load required module %s that depends on %s\n",
1948                                         ast_module_name(dep), ast_module_name(mod));
1949                                 res = -2;
1950                         } else {
1951                                 AST_VECTOR_APPEND(&localdeps, ast_module_name(dep));
1952                         }
1953                 }
1954         }
1955         AST_VECTOR_FREE(&missingdeps);
1956
1957         if (res != -2 && AST_VECTOR_SIZE(&localdeps)) {
1958                 AST_VECTOR_CALLBACK_VOID(&localdeps, STR_APPEND_TEXT, printmissing);
1959                 module_load_error("Declined modules which depend on %s: %s\n",
1960                         ast_module_name(mod), ast_str_buffer(*printmissing));
1961         }
1962         AST_VECTOR_FREE(&localdeps);
1963
1964         return res;
1965 }
1966
1967 static int start_resource_list(struct module_vector *resources, int *mod_count)
1968 {
1969         struct module_vector missingdeps;
1970         int res = 0;
1971         struct ast_str *printmissing = NULL;
1972
1973         AST_VECTOR_INIT(&missingdeps, 0);
1974         while (res != -2 && AST_VECTOR_SIZE(resources)) {
1975                 struct ast_module *mod = AST_VECTOR_REMOVE(resources, 0, 1);
1976                 enum ast_module_load_result lres;
1977
1978                 if (mod->flags.declined) {
1979                         ast_debug(1, "%s is already declined, skipping\n", ast_module_name(mod));
1980                         continue;
1981                 }
1982
1983 retry_load:
1984                 lres = start_resource_attempt(mod, mod_count);
1985                 if (lres == AST_MODULE_LOAD_SUCCESS) {
1986                         /* No missing dependencies, successful. */
1987                         continue;
1988                 }
1989
1990                 if (lres == AST_MODULE_LOAD_FAILURE) {
1991                         res = -2;
1992                         break;
1993                 }
1994
1995                 if (lres == AST_MODULE_LOAD_DECLINE) {
1996                         res = resource_list_recursive_decline(resources, mod, &printmissing);
1997                         continue;
1998                 }
1999
2000                 if (module_deps_missing_recursive(mod, &missingdeps)) {
2001                         AST_VECTOR_RESET(&missingdeps, AST_VECTOR_ELEM_CLEANUP_NOOP);
2002                         module_load_error("Failed to resolve dependencies for %s\n", ast_module_name(mod));
2003                         res = resource_list_recursive_decline(resources, mod, &printmissing);
2004                         continue;
2005                 }
2006
2007                 if (!AST_VECTOR_SIZE(&missingdeps)) {
2008                         module_load_error("%s load function returned an invalid result. "
2009                                 "This is a bug in the module.\n", ast_module_name(mod));
2010                         /* Dependencies were met but the module failed to start and the result
2011                          * code was not AST_MODULE_LOAD_FAILURE or AST_MODULE_LOAD_DECLINE. */
2012                         res = resource_list_recursive_decline(resources, mod, &printmissing);
2013                         continue;
2014                 }
2015
2016                 ast_debug(1, "%s has %d dependencies\n",
2017                         ast_module_name(mod), (int)AST_VECTOR_SIZE(&missingdeps));
2018                 while (AST_VECTOR_SIZE(&missingdeps)) {
2019                         int didwork = 0;
2020                         int i = 0;
2021
2022                         while (i < AST_VECTOR_SIZE(&missingdeps)) {
2023                                 struct ast_module *dep = AST_VECTOR_GET(&missingdeps, i);
2024
2025                                 if (dep->flags.declined) {
2026                                         ast_debug(1, "%s tried to start %s but it's already declined\n",
2027                                                 ast_module_name(mod), ast_module_name(dep));
2028                                         i++;
2029                                         continue;
2030                                 }
2031
2032                                 ast_debug(1, "%s trying to start %s\n", ast_module_name(mod), ast_module_name(dep));
2033                                 lres = start_resource_attempt(dep, mod_count);
2034                                 if (lres == AST_MODULE_LOAD_SUCCESS) {
2035                                         ast_debug(1, "%s started %s\n", ast_module_name(mod), ast_module_name(dep));
2036                                         AST_VECTOR_REMOVE(&missingdeps, i, 1);
2037                                         AST_VECTOR_REMOVE_CMP_ORDERED(resources, dep,
2038                                                 AST_VECTOR_ELEM_DEFAULT_CMP, AST_VECTOR_ELEM_CLEANUP_NOOP);
2039                                         didwork++;
2040                                         continue;
2041                                 }
2042
2043                                 if (lres == AST_MODULE_LOAD_FAILURE) {
2044                                         module_load_error("Failed to load %s.\n", ast_module_name(dep));
2045                                         res = -2;
2046                                         goto exitpoint;
2047                                 }
2048
2049                                 ast_debug(1, "%s failed to start %s\n", ast_module_name(mod), ast_module_name(dep));
2050                                 i++;
2051                         }
2052
2053                         if (!didwork) {
2054                                 break;
2055                         }
2056                 }
2057
2058                 if (AST_VECTOR_SIZE(&missingdeps)) {
2059                         if (!printmissing) {
2060                                 printmissing = ast_str_create(64);
2061                         } else {
2062                                 ast_str_reset(printmissing);
2063                         }
2064
2065                         if (printmissing) {
2066                                 struct ast_vector_const_string localdeps;
2067
2068                                 AST_VECTOR_INIT(&localdeps, 0);
2069                                 module_deps_reference(mod, &localdeps);
2070                                 AST_VECTOR_CALLBACK_VOID(&localdeps, STR_APPEND_TEXT, &printmissing);
2071                                 AST_VECTOR_FREE(&localdeps);
2072                         }
2073
2074                         module_load_error("Failed to load %s due to dependencies: %s.\n",
2075                                 ast_module_name(mod),
2076                                 printmissing ? ast_str_buffer(printmissing) : "allocation failure creating list");
2077                         res = resource_list_recursive_decline(resources, mod, &printmissing);
2078
2079                         AST_VECTOR_RESET(&missingdeps, AST_VECTOR_ELEM_CLEANUP_NOOP);
2080
2081                         continue;
2082                 }
2083
2084                 /* If we're here it means that we started with missingdeps and they're all loaded
2085                  * now.  It's impossible to reach this point a second time for the same module. */
2086                 goto retry_load;
2087         }
2088
2089 exitpoint:
2090         ast_free(printmissing);
2091         AST_VECTOR_FREE(&missingdeps);
2092
2093         return res;
2094 }
2095
2096 /*! loads modules in order by load_pri, updates mod_count
2097         \return -1 on failure to load module, -2 on failure to load required module, otherwise 0
2098 */
2099 static int load_resource_list(struct load_order *load_order, int *mod_count)
2100 {
2101         struct module_vector module_priorities;
2102         struct load_order_entry *order;
2103         int attempt = 0;
2104         int count = 0;
2105         int res = 0;
2106         int didwork;
2107         int lasttry = 0;
2108
2109         if (AST_VECTOR_INIT(&module_priorities, 500)) {
2110                 ast_log(LOG_ERROR, "Failed to initialize module loader.\n");
2111
2112                 return -1;
2113         }
2114
2115         while (res != -2) {
2116                 didwork = 0;
2117
2118                 AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
2119                         enum ast_module_load_result lres;
2120
2121                         /* Suppress log messages unless this is the last pass */
2122                         lres = load_resource(order->resource, !lasttry, &module_priorities, order->required, order->preload);
2123                         ast_debug(3, "PASS %d: %-46s %d\n", attempt, order->resource, lres);
2124                         switch (lres) {
2125                         case AST_MODULE_LOAD_SUCCESS:
2126                         case AST_MODULE_LOAD_SKIP:
2127                                 /* We're supplying module_priorities so SUCCESS isn't possible but we
2128                                  * still have to test for it.  SKIP is only used when we try to start a
2129                                  * module that is missing dependencies. */
2130                                 break;
2131                         case AST_MODULE_LOAD_DECLINE:
2132                                 res = -1;
2133                                 break;
2134                         case AST_MODULE_LOAD_FAILURE:
2135                                 /* LOAD_FAILURE only happens for required modules */
2136                                 if (lasttry) {
2137                                         /* This run is just to print errors. */
2138                                         module_load_error("*** Failed to load module %s - Required\n", order->resource);
2139                                         fprintf(stderr, "*** Failed to load module %s - Required\n", order->resource);
2140                                         res =  -2;
2141                                 }
2142                                 break;
2143                         case AST_MODULE_LOAD_PRIORITY:
2144                                 /* load_resource worked and the module was added to module_priorities */
2145                                 AST_LIST_REMOVE_CURRENT(entry);
2146                                 ast_free(order->resource);
2147                                 ast_free(order);
2148                                 didwork = 1;
2149                                 break;
2150                         }
2151                 }
2152                 AST_LIST_TRAVERSE_SAFE_END;
2153
2154                 if (!didwork) {
2155                         if (lasttry) {
2156                                 break;
2157                         }
2158                         /* We know the next try is going to fail, it's only being performed
2159                          * so we can print errors. */
2160                         lasttry = 1;
2161                 }
2162                 attempt++;
2163         }
2164
2165         if (res != -2) {
2166                 res = start_resource_list(&module_priorities, &count);
2167         }
2168
2169         if (mod_count) {
2170                 *mod_count += count;
2171         }
2172         AST_VECTOR_FREE(&module_priorities);
2173
2174         return res;
2175 }
2176
2177 static int loader_builtin_init(struct load_order *load_order)
2178 {
2179         struct ast_module *mod;
2180
2181         /*
2182          * All built-in modules have registered the first time, now it's time to complete
2183          * the registration and add them to the priority list.
2184          */
2185         loader_ready = 1;
2186
2187         while ((resource_being_loaded = AST_DLLIST_REMOVE_HEAD(&builtin_module_list, entry))) {
2188                 /* ast_module_register doesn't finish when first run by built-in modules. */
2189                 ast_module_register(resource_being_loaded->info);
2190         }
2191
2192         /* Add all built-in modules to the load order. */
2193         AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
2194                 if (!mod->flags.builtin) {
2195                         continue;
2196                 }
2197
2198                 /* Parse dependendencies from mod->info. */
2199                 if (module_post_register(mod)) {
2200                         return -1;
2201                 }
2202
2203                 /* Built-in modules are not preloaded, most have an early load priority. */
2204                 if (!add_to_load_order(mod->resource, load_order, 0, 0, 1)) {
2205                         return -1;
2206                 }
2207         }
2208
2209         return 0;
2210 }
2211
2212 static int loader_config_init(struct load_order *load_order)
2213 {
2214         int res = -1;
2215         struct load_order_entry *order;
2216         struct ast_config *cfg;
2217         struct ast_variable *v;
2218         struct ast_flags config_flags = { 0 };
2219
2220         cfg = ast_config_load2(AST_MODULE_CONFIG, "" /* core, can't reload */, config_flags);
2221         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
2222                 ast_log(LOG_WARNING, "'%s' invalid or missing.\n", AST_MODULE_CONFIG);
2223
2224                 return -1;
2225         }
2226
2227         /* first, find all the modules we have been explicitly requested to load */
2228         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
2229                 int required;
2230                 int preload = 0;
2231
2232                 if (!strncasecmp(v->name, "preload", strlen("preload"))) {
2233                         preload = 1;
2234                         if (!strcasecmp(v->name, "preload")) {
2235                                 required = 0;
2236                         } else if (!strcasecmp(v->name, "preload-require")) {
2237                                 required = 1;
2238                         } else {
2239                                 ast_log(LOG_ERROR, "Unknown configuration option '%s'", v->name);
2240                                 goto done;
2241                         }
2242                 } else if (!strcasecmp(v->name, "load")) {
2243                         required = 0;
2244                 } else if (!strcasecmp(v->name, "require")) {
2245                         required = 1;
2246                 } else if (!strcasecmp(v->name, "noload") || !strcasecmp(v->name, "autoload")) {
2247                         continue;
2248                 } else {
2249                         ast_log(LOG_ERROR, "Unknown configuration option '%s'", v->name);
2250                         goto done;
2251                 }
2252
2253                 if (required) {
2254                         ast_debug(2, "Adding module to required list: %s (%s)\n", v->value, v->name);
2255                 }
2256
2257                 if (!add_to_load_order(v->value, load_order, required, preload, 0)) {
2258                         goto done;
2259                 }
2260         }
2261
2262         /* check if 'autoload' is on */
2263         if (ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
2264                 /* if we are allowed to load dynamic modules, scan the directory for
2265                    for all available modules and add them as well */
2266                 DIR *dir = opendir(ast_config_AST_MODULE_DIR);
2267                 struct dirent *dirent;
2268
2269                 if (dir) {
2270                         while ((dirent = readdir(dir))) {
2271                                 int ld = strlen(dirent->d_name);
2272
2273                                 /* Must end in .so to load it.  */
2274
2275                                 if (ld < 4)
2276                                         continue;
2277
2278                                 if (strcasecmp(dirent->d_name + ld - 3, ".so"))
2279                                         continue;
2280
2281                                 /* if there is already a module by this name in the module_list,
2282                                    skip this file */
2283                                 if (find_resource(dirent->d_name, 0))
2284                                         continue;
2285
2286                                 if (!add_to_load_order(dirent->d_name, load_order, 0, 0, 0)) {
2287                                         closedir(dir);
2288                                         goto done;
2289                                 }
2290                         }
2291
2292                         closedir(dir);
2293                 } else {
2294                         ast_log(LOG_ERROR, "Unable to open modules directory '%s'.\n", ast_config_AST_MODULE_DIR);
2295                         goto done;
2296                 }
2297         }
2298
2299         /* now scan the config for any modules we are prohibited from loading and
2300            remove them from the load order */
2301         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
2302                 size_t baselen;
2303
2304                 if (strcasecmp(v->name, "noload")) {
2305                         continue;
2306                 }
2307
2308                 baselen = resource_name_baselen(v->value);
2309                 AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
2310                         if (!resource_name_match(v->value, baselen, order->resource)) {
2311                                 if (order->builtin) {
2312                                         ast_log(LOG_ERROR, "%s is a built-in module, you cannot specify 'noload'.\n", v->value);
2313                                         goto done;
2314                                 }
2315
2316                                 if (order->required) {
2317                                         ast_log(LOG_ERROR, "%s is configured with '%s' and 'noload', this is impossible.\n",
2318                                                 v->value, order->preload ? "preload-require" : "require");
2319                                         goto done;
2320                                 }
2321                                 AST_LIST_REMOVE_CURRENT(entry);
2322                                 ast_free(order->resource);
2323                                 ast_free(order);
2324                         }
2325                 }
2326                 AST_LIST_TRAVERSE_SAFE_END;
2327         }
2328
2329         res = 0;
2330 done:
2331         ast_config_destroy(cfg);
2332
2333         return res;
2334 }
2335
2336 int load_modules(void)
2337 {
2338         struct load_order_entry *order;
2339         unsigned int load_count;
2340         struct load_order load_order;
2341         int res = 0;
2342         int modulecount = 0;
2343         int i;
2344
2345         ast_verb(1, "Asterisk Dynamic Loader Starting:\n");
2346
2347 #if defined(HAVE_PERMANENT_DLOPEN)
2348         info_list = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL,
2349                 info_list_obj_cmp_fn); /* must not be cleaned at shutdown */
2350         if (!info_list) {
2351                 fprintf(stderr, "Module info list allocation failure.\n");
2352                 return 1;
2353         }
2354 #endif
2355
2356         AST_LIST_HEAD_INIT_NOLOCK(&load_order);
2357         AST_DLLIST_LOCK(&module_list);
2358
2359         AST_VECTOR_INIT(&startup_errors, 0);
2360         startup_error_builder = ast_str_create(64);
2361
2362         res = loader_builtin_init(&load_order);
2363         if (res) {
2364                 goto done;
2365         }
2366
2367         res = loader_config_init(&load_order);
2368         if (res) {
2369                 goto done;
2370         }
2371
2372         load_count = 0;
2373         AST_LIST_TRAVERSE(&load_order, order, entry)
2374                 load_count++;
2375
2376         if (load_count)
2377                 ast_log(LOG_NOTICE, "%u modules will be loaded.\n", load_count);
2378
2379         res = load_resource_list(&load_order, &modulecount);
2380         if (res == -1) {
2381                 ast_log(LOG_WARNING, "Some non-required modules failed to load.\n");
2382                 res = 0;
2383         }
2384
2385 done:
2386         while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
2387                 ast_free(order->resource);
2388                 ast_free(order);
2389         }
2390
2391         AST_DLLIST_UNLOCK(&module_list);
2392
2393         for (i = 0; i < AST_VECTOR_SIZE(&startup_errors); i++) {
2394                 char *str = AST_VECTOR_GET(&startup_errors, i);
2395
2396                 ast_log(LOG_ERROR, "%s", str);
2397                 ast_free(str);
2398         }
2399         AST_VECTOR_FREE(&startup_errors);
2400
2401         ast_free(startup_error_builder);
2402         startup_error_builder = NULL;
2403
2404         return res;
2405 }
2406
2407 void ast_update_use_count(void)
2408 {
2409         /* Notify any module monitors that the use count for a
2410            resource has changed */
2411         struct loadupdate *m;
2412
2413         AST_LIST_LOCK(&updaters);
2414         AST_LIST_TRAVERSE(&updaters, m, entry)
2415                 m->updater();
2416         AST_LIST_UNLOCK(&updaters);
2417 }
2418
2419 /*!
2420  * \internal
2421  * \brief Build an alpha sorted list of modules.
2422  *
2423  * \param alpha_module_list Pointer to uninitialized module_vector.
2424  *
2425  * This function always initializes alpha_module_list.
2426  *
2427  * \pre module_list must be locked.
2428  */
2429 static int alpha_module_list_create(struct module_vector *alpha_module_list)
2430 {
2431         struct ast_module *cur;
2432
2433         if (AST_VECTOR_INIT(alpha_module_list, 32)) {
2434                 return -1;
2435         }
2436
2437         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
2438                 if (AST_VECTOR_ADD_SORTED(alpha_module_list, cur, module_vector_strcasecmp)) {
2439                         return -1;
2440                 }
2441         }
2442
2443         return 0;
2444 }
2445
2446 int ast_update_module_list(int (*modentry)(const char *module, const char *description,
2447                                            int usecnt, const char *status, const char *like,
2448                                                                                    enum ast_module_support_level support_level),
2449                            const char *like)
2450 {
2451         int total_mod_loaded = 0;
2452         struct module_vector alpha_module_list;
2453
2454         AST_DLLIST_LOCK(&module_list);
2455
2456         if (!alpha_module_list_create(&alpha_module_list)) {
2457                 int idx;
2458
2459                 for (idx = 0; idx < AST_VECTOR_SIZE(&alpha_module_list); idx++) {
2460                         struct ast_module *cur = AST_VECTOR_GET(&alpha_module_list, idx);
2461
2462                         total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount,
2463                                 cur->flags.running ? "Running" : "Not Running", like, cur->info->support_level);
2464                 }
2465         }
2466
2467         AST_DLLIST_UNLOCK(&module_list);
2468         AST_VECTOR_FREE(&alpha_module_list);
2469
2470         return total_mod_loaded;
2471 }
2472
2473 int ast_update_module_list_data(int (*modentry)(const char *module, const char *description,
2474                                                 int usecnt, const char *status, const char *like,
2475                                                 enum ast_module_support_level support_level,
2476                                                 void *data),
2477                                 const char *like, void *data)
2478 {
2479         int total_mod_loaded = 0;
2480         struct module_vector alpha_module_list;
2481
2482         AST_DLLIST_LOCK(&module_list);
2483
2484         if (!alpha_module_list_create(&alpha_module_list)) {
2485                 int idx;
2486
2487                 for (idx = 0; idx < AST_VECTOR_SIZE(&alpha_module_list); idx++) {
2488                         struct ast_module *cur = AST_VECTOR_GET(&alpha_module_list, idx);
2489
2490                         total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount,
2491                                 cur->flags.running? "Running" : "Not Running", like, cur->info->support_level, data);
2492                 }
2493         }
2494
2495         AST_DLLIST_UNLOCK(&module_list);
2496         AST_VECTOR_FREE(&alpha_module_list);
2497
2498         return total_mod_loaded;
2499 }
2500
2501 int ast_update_module_list_condition(int (*modentry)(const char *module, const char *description,
2502                                                      int usecnt, const char *status,
2503                                                      const char *like,
2504                                                      enum ast_module_support_level support_level,
2505                                                      void *data, const char *condition),
2506                                      const char *like, void *data, const char *condition)
2507 {
2508         int conditions_met = 0;
2509         struct module_vector alpha_module_list;
2510
2511         AST_DLLIST_LOCK(&module_list);
2512
2513         if (!alpha_module_list_create(&alpha_module_list)) {
2514                 int idx;
2515
2516                 for (idx = 0; idx < AST_VECTOR_SIZE(&alpha_module_list); idx++) {
2517                         struct ast_module *cur = AST_VECTOR_GET(&alpha_module_list, idx);
2518
2519                         conditions_met += modentry(cur->resource, cur->info->description, cur->usecount,
2520                                 cur->flags.running? "Running" : "Not Running", like, cur->info->support_level, data,
2521                                 condition);
2522                 }
2523         }
2524
2525         AST_DLLIST_UNLOCK(&module_list);
2526         AST_VECTOR_FREE(&alpha_module_list);
2527
2528         return conditions_met;
2529 }
2530
2531 /*! \brief Check if module exists */
2532 int ast_module_check(const char *name)
2533 {
2534         struct ast_module *cur;
2535
2536         if (ast_strlen_zero(name))
2537                 return 0;       /* FALSE */
2538
2539         cur = find_resource(name, 1);
2540
2541         return (cur != NULL);
2542 }
2543
2544
2545 int ast_loader_register(int (*v)(void))
2546 {
2547         struct loadupdate *tmp;
2548
2549         if (!(tmp = ast_malloc(sizeof(*tmp))))
2550                 return -1;
2551
2552         tmp->updater = v;
2553         AST_LIST_LOCK(&updaters);
2554         AST_LIST_INSERT_HEAD(&updaters, tmp, entry);
2555         AST_LIST_UNLOCK(&updaters);
2556
2557         return 0;
2558 }
2559
2560 int ast_loader_unregister(int (*v)(void))
2561 {
2562         struct loadupdate *cur;
2563
2564         AST_LIST_LOCK(&updaters);
2565         AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, entry) {
2566                 if (cur->updater == v)  {
2567                         AST_LIST_REMOVE_CURRENT(entry);
2568                         break;
2569                 }
2570         }
2571         AST_LIST_TRAVERSE_SAFE_END;
2572         AST_LIST_UNLOCK(&updaters);
2573
2574         return cur ? 0 : -1;
2575 }
2576
2577 struct ast_module *__ast_module_ref(struct ast_module *mod, const char *file, int line, const char *func)
2578 {
2579         if (!mod) {
2580                 return NULL;
2581         }
2582
2583         if (mod->ref_debug) {
2584                 __ao2_ref(mod->ref_debug, +1, "", file, line, func);
2585         }
2586
2587         ast_atomic_fetchadd_int(&mod->usecount, +1);
2588         ast_update_use_count();
2589
2590         return mod;
2591 }
2592
2593 struct ast_module *__ast_module_running_ref(struct ast_module *mod,
2594         const char *file, int line, const char *func)
2595 {
2596         if (!mod || !mod->flags.running) {
2597                 return NULL;
2598         }
2599
2600         return __ast_module_ref(mod, file, line, func);
2601 }
2602
2603 void __ast_module_shutdown_ref(struct ast_module *mod, const char *file, int line, const char *func)
2604 {
2605         if (!mod || mod->flags.keepuntilshutdown) {
2606                 return;
2607         }
2608
2609         __ast_module_ref(mod, file, line, func);
2610         mod->flags.keepuntilshutdown = 1;
2611 }
2612
2613 void __ast_module_unref(struct ast_module *mod, const char *file, int line, const char *func)
2614 {
2615         if (!mod) {
2616                 return;
2617         }
2618
2619         if (mod->ref_debug) {
2620                 __ao2_ref(mod->ref_debug, -1, "", file, line, func);
2621         }
2622
2623         ast_atomic_fetchadd_int(&mod->usecount, -1);
2624         ast_update_use_count();
2625 }
2626
2627 const char *support_level_map [] = {
2628         [AST_MODULE_SUPPORT_UNKNOWN] = "unknown",
2629         [AST_MODULE_SUPPORT_CORE] = "core",
2630         [AST_MODULE_SUPPORT_EXTENDED] = "extended",
2631         [AST_MODULE_SUPPORT_DEPRECATED] = "deprecated",
2632 };
2633
2634 const char *ast_module_support_level_to_string(enum ast_module_support_level support_level)
2635 {
2636         return support_level_map[support_level];
2637 }