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