PJPROJECT logging: Made easier to get available logging levels.
[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/acl.h"
46 #include "asterisk/manager.h"
47 #include "asterisk/cdr.h"
48 #include "asterisk/enum.h"
49 #include "asterisk/http.h"
50 #include "asterisk/lock.h"
51 #include "asterisk/features_config.h"
52 #include "asterisk/dsp.h"
53 #include "asterisk/udptl.h"
54 #include "asterisk/heap.h"
55 #include "asterisk/app.h"
56 #include "asterisk/test.h"
57 #include "asterisk/sounds_index.h"
58
59 #include <dlfcn.h>
60
61 #include "asterisk/md5.h"
62 #include "asterisk/utils.h"
63
64 /*** DOCUMENTATION
65         <managerEvent language="en_US" name="Reload">
66                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
67                         <synopsis>Raised when a module has been reloaded in Asterisk.</synopsis>
68                         <syntax>
69                                 <parameter name="Module">
70                                         <para>The name of the module that was reloaded, or
71                                         <literal>All</literal> if all modules were reloaded</para>
72                                 </parameter>
73                                 <parameter name="Status">
74                                         <para>The numeric status code denoting the success or failure
75                                         of the reload request.</para>
76                                         <enumlist>
77                                                 <enum name="0"><para>Success</para></enum>
78                                                 <enum name="1"><para>Request queued</para></enum>
79                                                 <enum name="2"><para>Module not found</para></enum>
80                                                 <enum name="3"><para>Error</para></enum>
81                                                 <enum name="4"><para>Reload already in progress</para></enum>
82                                                 <enum name="5"><para>Module uninitialized</para></enum>
83                                                 <enum name="6"><para>Reload not supported</para></enum>
84                                         </enumlist>
85                                 </parameter>
86                         </syntax>
87                 </managerEventInstance>
88         </managerEvent>
89  ***/
90
91 #ifndef RTLD_NOW
92 #define RTLD_NOW 0
93 #endif
94
95 #ifndef RTLD_LOCAL
96 #define RTLD_LOCAL 0
97 #endif
98
99 struct ast_module_user {
100         struct ast_channel *chan;
101         AST_LIST_ENTRY(ast_module_user) entry;
102 };
103
104 AST_DLLIST_HEAD(module_user_list, ast_module_user);
105
106 static const unsigned char expected_key[] =
107 { 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3,
108   0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 };
109
110 static char buildopt_sum[33] = AST_BUILDOPT_SUM;
111
112 static unsigned int embedding = 1; /* we always start out by registering embedded modules,
113                                       since they are here before we dlopen() any
114                                    */
115
116 /*!
117  * \brief Internal flag to indicate all modules have been initially loaded.
118  */
119 static int modules_loaded;
120
121 struct ast_module {
122         const struct ast_module_info *info;
123         /* Used to get module references into refs log */
124         void *ref_debug;
125         void *lib;                                      /* the shared lib, or NULL if embedded */
126         int usecount;                                   /* the number of 'users' currently in this module */
127         struct module_user_list users;                  /* the list of users in the module */
128         struct {
129                 unsigned int running:1;
130                 unsigned int declined:1;
131                 unsigned int keepuntilshutdown:1;
132         } flags;
133         AST_LIST_ENTRY(ast_module) list_entry;
134         AST_DLLIST_ENTRY(ast_module) entry;
135         char resource[0];
136 };
137
138 static AST_DLLIST_HEAD_STATIC(module_list, ast_module);
139
140 const char *ast_module_name(const struct ast_module *mod)
141 {
142         if (!mod || !mod->info) {
143                 return NULL;
144         }
145
146         return mod->info->name;
147 }
148
149 /*
150  * module_list is cleared by its constructor possibly after
151  * we start accumulating embedded modules, so we need to
152  * use another list (without the lock) to accumulate them.
153  * Then we update the main list when embedding is done.
154  */
155 static struct module_list embedded_module_list;
156
157 struct loadupdate {
158         int (*updater)(void);
159         AST_LIST_ENTRY(loadupdate) entry;
160 };
161
162 static AST_DLLIST_HEAD_STATIC(updaters, loadupdate);
163
164 AST_MUTEX_DEFINE_STATIC(reloadlock);
165
166 struct reload_queue_item {
167         AST_LIST_ENTRY(reload_queue_item) entry;
168         char module[0];
169 };
170
171 static int do_full_reload = 0;
172
173 static AST_DLLIST_HEAD_STATIC(reload_queue, reload_queue_item);
174
175 /* when dynamic modules are being loaded, ast_module_register() will
176    need to know what filename the module was loaded from while it
177    is being registered
178 */
179 static struct ast_module *resource_being_loaded;
180
181 /* XXX: should we check for duplicate resource names here? */
182
183 void ast_module_register(const struct ast_module_info *info)
184 {
185         struct ast_module *mod;
186
187         if (embedding) {
188                 if (!(mod = ast_calloc(1, sizeof(*mod) + strlen(info->name) + 1)))
189                         return;
190                 strcpy(mod->resource, info->name);
191         } else {
192                 mod = resource_being_loaded;
193         }
194
195         ast_debug(5, "Registering module %s\n", info->name);
196
197         mod->info = info;
198         if (ast_opt_ref_debug) {
199                 mod->ref_debug = ao2_t_alloc(0, NULL, info->name);
200         }
201         AST_LIST_HEAD_INIT(&mod->users);
202
203         /* during startup, before the loader has been initialized,
204            there are no threads, so there is no need to take the lock
205            on this list to manipulate it. it is also possible that it
206            might be unsafe to use the list lock at that point... so
207            let's avoid it altogether
208         */
209         if (embedding) {
210                 AST_DLLIST_INSERT_TAIL(&embedded_module_list, mod, entry);
211         } else {
212                 AST_DLLIST_LOCK(&module_list);
213                 /* it is paramount that the new entry be placed at the tail of
214                    the list, otherwise the code that uses dlopen() to load
215                    dynamic modules won't be able to find out if the module it
216                    just opened was registered or failed to load
217                 */
218                 AST_DLLIST_INSERT_TAIL(&module_list, mod, entry);
219                 AST_DLLIST_UNLOCK(&module_list);
220         }
221
222         /* give the module a copy of its own handle, for later use in registrations and the like */
223         *((struct ast_module **) &(info->self)) = mod;
224 }
225
226 void ast_module_unregister(const struct ast_module_info *info)
227 {
228         struct ast_module *mod = NULL;
229
230         /* it is assumed that the users list in the module structure
231            will already be empty, or we cannot have gotten to this
232            point
233         */
234         AST_DLLIST_LOCK(&module_list);
235         AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&module_list, mod, entry) {
236                 if (mod->info == info) {
237                         AST_DLLIST_REMOVE_CURRENT(entry);
238                         break;
239                 }
240         }
241         AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
242         AST_DLLIST_UNLOCK(&module_list);
243
244         if (mod) {
245                 ast_debug(5, "Unregistering module %s\n", info->name);
246                 AST_LIST_HEAD_DESTROY(&mod->users);
247                 ao2_cleanup(mod->ref_debug);
248                 ast_free(mod);
249         }
250 }
251
252 struct ast_module_user *__ast_module_user_add(struct ast_module *mod, struct ast_channel *chan)
253 {
254         struct ast_module_user *u;
255
256         u = ast_calloc(1, sizeof(*u));
257         if (!u) {
258                 return NULL;
259         }
260
261         u->chan = chan;
262
263         AST_LIST_LOCK(&mod->users);
264         AST_LIST_INSERT_HEAD(&mod->users, u, entry);
265         AST_LIST_UNLOCK(&mod->users);
266
267         if (mod->ref_debug) {
268                 ao2_ref(mod->ref_debug, +1);
269         }
270
271         ast_atomic_fetchadd_int(&mod->usecount, +1);
272
273         ast_update_use_count();
274
275         return u;
276 }
277
278 void __ast_module_user_remove(struct ast_module *mod, struct ast_module_user *u)
279 {
280         if (!u) {
281                 return;
282         }
283
284         AST_LIST_LOCK(&mod->users);
285         u = AST_LIST_REMOVE(&mod->users, u, entry);
286         AST_LIST_UNLOCK(&mod->users);
287         if (!u) {
288                 /*
289                  * Was not in the list.  Either a bad pointer or
290                  * __ast_module_user_hangup_all() has been called.
291                  */
292                 return;
293         }
294
295         if (mod->ref_debug) {
296                 ao2_ref(mod->ref_debug, -1);
297         }
298
299         ast_atomic_fetchadd_int(&mod->usecount, -1);
300         ast_free(u);
301
302         ast_update_use_count();
303 }
304
305 void __ast_module_user_hangup_all(struct ast_module *mod)
306 {
307         struct ast_module_user *u;
308
309         AST_LIST_LOCK(&mod->users);
310         while ((u = AST_LIST_REMOVE_HEAD(&mod->users, entry))) {
311                 if (u->chan) {
312                         ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
313                 }
314
315                 if (mod->ref_debug) {
316                         ao2_ref(mod->ref_debug, -1);
317                 }
318
319                 ast_atomic_fetchadd_int(&mod->usecount, -1);
320                 ast_free(u);
321         }
322         AST_LIST_UNLOCK(&mod->users);
323
324         ast_update_use_count();
325 }
326
327 /*! \note
328  * In addition to modules, the reload command handles some extra keywords
329  * which are listed here together with the corresponding handlers.
330  * This table is also used by the command completion code.
331  */
332 static struct reload_classes {
333         const char *name;
334         int (*reload_fn)(void);
335 } reload_classes[] = {  /* list in alpha order, longest match first for cli completion */
336         { "acl",         ast_named_acl_reload },
337         { "cdr",         ast_cdr_engine_reload },
338         { "cel",         ast_cel_engine_reload },
339         { "dnsmgr",      dnsmgr_reload },
340         { "dsp",         ast_dsp_reload},
341         { "extconfig",   read_config_maps },
342         { "enum",        ast_enum_reload },
343         { "features",    ast_features_config_reload },
344         { "http",        ast_http_reload },
345         { "indications", ast_indications_reload },
346         { "logger",      logger_reload },
347         { "manager",     reload_manager },
348         { "plc",         ast_plc_reload },
349         { "sounds",      ast_sounds_reindex },
350         { "udptl",       ast_udptl_reload },
351         { NULL,          NULL }
352 };
353
354 static int printdigest(const unsigned char *d)
355 {
356         int x, pos;
357         char buf[256]; /* large enough so we don't have to worry */
358
359         for (pos = 0, x = 0; x < 16; x++)
360                 pos += sprintf(buf + pos, " %02hhx", *d++);
361
362         ast_debug(1, "Unexpected signature:%s\n", buf);
363
364         return 0;
365 }
366
367 static int key_matches(const unsigned char *key1, const unsigned char *key2)
368 {
369         int x;
370
371         for (x = 0; x < 16; x++) {
372                 if (key1[x] != key2[x])
373                         return 0;
374         }
375
376         return 1;
377 }
378
379 static int verify_key(const unsigned char *key)
380 {
381         struct MD5Context c;
382         unsigned char digest[16];
383
384         MD5Init(&c);
385         MD5Update(&c, key, strlen((char *)key));
386         MD5Final(digest, &c);
387
388         if (key_matches(expected_key, digest))
389                 return 0;
390
391         printdigest(digest);
392
393         return -1;
394 }
395
396 static int resource_name_match(const char *name1_in, const char *name2_in)
397 {
398         char *name1 = (char *) name1_in;
399         char *name2 = (char *) name2_in;
400
401         /* trim off any .so extensions */
402         if (!strcasecmp(name1 + strlen(name1) - 3, ".so")) {
403                 name1 = ast_strdupa(name1);
404                 name1[strlen(name1) - 3] = '\0';
405         }
406         if (!strcasecmp(name2 + strlen(name2) - 3, ".so")) {
407                 name2 = ast_strdupa(name2);
408                 name2[strlen(name2) - 3] = '\0';
409         }
410
411         return strcasecmp(name1, name2);
412 }
413
414 static struct ast_module *find_resource(const char *resource, int do_lock)
415 {
416         struct ast_module *cur;
417
418         if (do_lock) {
419                 AST_DLLIST_LOCK(&module_list);
420         }
421
422         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
423                 if (!resource_name_match(resource, cur->resource))
424                         break;
425         }
426
427         if (do_lock) {
428                 AST_DLLIST_UNLOCK(&module_list);
429         }
430
431         return cur;
432 }
433
434 #ifdef LOADABLE_MODULES
435
436 /*!
437  * \brief dlclose(), with failure logging.
438  */
439 static void logged_dlclose(const char *name, void *lib)
440 {
441         char *error;
442
443         if (!lib) {
444                 return;
445         }
446
447         /* Clear any existing error */
448         dlerror();
449         if (dlclose(lib)) {
450                 error = dlerror();
451                 ast_log(AST_LOG_ERROR, "Failure in dlclose for module '%s': %s\n",
452                         S_OR(name, "unknown"), S_OR(error, "Unknown error"));
453         }
454 }
455
456 #if defined(HAVE_RTLD_NOLOAD)
457 /*!
458  * \brief Check to see if the given resource is loaded.
459  *
460  * \param resource_name Name of the resource, including .so suffix.
461  * \return False (0) if module is not loaded.
462  * \return True (non-zero) if module is loaded.
463  */
464 static int is_module_loaded(const char *resource_name)
465 {
466         char fn[PATH_MAX] = "";
467         void *lib;
468
469         snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR,
470                 resource_name);
471
472         lib = dlopen(fn, RTLD_LAZY | RTLD_NOLOAD);
473
474         if (lib) {
475                 logged_dlclose(resource_name, lib);
476                 return 1;
477         }
478
479         return 0;
480 }
481 #endif
482
483 static void unload_dynamic_module(struct ast_module *mod)
484 {
485 #if defined(HAVE_RTLD_NOLOAD)
486         char *name = ast_strdupa(ast_module_name(mod));
487 #endif
488         void *lib = mod->lib;
489
490         /* WARNING: the structure pointed to by mod is going to
491            disappear when this operation succeeds, so we can't
492            dereference it */
493         logged_dlclose(ast_module_name(mod), lib);
494
495         /* There are several situations where the module might still be resident
496          * in memory.
497          *
498          * If somehow there was another dlopen() on the same module (unlikely,
499          * since that all is supposed to happen in loader.c).
500          *
501          * Or the lazy resolution of a global symbol (very likely, since that is
502          * how we load all of our modules that export global symbols).
503          *
504          * Avoid the temptation of repeating the dlclose(). The other code that
505          * dlopened the module still has its module reference, and should close
506          * it itself. In other situations, dlclose() will happily return success
507          * for as many times as you wish to call it.
508          */
509 #if defined(HAVE_RTLD_NOLOAD)
510         if (is_module_loaded(name)) {
511                 ast_log(LOG_WARNING, "Module '%s' could not be completely unloaded\n", name);
512         }
513 #endif
514 }
515
516 static enum ast_module_load_result load_resource(const char *resource_name, unsigned int global_symbols_only, unsigned int suppress_logging, struct ast_heap *resource_heap, int required);
517
518 #define MODULE_LOCAL_ONLY (void *)-1
519
520 static struct ast_module *load_dynamic_module(const char *resource_in, unsigned int global_symbols_only, unsigned int suppress_logging, struct ast_heap *resource_heap)
521 {
522         char fn[PATH_MAX] = "";
523         void *lib = NULL;
524         struct ast_module *mod;
525         unsigned int wants_global;
526         int space;      /* room needed for the descriptor */
527         int missing_so = 0;
528
529         space = sizeof(*resource_being_loaded) + strlen(resource_in) + 1;
530         if (strcasecmp(resource_in + strlen(resource_in) - 3, ".so")) {
531                 missing_so = 1;
532                 space += 3;     /* room for the extra ".so" */
533         }
534
535         snprintf(fn, sizeof(fn), "%s/%s%s", ast_config_AST_MODULE_DIR, resource_in, missing_so ? ".so" : "");
536
537         /* make a first load of the module in 'quiet' mode... don't try to resolve
538            any symbols, and don't export any symbols. this will allow us to peek into
539            the module's info block (if available) to see what flags it has set */
540
541         resource_being_loaded = ast_calloc(1, space);
542         if (!resource_being_loaded)
543                 return NULL;
544         strcpy(resource_being_loaded->resource, resource_in);
545         if (missing_so)
546                 strcat(resource_being_loaded->resource, ".so");
547
548         if (!(lib = dlopen(fn, RTLD_LAZY | RTLD_GLOBAL))) {
549                 if (!suppress_logging) {
550                         ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
551                 }
552                 ast_free(resource_being_loaded);
553                 return NULL;
554         }
555
556         /* the dlopen() succeeded, let's find out if the module
557            registered itself */
558         /* note that this will only work properly as long as
559            ast_module_register() (which is called by the module's
560            constructor) places the new module at the tail of the
561            module_list
562         */
563         if (resource_being_loaded != (mod = AST_DLLIST_LAST(&module_list))) {
564                 ast_log(LOG_WARNING, "Module '%s' did not register itself during load\n", resource_in);
565                 /* no, it did not, so close it and return */
566                 logged_dlclose(resource_in, lib);
567                 /* note that the module's destructor will call ast_module_unregister(),
568                    which will free the structure we allocated in resource_being_loaded */
569                 return NULL;
570         }
571
572         wants_global = ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS);
573
574         /* if we are being asked only to load modules that provide global symbols,
575            and this one does not, then close it and return */
576         if (global_symbols_only && !wants_global) {
577                 logged_dlclose(resource_in, lib);
578                 return MODULE_LOCAL_ONLY;
579         }
580
581         logged_dlclose(resource_in, lib);
582         resource_being_loaded = NULL;
583
584         /* start the load process again */
585         resource_being_loaded = ast_calloc(1, space);
586         if (!resource_being_loaded)
587                 return NULL;
588         strcpy(resource_being_loaded->resource, resource_in);
589         if (missing_so)
590                 strcat(resource_being_loaded->resource, ".so");
591
592         if (!(lib = dlopen(fn, wants_global ? RTLD_LAZY | RTLD_GLOBAL : RTLD_NOW | RTLD_LOCAL))) {
593                 ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
594                 ast_free(resource_being_loaded);
595                 return NULL;
596         }
597
598         /* since the module was successfully opened, and it registered itself
599            the previous time we did that, we're going to assume it worked this
600            time too :) */
601
602         AST_DLLIST_LAST(&module_list)->lib = lib;
603         resource_being_loaded = NULL;
604
605         return AST_DLLIST_LAST(&module_list);
606 }
607
608 #endif
609
610 int modules_shutdown(void)
611 {
612         struct ast_module *mod;
613         int somethingchanged = 1, final = 0;
614
615         AST_DLLIST_LOCK(&module_list);
616
617         /*!\note Some resources, like timers, are started up dynamically, and thus
618          * may be still in use, even if all channels are dead.  We must therefore
619          * check the usecount before asking modules to unload. */
620         do {
621                 if (!somethingchanged) {
622                         /*!\note If we go through the entire list without changing
623                          * anything, ignore the usecounts and unload, then exit. */
624                         final = 1;
625                 }
626
627                 /* Reset flag before traversing the list */
628                 somethingchanged = 0;
629
630                 AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&module_list, mod, entry) {
631                         if (!final && mod->usecount) {
632                                 ast_debug(1, "Passing on %s: its use count is %d\n",
633                                         mod->resource, mod->usecount);
634                                 continue;
635                         }
636                         AST_DLLIST_REMOVE_CURRENT(entry);
637                         if (mod->flags.running && !mod->flags.declined && mod->info->unload) {
638                                 ast_verb(1, "Unloading %s\n", mod->resource);
639                                 mod->info->unload();
640                         }
641                         AST_LIST_HEAD_DESTROY(&mod->users);
642                         ao2_cleanup(mod->ref_debug);
643                         ast_free(mod);
644                         somethingchanged = 1;
645                 }
646                 AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
647                 if (!somethingchanged) {
648                         AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
649                                 if (mod->flags.keepuntilshutdown) {
650                                         ast_module_unref(mod);
651                                         mod->flags.keepuntilshutdown = 0;
652                                         somethingchanged = 1;
653                                 }
654                         }
655                 }
656         } while (somethingchanged && !final);
657
658         final = AST_DLLIST_EMPTY(&module_list);
659         AST_DLLIST_UNLOCK(&module_list);
660
661         return !final;
662 }
663
664 int ast_unload_resource(const char *resource_name, enum ast_module_unload_mode force)
665 {
666         struct ast_module *mod;
667         int res = -1;
668         int error = 0;
669
670         AST_DLLIST_LOCK(&module_list);
671
672         if (!(mod = find_resource(resource_name, 0))) {
673                 AST_DLLIST_UNLOCK(&module_list);
674                 ast_log(LOG_WARNING, "Unload failed, '%s' could not be found\n", resource_name);
675                 return -1;
676         }
677
678         if (!mod->flags.running || mod->flags.declined) {
679                 ast_log(LOG_WARNING, "Unload failed, '%s' is not loaded.\n", resource_name);
680                 error = 1;
681         }
682
683         if (!error && (mod->usecount > 0)) {
684                 if (force)
685                         ast_log(LOG_WARNING, "Warning:  Forcing removal of module '%s' with use count %d\n",
686                                 resource_name, mod->usecount);
687                 else {
688                         ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name,
689                                 mod->usecount);
690                         error = 1;
691                 }
692         }
693
694         if (!error) {
695                 /* Request any channels attached to the module to hangup. */
696                 __ast_module_user_hangup_all(mod);
697
698                 ast_verb(1, "Unloading %s\n", mod->resource);
699                 res = mod->info->unload();
700                 if (res) {
701                         ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
702                         if (force <= AST_FORCE_FIRM) {
703                                 error = 1;
704                         } else {
705                                 ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
706                         }
707                 }
708
709                 if (!error) {
710                         /*
711                          * Request hangup on any channels that managed to get attached
712                          * while we called the module unload function.
713                          */
714                         __ast_module_user_hangup_all(mod);
715                         sched_yield();
716                 }
717         }
718
719         if (!error)
720                 mod->flags.running = mod->flags.declined = 0;
721
722         AST_DLLIST_UNLOCK(&module_list);
723
724         if (!error && !mod->lib && mod->info && mod->info->restore_globals)
725                 mod->info->restore_globals();
726
727 #ifdef LOADABLE_MODULES
728         if (!error) {
729                 unload_dynamic_module(mod);
730                 ast_test_suite_event_notify("MODULE_UNLOAD", "Message: %s", resource_name);
731         }
732 #endif
733
734         if (!error)
735                 ast_update_use_count();
736
737         return res;
738 }
739
740 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload)
741 {
742         struct ast_module *cur;
743         int i, which=0, l = strlen(word);
744         char *ret = NULL;
745
746         if (pos != rpos)
747                 return NULL;
748
749         AST_DLLIST_LOCK(&module_list);
750         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
751                 if (!strncasecmp(word, cur->resource, l) &&
752                     (cur->info->reload || !needsreload) &&
753                     ++which > state) {
754                         ret = ast_strdup(cur->resource);
755                         break;
756                 }
757         }
758         AST_DLLIST_UNLOCK(&module_list);
759
760         if (!ret) {
761                 for (i=0; !ret && reload_classes[i].name; i++) {
762                         if (!strncasecmp(word, reload_classes[i].name, l) && ++which > state)
763                                 ret = ast_strdup(reload_classes[i].name);
764                 }
765         }
766
767         return ret;
768 }
769
770 void ast_process_pending_reloads(void)
771 {
772         struct reload_queue_item *item;
773
774         modules_loaded = 1;
775
776         AST_LIST_LOCK(&reload_queue);
777
778         if (do_full_reload) {
779                 do_full_reload = 0;
780                 AST_LIST_UNLOCK(&reload_queue);
781                 ast_log(LOG_NOTICE, "Executing deferred reload request.\n");
782                 ast_module_reload(NULL);
783                 return;
784         }
785
786         while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
787                 ast_log(LOG_NOTICE, "Executing deferred reload request for module '%s'.\n", item->module);
788                 ast_module_reload(item->module);
789                 ast_free(item);
790         }
791
792         AST_LIST_UNLOCK(&reload_queue);
793 }
794
795 static void queue_reload_request(const char *module)
796 {
797         struct reload_queue_item *item;
798
799         AST_LIST_LOCK(&reload_queue);
800
801         if (do_full_reload) {
802                 AST_LIST_UNLOCK(&reload_queue);
803                 return;
804         }
805
806         if (ast_strlen_zero(module)) {
807                 /* A full reload request (when module is NULL) wipes out any previous
808                    reload requests and causes the queue to ignore future ones */
809                 while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
810                         ast_free(item);
811                 }
812                 do_full_reload = 1;
813         } else {
814                 /* No reason to add the same module twice */
815                 AST_LIST_TRAVERSE(&reload_queue, item, entry) {
816                         if (!strcasecmp(item->module, module)) {
817                                 AST_LIST_UNLOCK(&reload_queue);
818                                 return;
819                         }
820                 }
821                 item = ast_calloc(1, sizeof(*item) + strlen(module) + 1);
822                 if (!item) {
823                         ast_log(LOG_ERROR, "Failed to allocate reload queue item.\n");
824                         AST_LIST_UNLOCK(&reload_queue);
825                         return;
826                 }
827                 strcpy(item->module, module);
828                 AST_LIST_INSERT_TAIL(&reload_queue, item, entry);
829         }
830         AST_LIST_UNLOCK(&reload_queue);
831 }
832
833 /*!
834  * \since 12
835  * \internal
836  * \brief Publish a \ref stasis message regarding the reload result
837  */
838 static void publish_reload_message(const char *name, enum ast_module_reload_result result)
839 {
840         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
841         RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
842         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
843         RAII_VAR(struct ast_json *, event_object, NULL, ast_json_unref);
844         char res_buffer[8];
845
846         if (!ast_manager_get_generic_type()) {
847                 return;
848         }
849
850         snprintf(res_buffer, sizeof(res_buffer), "%u", result);
851         event_object = ast_json_pack("{s: s, s: s}",
852                         "Module", S_OR(name, "All"),
853                         "Status", res_buffer);
854         json_object = ast_json_pack("{s: s, s: i, s: o}",
855                         "type", "Reload",
856                         "class_type", EVENT_FLAG_SYSTEM,
857                         "event", ast_json_ref(event_object));
858
859         if (!json_object) {
860                 return;
861         }
862
863         payload = ast_json_payload_create(json_object);
864         if (!payload) {
865                 return;
866         }
867
868         message = stasis_message_create(ast_manager_get_generic_type(), payload);
869         if (!message) {
870                 return;
871         }
872
873         stasis_publish(ast_manager_get_topic(), message);
874 }
875
876 enum ast_module_reload_result ast_module_reload(const char *name)
877 {
878         struct ast_module *cur;
879         enum ast_module_reload_result res = AST_MODULE_RELOAD_NOT_FOUND;
880         int i;
881
882         /* If we aren't fully booted, we just pretend we reloaded but we queue this
883            up to run once we are booted up. */
884         if (!modules_loaded) {
885                 queue_reload_request(name);
886                 res = AST_MODULE_RELOAD_QUEUED;
887                 goto module_reload_exit;
888         }
889
890         if (ast_mutex_trylock(&reloadlock)) {
891                 ast_verb(3, "The previous reload command didn't finish yet\n");
892                 res = AST_MODULE_RELOAD_IN_PROGRESS;
893                 goto module_reload_exit;
894         }
895         ast_sd_notify("RELOAD=1");
896         ast_lastreloadtime = ast_tvnow();
897
898         if (ast_opt_lock_confdir) {
899                 int try;
900                 int res;
901                 for (try = 1, res = AST_LOCK_TIMEOUT; try < 6 && (res == AST_LOCK_TIMEOUT); try++) {
902                         res = ast_lock_path(ast_config_AST_CONFIG_DIR);
903                         if (res == AST_LOCK_TIMEOUT) {
904                                 ast_log(LOG_WARNING, "Failed to grab lock on %s, try %d\n", ast_config_AST_CONFIG_DIR, try);
905                         }
906                 }
907                 if (res != AST_LOCK_SUCCESS) {
908                         ast_log(AST_LOG_WARNING, "Cannot grab lock on %s\n", ast_config_AST_CONFIG_DIR);
909                         res = AST_MODULE_RELOAD_ERROR;
910                         goto module_reload_done;
911                 }
912         }
913
914         /* Call "predefined" reload here first */
915         for (i = 0; reload_classes[i].name; i++) {
916                 if (!name || !strcasecmp(name, reload_classes[i].name)) {
917                         if (reload_classes[i].reload_fn() == AST_MODULE_LOAD_SUCCESS) {
918                                 res = AST_MODULE_RELOAD_SUCCESS;
919                         }
920                 }
921         }
922
923         if (name && res == AST_MODULE_RELOAD_SUCCESS) {
924                 if (ast_opt_lock_confdir) {
925                         ast_unlock_path(ast_config_AST_CONFIG_DIR);
926                 }
927                 goto module_reload_done;
928         }
929
930         AST_DLLIST_LOCK(&module_list);
931         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
932                 const struct ast_module_info *info = cur->info;
933
934                 if (name && resource_name_match(name, cur->resource))
935                         continue;
936
937                 if (!cur->flags.running || cur->flags.declined) {
938                         if (res == AST_MODULE_RELOAD_NOT_FOUND) {
939                                 res = AST_MODULE_RELOAD_UNINITIALIZED;
940                         }
941                         if (!name) {
942                                 continue;
943                         }
944                         break;
945                 }
946
947                 if (!info->reload) {    /* cannot be reloaded */
948                         if (res == AST_MODULE_RELOAD_NOT_FOUND) {
949                                 res = AST_MODULE_RELOAD_NOT_IMPLEMENTED;
950                         }
951                         if (!name) {
952                                 continue;
953                         }
954                         break;
955                 }
956                 ast_verb(3, "Reloading module '%s' (%s)\n", cur->resource, info->description);
957                 if (info->reload() == AST_MODULE_LOAD_SUCCESS) {
958                         res = AST_MODULE_RELOAD_SUCCESS;
959                 }
960                 if (name) {
961                         break;
962                 }
963         }
964         AST_DLLIST_UNLOCK(&module_list);
965
966         if (ast_opt_lock_confdir) {
967                 ast_unlock_path(ast_config_AST_CONFIG_DIR);
968         }
969 module_reload_done:
970         ast_mutex_unlock(&reloadlock);
971         ast_sd_notify("READY=1");
972
973 module_reload_exit:
974         publish_reload_message(name, res);
975         return res;
976 }
977
978 static unsigned int inspect_module(const struct ast_module *mod)
979 {
980         if (!mod->info->description) {
981                 ast_log(LOG_WARNING, "Module '%s' does not provide a description.\n", mod->resource);
982                 return 1;
983         }
984
985         if (!mod->info->key) {
986                 ast_log(LOG_WARNING, "Module '%s' does not provide a license key.\n", mod->resource);
987                 return 1;
988         }
989
990         if (verify_key((unsigned char *) mod->info->key)) {
991                 ast_log(LOG_WARNING, "Module '%s' did not provide a valid license key.\n", mod->resource);
992                 return 1;
993         }
994
995         if (!ast_strlen_zero(mod->info->buildopt_sum) &&
996             strcmp(buildopt_sum, mod->info->buildopt_sum)) {
997                 ast_log(LOG_WARNING, "Module '%s' was not compiled with the same compile-time options as this version of Asterisk.\n", mod->resource);
998                 ast_log(LOG_WARNING, "Module '%s' will not be initialized as it may cause instability.\n", mod->resource);
999                 return 1;
1000         }
1001
1002         return 0;
1003 }
1004
1005 static enum ast_module_load_result start_resource(struct ast_module *mod)
1006 {
1007         char tmp[256];
1008         enum ast_module_load_result res;
1009
1010         if (mod->flags.running) {
1011                 return AST_MODULE_LOAD_SUCCESS;
1012         }
1013
1014         if (!mod->info->load) {
1015                 return AST_MODULE_LOAD_FAILURE;
1016         }
1017
1018         if (!ast_fully_booted) {
1019                 ast_verb(1, "Loading %s.\n", mod->resource);
1020         }
1021         res = mod->info->load();
1022
1023         switch (res) {
1024         case AST_MODULE_LOAD_SUCCESS:
1025                 if (!ast_fully_booted) {
1026                         ast_verb(2, "%s => (%s)\n", mod->resource, term_color(tmp, mod->info->description, COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
1027                 } else {
1028                         ast_verb(1, "Loaded %s => (%s)\n", mod->resource, mod->info->description);
1029                 }
1030
1031                 mod->flags.running = 1;
1032
1033                 ast_update_use_count();
1034                 break;
1035         case AST_MODULE_LOAD_DECLINE:
1036                 mod->flags.declined = 1;
1037                 break;
1038         case AST_MODULE_LOAD_FAILURE:
1039         case AST_MODULE_LOAD_SKIP: /* modules should never return this value */
1040         case AST_MODULE_LOAD_PRIORITY:
1041                 break;
1042         }
1043
1044         /* Make sure the newly started module is at the end of the list */
1045         AST_DLLIST_LOCK(&module_list);
1046         AST_DLLIST_REMOVE(&module_list, mod, entry);
1047         AST_DLLIST_INSERT_TAIL(&module_list, mod, entry);
1048         AST_DLLIST_UNLOCK(&module_list);
1049
1050         return res;
1051 }
1052
1053 /*! loads a resource based upon resource_name. If global_symbols_only is set
1054  *  only modules with global symbols will be loaded.
1055  *
1056  *  If the ast_heap is provided (not NULL) the module is found and added to the
1057  *  heap without running the module's load() function.  By doing this, modules
1058  *  added to the resource_heap can be initialized later in order by priority.
1059  *
1060  *  If the ast_heap is not provided, the module's load function will be executed
1061  *  immediately */
1062 static enum ast_module_load_result load_resource(const char *resource_name, unsigned int global_symbols_only, unsigned int suppress_logging, struct ast_heap *resource_heap, int required)
1063 {
1064         struct ast_module *mod;
1065         enum ast_module_load_result res = AST_MODULE_LOAD_SUCCESS;
1066
1067         if ((mod = find_resource(resource_name, 0))) {
1068                 if (mod->flags.running) {
1069                         ast_log(LOG_WARNING, "Module '%s' already exists.\n", resource_name);
1070                         return AST_MODULE_LOAD_DECLINE;
1071                 }
1072                 if (global_symbols_only && !ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS))
1073                         return AST_MODULE_LOAD_SKIP;
1074         } else {
1075 #ifdef LOADABLE_MODULES
1076                 mod = load_dynamic_module(resource_name, global_symbols_only, suppress_logging, resource_heap);
1077                 if (mod == MODULE_LOCAL_ONLY) {
1078                                 return AST_MODULE_LOAD_SKIP;
1079                 }
1080                 if (!mod) {
1081                         if (!global_symbols_only) {
1082                                 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
1083                         }
1084                         return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1085                 }
1086 #else
1087                 ast_log(LOG_WARNING, "Module support is not available. Module '%s' could not be loaded.\n", resource_name);
1088                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1089 #endif
1090         }
1091
1092         if (inspect_module(mod)) {
1093                 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
1094 #ifdef LOADABLE_MODULES
1095                 unload_dynamic_module(mod);
1096 #endif
1097                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1098         }
1099
1100         if (!mod->lib && mod->info->backup_globals && mod->info->backup_globals()) {
1101                 ast_log(LOG_WARNING, "Module '%s' was unable to backup its global data.\n", resource_name);
1102                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
1103         }
1104
1105         mod->flags.declined = 0;
1106
1107         if (resource_heap) {
1108                 ast_heap_push(resource_heap, mod);
1109                 res = AST_MODULE_LOAD_PRIORITY;
1110         } else {
1111                 res = start_resource(mod);
1112         }
1113
1114         return res;
1115 }
1116
1117 int ast_load_resource(const char *resource_name)
1118 {
1119         int res;
1120         AST_DLLIST_LOCK(&module_list);
1121         res = load_resource(resource_name, 0, 0, NULL, 0);
1122         if (!res) {
1123                 ast_test_suite_event_notify("MODULE_LOAD", "Message: %s", resource_name);
1124         }
1125         AST_DLLIST_UNLOCK(&module_list);
1126
1127         return res;
1128 }
1129
1130 struct load_order_entry {
1131         char *resource;
1132         int required;
1133         AST_LIST_ENTRY(load_order_entry) entry;
1134 };
1135
1136 AST_LIST_HEAD_NOLOCK(load_order, load_order_entry);
1137
1138 static struct load_order_entry *add_to_load_order(const char *resource, struct load_order *load_order, int required)
1139 {
1140         struct load_order_entry *order;
1141
1142         AST_LIST_TRAVERSE(load_order, order, entry) {
1143                 if (!resource_name_match(order->resource, resource)) {
1144                         /* Make sure we have the proper setting for the required field
1145                            (we might have both load= and required= lines in modules.conf) */
1146                         order->required |= required;
1147                         return NULL;
1148                 }
1149         }
1150
1151         if (!(order = ast_calloc(1, sizeof(*order))))
1152                 return NULL;
1153
1154         order->resource = ast_strdup(resource);
1155         order->required = required;
1156         AST_LIST_INSERT_TAIL(load_order, order, entry);
1157
1158         return order;
1159 }
1160
1161 static int mod_load_cmp(void *a, void *b)
1162 {
1163         struct ast_module *a_mod = (struct ast_module *) a;
1164         struct ast_module *b_mod = (struct ast_module *) b;
1165         /* if load_pri is not set, default is 128.  Lower is better */
1166         int a_pri = ast_test_flag(a_mod->info, AST_MODFLAG_LOAD_ORDER) ? a_mod->info->load_pri : 128;
1167         int b_pri = ast_test_flag(b_mod->info, AST_MODFLAG_LOAD_ORDER) ? b_mod->info->load_pri : 128;
1168
1169         /*
1170          * Returns comparison values for a min-heap
1171          * <0 a_pri > b_pri
1172          * =0 a_pri == b_pri
1173          * >0 a_pri < b_pri
1174          */
1175         return b_pri - a_pri;
1176 }
1177
1178 AST_LIST_HEAD_NOLOCK(load_retries, load_order_entry);
1179
1180 /*! loads modules in order by load_pri, updates mod_count
1181         \return -1 on failure to load module, -2 on failure to load required module, otherwise 0
1182 */
1183 static int load_resource_list(struct load_order *load_order, unsigned int global_symbols, int *mod_count)
1184 {
1185         struct ast_heap *resource_heap;
1186         struct load_order_entry *order;
1187         struct ast_module *mod;
1188         struct load_retries load_retries;
1189         int count = 0;
1190         int res = 0;
1191         int i = 0;
1192 #define LOAD_RETRIES 4
1193
1194         AST_LIST_HEAD_INIT_NOLOCK(&load_retries);
1195
1196         if(!(resource_heap = ast_heap_create(8, mod_load_cmp, -1))) {
1197                 return -1;
1198         }
1199
1200         /* first, add find and add modules to heap */
1201         AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
1202                 enum ast_module_load_result lres;
1203
1204                 /* Suppress log messages unless this is the last pass */
1205                 lres = load_resource(order->resource, global_symbols, 1, resource_heap, order->required);
1206                 ast_debug(3, "PASS 0: %-46s %d %d\n", order->resource, lres, global_symbols);
1207                 switch (lres) {
1208                 case AST_MODULE_LOAD_SUCCESS:
1209                         /* We're supplying a heap so SUCCESS isn't possible but we still have to test for it. */
1210                         break;
1211                 case AST_MODULE_LOAD_FAILURE:
1212                 case AST_MODULE_LOAD_DECLINE:
1213                         /*
1214                          * DECLINE or FAILURE means there was an issue with dlopen or module_register
1215                          * which might be retryable.  LOAD_FAILURE only happens for required modules
1216                          * but we're still going to retry.  We need to remove the entry from the
1217                          * load_order list and add it to the load_retries list.
1218                          */
1219                         AST_LIST_REMOVE_CURRENT(entry);
1220                         AST_LIST_INSERT_TAIL(&load_retries, order, entry);
1221                         break;
1222                 case AST_MODULE_LOAD_SKIP:
1223                         /*
1224                          * SKIP means that dlopen worked but global_symbols was set and this module doesn't qualify.
1225                          * Leave it in load_order for the next call of load_resource_list.
1226                          */
1227                         break;
1228                 case AST_MODULE_LOAD_PRIORITY:
1229                         /* load_resource worked and the module was added to the priority heap */
1230                         AST_LIST_REMOVE_CURRENT(entry);
1231                         ast_free(order->resource);
1232                         ast_free(order);
1233                         break;
1234                 }
1235         }
1236         AST_LIST_TRAVERSE_SAFE_END;
1237
1238         /* Retry the failures until the list is empty or we reach LOAD_RETRIES */
1239         for (i = 0; !AST_LIST_EMPTY(&load_retries) && i < LOAD_RETRIES; i++) {
1240                 AST_LIST_TRAVERSE_SAFE_BEGIN(&load_retries, order, entry) {
1241                         enum ast_module_load_result lres;
1242
1243                         /* Suppress log messages unless this is the last pass */
1244                         lres = load_resource(order->resource, global_symbols, (i < LOAD_RETRIES - 1), resource_heap, order->required);
1245                         ast_debug(3, "PASS %d %-46s %d %d\n", i + 1, order->resource, lres, global_symbols);
1246                         switch (lres) {
1247                         /* These are all retryable. */
1248                         case AST_MODULE_LOAD_SUCCESS:
1249                         case AST_MODULE_LOAD_DECLINE:
1250                                 break;
1251                         case AST_MODULE_LOAD_FAILURE:
1252                                 /* LOAD_FAILURE only happens for required modules */
1253                                 if (i == LOAD_RETRIES - 1) {
1254                                         /* This was the last chance to load a required module*/
1255                                         ast_log(LOG_ERROR, "*** Failed to load module %s - Required\n", order->resource);
1256                                         fprintf(stderr, "*** Failed to load module %s - Required\n", order->resource);
1257                                         res =  -2;
1258                                         goto done;
1259                                 }
1260                                 break;;
1261                         case AST_MODULE_LOAD_SKIP:
1262                                 /*
1263                                  * SKIP means that dlopen worked but global_symbols was set and this module
1264                                  * doesn't qualify.  Put it back in load_order for the next call of
1265                                  * load_resource_list.
1266                                  */
1267                                 AST_LIST_REMOVE_CURRENT(entry);
1268                                 AST_LIST_INSERT_TAIL(load_order, order, entry);
1269                                 break;
1270                         case AST_MODULE_LOAD_PRIORITY:
1271                                 /* load_resource worked and the module was added to the priority heap */
1272                                 AST_LIST_REMOVE_CURRENT(entry);
1273                                 ast_free(order->resource);
1274                                 ast_free(order);
1275                                 break;
1276                         }
1277                 }
1278                 AST_LIST_TRAVERSE_SAFE_END;
1279         }
1280
1281         /* second remove modules from heap sorted by priority */
1282         while ((mod = ast_heap_pop(resource_heap))) {
1283                 enum ast_module_load_result lres;
1284
1285                 lres = start_resource(mod);
1286                 ast_debug(3, "START: %-46s %d %d\n", mod->resource, lres, global_symbols);
1287                 switch (lres) {
1288                 case AST_MODULE_LOAD_SUCCESS:
1289                         count++;
1290                 case AST_MODULE_LOAD_DECLINE:
1291                         break;
1292                 case AST_MODULE_LOAD_FAILURE:
1293                         res = -1;
1294                         goto done;
1295                 case AST_MODULE_LOAD_SKIP:
1296                 case AST_MODULE_LOAD_PRIORITY:
1297                         break;
1298                 }
1299         }
1300
1301 done:
1302
1303         while ((order = AST_LIST_REMOVE_HEAD(&load_retries, entry))) {
1304                 ast_free(order->resource);
1305                 ast_free(order);
1306         }
1307
1308         if (mod_count) {
1309                 *mod_count += count;
1310         }
1311         ast_heap_destroy(resource_heap);
1312
1313         return res;
1314 }
1315
1316 int load_modules(unsigned int preload_only)
1317 {
1318         struct ast_config *cfg;
1319         struct ast_module *mod;
1320         struct load_order_entry *order;
1321         struct ast_variable *v;
1322         unsigned int load_count;
1323         struct load_order load_order;
1324         int res = 0;
1325         struct ast_flags config_flags = { 0 };
1326         int modulecount = 0;
1327
1328 #ifdef LOADABLE_MODULES
1329         struct dirent *dirent;
1330         DIR *dir;
1331 #endif
1332
1333         /* all embedded modules have registered themselves by now */
1334         embedding = 0;
1335
1336         ast_verb(1, "Asterisk Dynamic Loader Starting:\n");
1337
1338         AST_LIST_HEAD_INIT_NOLOCK(&load_order);
1339
1340         AST_DLLIST_LOCK(&module_list);
1341
1342         if (embedded_module_list.first) {
1343                 module_list.first = embedded_module_list.first;
1344                 module_list.last = embedded_module_list.last;
1345                 embedded_module_list.first = NULL;
1346         }
1347
1348         cfg = ast_config_load2(AST_MODULE_CONFIG, "" /* core, can't reload */, config_flags);
1349         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
1350                 ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
1351                 goto done;
1352         }
1353
1354         /* first, find all the modules we have been explicitly requested to load */
1355         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
1356                 if (!strcasecmp(v->name, preload_only ? "preload" : "load")) {
1357                         add_to_load_order(v->value, &load_order, 0);
1358                 }
1359                 if (!strcasecmp(v->name, preload_only ? "preload-require" : "require")) {
1360                         /* Add the module to the list and make sure it's required */
1361                         add_to_load_order(v->value, &load_order, 1);
1362                         ast_debug(2, "Adding module to required list: %s (%s)\n", v->value, v->name);
1363                 }
1364
1365         }
1366
1367         /* check if 'autoload' is on */
1368         if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
1369                 /* if so, first add all the embedded modules that are not already running to the load order */
1370                 AST_DLLIST_TRAVERSE(&module_list, mod, entry) {
1371                         /* if it's not embedded, skip it */
1372                         if (mod->lib)
1373                                 continue;
1374
1375                         if (mod->flags.running)
1376                                 continue;
1377
1378                         add_to_load_order(mod->resource, &load_order, 0);
1379                 }
1380
1381 #ifdef LOADABLE_MODULES
1382                 /* if we are allowed to load dynamic modules, scan the directory for
1383                    for all available modules and add them as well */
1384                 if ((dir = opendir(ast_config_AST_MODULE_DIR))) {
1385                         while ((dirent = readdir(dir))) {
1386                                 int ld = strlen(dirent->d_name);
1387
1388                                 /* Must end in .so to load it.  */
1389
1390                                 if (ld < 4)
1391                                         continue;
1392
1393                                 if (strcasecmp(dirent->d_name + ld - 3, ".so"))
1394                                         continue;
1395
1396                                 /* if there is already a module by this name in the module_list,
1397                                    skip this file */
1398                                 if (find_resource(dirent->d_name, 0))
1399                                         continue;
1400
1401                                 add_to_load_order(dirent->d_name, &load_order, 0);
1402                         }
1403
1404                         closedir(dir);
1405                 } else {
1406                         if (!ast_opt_quiet)
1407                                 ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
1408                                         ast_config_AST_MODULE_DIR);
1409                 }
1410 #endif
1411         }
1412
1413         /* now scan the config for any modules we are prohibited from loading and
1414            remove them from the load order */
1415         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
1416                 if (strcasecmp(v->name, "noload"))
1417                         continue;
1418
1419                 AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
1420                         if (!resource_name_match(order->resource, v->value)) {
1421                                 AST_LIST_REMOVE_CURRENT(entry);
1422                                 ast_free(order->resource);
1423                                 ast_free(order);
1424                         }
1425                 }
1426                 AST_LIST_TRAVERSE_SAFE_END;
1427         }
1428
1429         /* we are done with the config now, all the information we need is in the
1430            load_order list */
1431         ast_config_destroy(cfg);
1432
1433         load_count = 0;
1434         AST_LIST_TRAVERSE(&load_order, order, entry)
1435                 load_count++;
1436
1437         if (load_count)
1438                 ast_log(LOG_NOTICE, "%u modules will be loaded.\n", load_count);
1439
1440         /* first, load only modules that provide global symbols */
1441         if ((res = load_resource_list(&load_order, 1, &modulecount)) < 0) {
1442                 goto done;
1443         }
1444
1445         /* now load everything else */
1446         if ((res = load_resource_list(&load_order, 0, &modulecount)) < 0) {
1447                 goto done;
1448         }
1449
1450 done:
1451         while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
1452                 ast_free(order->resource);
1453                 ast_free(order);
1454         }
1455
1456         AST_DLLIST_UNLOCK(&module_list);
1457         return res;
1458 }
1459
1460 void ast_update_use_count(void)
1461 {
1462         /* Notify any module monitors that the use count for a
1463            resource has changed */
1464         struct loadupdate *m;
1465
1466         AST_LIST_LOCK(&updaters);
1467         AST_LIST_TRAVERSE(&updaters, m, entry)
1468                 m->updater();
1469         AST_LIST_UNLOCK(&updaters);
1470 }
1471
1472 int ast_update_module_list(int (*modentry)(const char *module, const char *description,
1473                                            int usecnt, const char *status, const char *like,
1474                                                                                    enum ast_module_support_level support_level),
1475                            const char *like)
1476 {
1477         struct ast_module *cur;
1478         int unlock = -1;
1479         int total_mod_loaded = 0;
1480         AST_LIST_HEAD_NOLOCK(, ast_module) alpha_module_list = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
1481
1482         if (AST_DLLIST_TRYLOCK(&module_list)) {
1483                 unlock = 0;
1484         }
1485
1486         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
1487                 AST_LIST_INSERT_SORTALPHA(&alpha_module_list, cur, list_entry, resource);
1488         }
1489
1490         while ((cur = AST_LIST_REMOVE_HEAD(&alpha_module_list, list_entry))) {
1491                 total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount,
1492                                                 cur->flags.running ? "Running" : "Not Running", like, cur->info->support_level);
1493         }
1494
1495         if (unlock) {
1496                 AST_DLLIST_UNLOCK(&module_list);
1497         }
1498
1499         return total_mod_loaded;
1500 }
1501
1502 int ast_update_module_list_data(int (*modentry)(const char *module, const char *description,
1503                                                 int usecnt, const char *status, const char *like,
1504                                                 enum ast_module_support_level support_level,
1505                                                 void *data),
1506                                 const char *like, void *data)
1507 {
1508         struct ast_module *cur;
1509         int total_mod_loaded = 0;
1510         AST_LIST_HEAD_NOLOCK(, ast_module) alpha_module_list = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
1511
1512         AST_DLLIST_LOCK(&module_list);
1513
1514         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
1515                 AST_LIST_INSERT_SORTALPHA(&alpha_module_list, cur, list_entry, resource);
1516         }
1517
1518         while ((cur = AST_LIST_REMOVE_HEAD(&alpha_module_list, list_entry))) {
1519                 total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount,
1520                         cur->flags.running? "Running" : "Not Running", like, cur->info->support_level, data);
1521         }
1522
1523         AST_DLLIST_UNLOCK(&module_list);
1524
1525         return total_mod_loaded;
1526 }
1527
1528 int ast_update_module_list_condition(int (*modentry)(const char *module, const char *description,
1529                                                      int usecnt, const char *status,
1530                                                      const char *like,
1531                                                      enum ast_module_support_level support_level,
1532                                                      void *data, const char *condition),
1533                                      const char *like, void *data, const char *condition)
1534 {
1535         struct ast_module *cur;
1536         int conditions_met = 0;
1537         AST_LIST_HEAD_NOLOCK(, ast_module) alpha_module_list = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
1538
1539         AST_DLLIST_LOCK(&module_list);
1540
1541         AST_DLLIST_TRAVERSE(&module_list, cur, entry) {
1542                 AST_LIST_INSERT_SORTALPHA(&alpha_module_list, cur, list_entry, resource);
1543         }
1544
1545         while ((cur = AST_LIST_REMOVE_HEAD(&alpha_module_list, list_entry))) {
1546                 conditions_met += modentry(cur->resource, cur->info->description, cur->usecount,
1547                         cur->flags.running? "Running" : "Not Running", like, cur->info->support_level, data,
1548                         condition);
1549         }
1550
1551         AST_DLLIST_UNLOCK(&module_list);
1552
1553         return conditions_met;
1554 }
1555
1556 /*! \brief Check if module exists */
1557 int ast_module_check(const char *name)
1558 {
1559         struct ast_module *cur;
1560
1561         if (ast_strlen_zero(name))
1562                 return 0;       /* FALSE */
1563
1564         cur = find_resource(name, 1);
1565
1566         return (cur != NULL);
1567 }
1568
1569
1570 int ast_loader_register(int (*v)(void))
1571 {
1572         struct loadupdate *tmp;
1573
1574         if (!(tmp = ast_malloc(sizeof(*tmp))))
1575                 return -1;
1576
1577         tmp->updater = v;
1578         AST_LIST_LOCK(&updaters);
1579         AST_LIST_INSERT_HEAD(&updaters, tmp, entry);
1580         AST_LIST_UNLOCK(&updaters);
1581
1582         return 0;
1583 }
1584
1585 int ast_loader_unregister(int (*v)(void))
1586 {
1587         struct loadupdate *cur;
1588
1589         AST_LIST_LOCK(&updaters);
1590         AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, entry) {
1591                 if (cur->updater == v)  {
1592                         AST_LIST_REMOVE_CURRENT(entry);
1593                         break;
1594                 }
1595         }
1596         AST_LIST_TRAVERSE_SAFE_END;
1597         AST_LIST_UNLOCK(&updaters);
1598
1599         return cur ? 0 : -1;
1600 }
1601
1602 struct ast_module *__ast_module_ref(struct ast_module *mod, const char *file, int line, const char *func)
1603 {
1604         if (!mod) {
1605                 return NULL;
1606         }
1607
1608         if (mod->ref_debug) {
1609                 __ao2_ref(mod->ref_debug, +1, "", file, line, func);
1610         }
1611
1612         ast_atomic_fetchadd_int(&mod->usecount, +1);
1613         ast_update_use_count();
1614
1615         return mod;
1616 }
1617
1618 void __ast_module_shutdown_ref(struct ast_module *mod, const char *file, int line, const char *func)
1619 {
1620         if (!mod || mod->flags.keepuntilshutdown) {
1621                 return;
1622         }
1623
1624         __ast_module_ref(mod, file, line, func);
1625         mod->flags.keepuntilshutdown = 1;
1626 }
1627
1628 void __ast_module_unref(struct ast_module *mod, const char *file, int line, const char *func)
1629 {
1630         if (!mod) {
1631                 return;
1632         }
1633
1634         if (mod->ref_debug) {
1635                 __ao2_ref(mod->ref_debug, -1, "", file, line, func);
1636         }
1637
1638         ast_atomic_fetchadd_int(&mod->usecount, -1);
1639         ast_update_use_count();
1640 }
1641
1642 const char *support_level_map [] = {
1643         [AST_MODULE_SUPPORT_UNKNOWN] = "unknown",
1644         [AST_MODULE_SUPPORT_CORE] = "core",
1645         [AST_MODULE_SUPPORT_EXTENDED] = "extended",
1646         [AST_MODULE_SUPPORT_DEPRECATED] = "deprecated",
1647 };
1648
1649 const char *ast_module_support_level_to_string(enum ast_module_support_level support_level)
1650 {
1651         return support_level_map[support_level];
1652 }