Named ACLs: Introduces a system for creating and sharing ACLs
[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 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
37
38 #include "asterisk/_private.h"
39 #include "asterisk/paths.h"     /* use ast_config_AST_MODULE_DIR */
40 #include <dirent.h>
41
42 #include "asterisk/linkedlists.h"
43 #include "asterisk/module.h"
44 #include "asterisk/config.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/term.h"
47 #include "asterisk/acl.h"
48 #include "asterisk/manager.h"
49 #include "asterisk/cdr.h"
50 #include "asterisk/enum.h"
51 #include "asterisk/http.h"
52 #include "asterisk/lock.h"
53 #include "asterisk/features.h"
54 #include "asterisk/dsp.h"
55 #include "asterisk/udptl.h"
56 #include "asterisk/heap.h"
57 #include "asterisk/app.h"
58
59 #include <dlfcn.h>
60
61 #include "asterisk/md5.h"
62 #include "asterisk/utils.h"
63
64 /*** DOCUMENTATION
65  ***/
66
67 #ifndef RTLD_NOW
68 #define RTLD_NOW 0
69 #endif
70
71 #ifndef RTLD_LOCAL
72 #define RTLD_LOCAL 0
73 #endif
74
75 struct ast_module_user {
76         struct ast_channel *chan;
77         AST_LIST_ENTRY(ast_module_user) entry;
78 };
79
80 AST_LIST_HEAD(module_user_list, ast_module_user);
81
82 static const unsigned char expected_key[] =
83 { 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3,
84   0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 };
85
86 static char buildopt_sum[33] = AST_BUILDOPT_SUM;
87
88 static unsigned int embedding = 1; /* we always start out by registering embedded modules,
89                                       since they are here before we dlopen() any
90                                    */
91
92 struct ast_module {
93         const struct ast_module_info *info;
94         void *lib;                                      /* the shared lib, or NULL if embedded */
95         int usecount;                                   /* the number of 'users' currently in this module */
96         struct module_user_list users;                  /* the list of users in the module */
97         struct {
98                 unsigned int running:1;
99                 unsigned int declined:1;
100         } flags;
101         AST_LIST_ENTRY(ast_module) entry;
102         char resource[0];
103 };
104
105 static AST_LIST_HEAD_STATIC(module_list, ast_module);
106
107 const char *ast_module_name(const struct ast_module *mod)
108 {
109         if (!mod || !mod->info) {
110                 return NULL;
111         }
112
113         return mod->info->name;
114 }
115
116 /*
117  * module_list is cleared by its constructor possibly after
118  * we start accumulating embedded modules, so we need to
119  * use another list (without the lock) to accumulate them.
120  * Then we update the main list when embedding is done.
121  */
122 static struct module_list embedded_module_list;
123
124 struct loadupdate {
125         int (*updater)(void);
126         AST_LIST_ENTRY(loadupdate) entry;
127 };
128
129 static AST_LIST_HEAD_STATIC(updaters, loadupdate);
130
131 AST_MUTEX_DEFINE_STATIC(reloadlock);
132
133 struct reload_queue_item {
134         AST_LIST_ENTRY(reload_queue_item) entry;
135         char module[0];
136 };
137
138 static int do_full_reload = 0;
139
140 static AST_LIST_HEAD_STATIC(reload_queue, reload_queue_item);
141
142 /* when dynamic modules are being loaded, ast_module_register() will
143    need to know what filename the module was loaded from while it
144    is being registered
145 */
146 static struct ast_module *resource_being_loaded;
147
148 /* XXX: should we check for duplicate resource names here? */
149
150 void ast_module_register(const struct ast_module_info *info)
151 {
152         struct ast_module *mod;
153
154         if (embedding) {
155                 if (!(mod = ast_calloc(1, sizeof(*mod) + strlen(info->name) + 1)))
156                         return;
157                 strcpy(mod->resource, info->name);
158         } else {
159                 mod = resource_being_loaded;
160         }
161
162         mod->info = info;
163         AST_LIST_HEAD_INIT(&mod->users);
164
165         /* during startup, before the loader has been initialized,
166            there are no threads, so there is no need to take the lock
167            on this list to manipulate it. it is also possible that it
168            might be unsafe to use the list lock at that point... so
169            let's avoid it altogether
170         */
171         if (embedding) {
172                 AST_LIST_INSERT_TAIL(&embedded_module_list, mod, entry);
173         } else {
174                 AST_LIST_LOCK(&module_list);
175                 /* it is paramount that the new entry be placed at the tail of
176                    the list, otherwise the code that uses dlopen() to load
177                    dynamic modules won't be able to find out if the module it
178                    just opened was registered or failed to load
179                 */
180                 AST_LIST_INSERT_TAIL(&module_list, mod, entry);
181                 AST_LIST_UNLOCK(&module_list);
182         }
183
184         /* give the module a copy of its own handle, for later use in registrations and the like */
185         *((struct ast_module **) &(info->self)) = mod;
186 }
187
188 void ast_module_unregister(const struct ast_module_info *info)
189 {
190         struct ast_module *mod = NULL;
191
192         /* it is assumed that the users list in the module structure
193            will already be empty, or we cannot have gotten to this
194            point
195         */
196         AST_LIST_LOCK(&module_list);
197         AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, mod, entry) {
198                 if (mod->info == info) {
199                         AST_LIST_REMOVE_CURRENT(entry);
200                         break;
201                 }
202         }
203         AST_LIST_TRAVERSE_SAFE_END;
204         AST_LIST_UNLOCK(&module_list);
205
206         if (mod) {
207                 AST_LIST_HEAD_DESTROY(&mod->users);
208                 ast_free(mod);
209         }
210 }
211
212 struct ast_module_user *__ast_module_user_add(struct ast_module *mod,
213                                               struct ast_channel *chan)
214 {
215         struct ast_module_user *u = ast_calloc(1, sizeof(*u));
216
217         if (!u)
218                 return NULL;
219
220         u->chan = chan;
221
222         AST_LIST_LOCK(&mod->users);
223         AST_LIST_INSERT_HEAD(&mod->users, u, entry);
224         AST_LIST_UNLOCK(&mod->users);
225
226         ast_atomic_fetchadd_int(&mod->usecount, +1);
227
228         ast_update_use_count();
229
230         return u;
231 }
232
233 void __ast_module_user_remove(struct ast_module *mod, struct ast_module_user *u)
234 {
235         AST_LIST_LOCK(&mod->users);
236         AST_LIST_REMOVE(&mod->users, u, entry);
237         AST_LIST_UNLOCK(&mod->users);
238         ast_atomic_fetchadd_int(&mod->usecount, -1);
239         ast_free(u);
240
241         ast_update_use_count();
242 }
243
244 void __ast_module_user_hangup_all(struct ast_module *mod)
245 {
246         struct ast_module_user *u;
247
248         AST_LIST_LOCK(&mod->users);
249         while ((u = AST_LIST_REMOVE_HEAD(&mod->users, entry))) {
250                 if (u->chan) {
251                         ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
252                 }
253                 ast_atomic_fetchadd_int(&mod->usecount, -1);
254                 ast_free(u);
255         }
256         AST_LIST_UNLOCK(&mod->users);
257
258         ast_update_use_count();
259 }
260
261 /*! \note
262  * In addition to modules, the reload command handles some extra keywords
263  * which are listed here together with the corresponding handlers.
264  * This table is also used by the command completion code.
265  */
266 static struct reload_classes {
267         const char *name;
268         int (*reload_fn)(void);
269 } reload_classes[] = {  /* list in alpha order, longest match first for cli completion */
270         { "cdr",        ast_cdr_engine_reload },
271         { "dnsmgr",     dnsmgr_reload },
272         { "extconfig",  read_config_maps },
273         { "enum",       ast_enum_reload },
274         { "acl",        ast_named_acl_reload },
275         { "manager",    reload_manager },
276         { "http",       ast_http_reload },
277         { "logger",     logger_reload },
278         { "features",   ast_features_reload },
279         { "dsp",        ast_dsp_reload},
280         { "udptl",      ast_udptl_reload },
281         { "indications", ast_indications_reload },
282         { "cel",        ast_cel_engine_reload },
283         { "plc",        ast_plc_reload },
284         { NULL,         NULL }
285 };
286
287 static int printdigest(const unsigned char *d)
288 {
289         int x, pos;
290         char buf[256]; /* large enough so we don't have to worry */
291
292         for (pos = 0, x = 0; x < 16; x++)
293                 pos += sprintf(buf + pos, " %02x", *d++);
294
295         ast_debug(1, "Unexpected signature:%s\n", buf);
296
297         return 0;
298 }
299
300 static int key_matches(const unsigned char *key1, const unsigned char *key2)
301 {
302         int x;
303
304         for (x = 0; x < 16; x++) {
305                 if (key1[x] != key2[x])
306                         return 0;
307         }
308
309         return 1;
310 }
311
312 static int verify_key(const unsigned char *key)
313 {
314         struct MD5Context c;
315         unsigned char digest[16];
316
317         MD5Init(&c);
318         MD5Update(&c, key, strlen((char *)key));
319         MD5Final(digest, &c);
320
321         if (key_matches(expected_key, digest))
322                 return 0;
323
324         printdigest(digest);
325
326         return -1;
327 }
328
329 static int resource_name_match(const char *name1_in, const char *name2_in)
330 {
331         char *name1 = (char *) name1_in;
332         char *name2 = (char *) name2_in;
333
334         /* trim off any .so extensions */
335         if (!strcasecmp(name1 + strlen(name1) - 3, ".so")) {
336                 name1 = ast_strdupa(name1);
337                 name1[strlen(name1) - 3] = '\0';
338         }
339         if (!strcasecmp(name2 + strlen(name2) - 3, ".so")) {
340                 name2 = ast_strdupa(name2);
341                 name2[strlen(name2) - 3] = '\0';
342         }
343
344         return strcasecmp(name1, name2);
345 }
346
347 static struct ast_module *find_resource(const char *resource, int do_lock)
348 {
349         struct ast_module *cur;
350
351         if (do_lock)
352                 AST_LIST_LOCK(&module_list);
353
354         AST_LIST_TRAVERSE(&module_list, cur, entry) {
355                 if (!resource_name_match(resource, cur->resource))
356                         break;
357         }
358
359         if (do_lock)
360                 AST_LIST_UNLOCK(&module_list);
361
362         return cur;
363 }
364
365 #ifdef LOADABLE_MODULES
366 static void unload_dynamic_module(struct ast_module *mod)
367 {
368         void *lib = mod->lib;
369
370         /* WARNING: the structure pointed to by mod is going to
371            disappear when this operation succeeds, so we can't
372            dereference it */
373
374         if (lib)
375                 while (!dlclose(lib));
376 }
377
378 static struct ast_module *load_dynamic_module(const char *resource_in, unsigned int global_symbols_only)
379 {
380         char fn[PATH_MAX] = "";
381         void *lib = NULL;
382         struct ast_module *mod;
383         unsigned int wants_global;
384         int space;      /* room needed for the descriptor */
385         int missing_so = 0;
386
387         space = sizeof(*resource_being_loaded) + strlen(resource_in) + 1;
388         if (strcasecmp(resource_in + strlen(resource_in) - 3, ".so")) {
389                 missing_so = 1;
390                 space += 3;     /* room for the extra ".so" */
391         }
392
393         snprintf(fn, sizeof(fn), "%s/%s%s", ast_config_AST_MODULE_DIR, resource_in, missing_so ? ".so" : "");
394
395         /* make a first load of the module in 'quiet' mode... don't try to resolve
396            any symbols, and don't export any symbols. this will allow us to peek into
397            the module's info block (if available) to see what flags it has set */
398
399         resource_being_loaded = ast_calloc(1, space);
400         if (!resource_being_loaded)
401                 return NULL;
402         strcpy(resource_being_loaded->resource, resource_in);
403         if (missing_so)
404                 strcat(resource_being_loaded->resource, ".so");
405
406         if (!(lib = dlopen(fn, RTLD_LAZY | RTLD_LOCAL))) {
407                 ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
408                 ast_free(resource_being_loaded);
409                 return NULL;
410         }
411
412         /* the dlopen() succeeded, let's find out if the module
413            registered itself */
414         /* note that this will only work properly as long as
415            ast_module_register() (which is called by the module's
416            constructor) places the new module at the tail of the
417            module_list
418         */
419         if (resource_being_loaded != (mod = AST_LIST_LAST(&module_list))) {
420                 ast_log(LOG_WARNING, "Module '%s' did not register itself during load\n", resource_in);
421                 /* no, it did not, so close it and return */
422                 while (!dlclose(lib));
423                 /* note that the module's destructor will call ast_module_unregister(),
424                    which will free the structure we allocated in resource_being_loaded */
425                 return NULL;
426         }
427
428         wants_global = ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS);
429
430         /* if we are being asked only to load modules that provide global symbols,
431            and this one does not, then close it and return */
432         if (global_symbols_only && !wants_global) {
433                 while (!dlclose(lib));
434                 return NULL;
435         }
436
437         /* This section is a workaround for a gcc 4.1 bug that has already been
438          * fixed in later versions.  Unfortunately, some distributions, such as
439          * RHEL/CentOS 5, distribute gcc 4.1, so we're stuck with having to deal
440          * with this issue.  This basically ensures that optional_api modules are
441          * loaded before any module which requires their functionality. */
442 #if !defined(HAVE_ATTRIBUTE_weak_import) && !defined(HAVE_ATTRIBUTE_weakref)
443         if (!ast_strlen_zero(mod->info->nonoptreq)) {
444                 /* Force any required dependencies to load */
445                 char *each, *required_resource = ast_strdupa(mod->info->nonoptreq);
446                 while ((each = strsep(&required_resource, ","))) {
447                         each = ast_strip(each);
448
449                         /* Is it already loaded? */
450                         if (!find_resource(each, 0)) {
451                                 load_dynamic_module(each, global_symbols_only);
452                         }
453                 }
454         }
455 #endif
456
457         while (!dlclose(lib));
458         resource_being_loaded = NULL;
459
460         /* start the load process again */
461         resource_being_loaded = ast_calloc(1, space);
462         if (!resource_being_loaded)
463                 return NULL;
464         strcpy(resource_being_loaded->resource, resource_in);
465         if (missing_so)
466                 strcat(resource_being_loaded->resource, ".so");
467
468         if (!(lib = dlopen(fn, wants_global ? RTLD_LAZY | RTLD_GLOBAL : RTLD_NOW | RTLD_LOCAL))) {
469                 ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
470                 ast_free(resource_being_loaded);
471                 return NULL;
472         }
473
474         /* since the module was successfully opened, and it registered itself
475            the previous time we did that, we're going to assume it worked this
476            time too :) */
477
478         AST_LIST_LAST(&module_list)->lib = lib;
479         resource_being_loaded = NULL;
480
481         return AST_LIST_LAST(&module_list);
482 }
483 #endif
484
485 void ast_module_shutdown(void)
486 {
487         struct ast_module *mod;
488         int somethingchanged = 1, final = 0;
489
490         AST_LIST_LOCK(&module_list);
491
492         /*!\note Some resources, like timers, are started up dynamically, and thus
493          * may be still in use, even if all channels are dead.  We must therefore
494          * check the usecount before asking modules to unload. */
495         do {
496                 if (!somethingchanged) {
497                         /*!\note If we go through the entire list without changing
498                          * anything, ignore the usecounts and unload, then exit. */
499                         final = 1;
500                 }
501
502                 /* Reset flag before traversing the list */
503                 somethingchanged = 0;
504
505                 AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, mod, entry) {
506                         if (!final && mod->usecount) {
507                                 continue;
508                         }
509                         AST_LIST_REMOVE_CURRENT(entry);
510                         if (mod->flags.running && !mod->flags.declined && mod->info->unload) {
511                                 mod->info->unload();
512                         }
513                         AST_LIST_HEAD_DESTROY(&mod->users);
514                         free(mod);
515                         somethingchanged = 1;
516                 }
517                 AST_LIST_TRAVERSE_SAFE_END;
518         } while (somethingchanged && !final);
519
520         AST_LIST_UNLOCK(&module_list);
521 }
522
523 int ast_unload_resource(const char *resource_name, enum ast_module_unload_mode force)
524 {
525         struct ast_module *mod;
526         int res = -1;
527         int error = 0;
528
529         AST_LIST_LOCK(&module_list);
530
531         if (!(mod = find_resource(resource_name, 0))) {
532                 AST_LIST_UNLOCK(&module_list);
533                 ast_log(LOG_WARNING, "Unload failed, '%s' could not be found\n", resource_name);
534                 return -1;
535         }
536
537         if (!mod->flags.running || mod->flags.declined) {
538                 ast_log(LOG_WARNING, "Unload failed, '%s' is not loaded.\n", resource_name);
539                 error = 1;
540         }
541
542         if (!error && (mod->usecount > 0)) {
543                 if (force)
544                         ast_log(LOG_WARNING, "Warning:  Forcing removal of module '%s' with use count %d\n",
545                                 resource_name, mod->usecount);
546                 else {
547                         ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name,
548                                 mod->usecount);
549                         error = 1;
550                 }
551         }
552
553         if (!error) {
554                 __ast_module_user_hangup_all(mod);
555                 res = mod->info->unload();
556
557                 if (res) {
558                         ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
559                         if (force <= AST_FORCE_FIRM)
560                                 error = 1;
561                         else
562                                 ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
563                 }
564         }
565
566         if (!error)
567                 mod->flags.running = mod->flags.declined = 0;
568
569         AST_LIST_UNLOCK(&module_list);
570
571         if (!error && !mod->lib && mod->info && mod->info->restore_globals)
572                 mod->info->restore_globals();
573
574 #ifdef LOADABLE_MODULES
575         if (!error)
576                 unload_dynamic_module(mod);
577 #endif
578
579         if (!error)
580                 ast_update_use_count();
581
582         return res;
583 }
584
585 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload)
586 {
587         struct ast_module *cur;
588         int i, which=0, l = strlen(word);
589         char *ret = NULL;
590
591         if (pos != rpos)
592                 return NULL;
593
594         AST_LIST_LOCK(&module_list);
595         AST_LIST_TRAVERSE(&module_list, cur, entry) {
596                 if (!strncasecmp(word, cur->resource, l) &&
597                     (cur->info->reload || !needsreload) &&
598                     ++which > state) {
599                         ret = ast_strdup(cur->resource);
600                         break;
601                 }
602         }
603         AST_LIST_UNLOCK(&module_list);
604
605         if (!ret) {
606                 for (i=0; !ret && reload_classes[i].name; i++) {
607                         if (!strncasecmp(word, reload_classes[i].name, l) && ++which > state)
608                                 ret = ast_strdup(reload_classes[i].name);
609                 }
610         }
611
612         return ret;
613 }
614
615 void ast_process_pending_reloads(void)
616 {
617         struct reload_queue_item *item;
618
619         if (!ast_fully_booted) {
620                 return;
621         }
622
623         AST_LIST_LOCK(&reload_queue);
624
625         if (do_full_reload) {
626                 do_full_reload = 0;
627                 AST_LIST_UNLOCK(&reload_queue);
628                 ast_log(LOG_NOTICE, "Executing deferred reload request.\n");
629                 ast_module_reload(NULL);
630                 return;
631         }
632
633         while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
634                 ast_log(LOG_NOTICE, "Executing deferred reload request for module '%s'.\n", item->module);
635                 ast_module_reload(item->module);
636                 ast_free(item);
637         }
638
639         AST_LIST_UNLOCK(&reload_queue);
640 }
641
642 static void queue_reload_request(const char *module)
643 {
644         struct reload_queue_item *item;
645
646         AST_LIST_LOCK(&reload_queue);
647
648         if (do_full_reload) {
649                 AST_LIST_UNLOCK(&reload_queue);
650                 return;
651         }
652
653         if (ast_strlen_zero(module)) {
654                 /* A full reload request (when module is NULL) wipes out any previous
655                    reload requests and causes the queue to ignore future ones */
656                 while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
657                         ast_free(item);
658                 }
659                 do_full_reload = 1;
660         } else {
661                 /* No reason to add the same module twice */
662                 AST_LIST_TRAVERSE(&reload_queue, item, entry) {
663                         if (!strcasecmp(item->module, module)) {
664                                 AST_LIST_UNLOCK(&reload_queue);
665                                 return;
666                         }
667                 }
668                 item = ast_calloc(1, sizeof(*item) + strlen(module) + 1);
669                 if (!item) {
670                         ast_log(LOG_ERROR, "Failed to allocate reload queue item.\n");
671                         AST_LIST_UNLOCK(&reload_queue);
672                         return;
673                 }
674                 strcpy(item->module, module);
675                 AST_LIST_INSERT_TAIL(&reload_queue, item, entry);
676         }
677         AST_LIST_UNLOCK(&reload_queue);
678 }
679
680 int ast_module_reload(const char *name)
681 {
682         struct ast_module *cur;
683         int res = 0; /* return value. 0 = not found, others, see below */
684         int i;
685
686         /* If we aren't fully booted, we just pretend we reloaded but we queue this
687            up to run once we are booted up. */
688         if (!ast_fully_booted) {
689                 queue_reload_request(name);
690                 return 0;
691         }
692
693         if (ast_mutex_trylock(&reloadlock)) {
694                 ast_verbose("The previous reload command didn't finish yet\n");
695                 return -1;      /* reload already in progress */
696         }
697         ast_lastreloadtime = ast_tvnow();
698
699         if (ast_opt_lock_confdir) {
700                 int try;
701                 int res;
702                 for (try = 1, res = AST_LOCK_TIMEOUT; try < 6 && (res == AST_LOCK_TIMEOUT); try++) {
703                         res = ast_lock_path(ast_config_AST_CONFIG_DIR);
704                         if (res == AST_LOCK_TIMEOUT) {
705                                 ast_log(LOG_WARNING, "Failed to grab lock on %s, try %d\n", ast_config_AST_CONFIG_DIR, try);
706                         }
707                 }
708                 if (res != AST_LOCK_SUCCESS) {
709                         ast_verbose("Cannot grab lock on %s\n", ast_config_AST_CONFIG_DIR);
710                         ast_mutex_unlock(&reloadlock);
711                         return -1;
712                 }
713         }
714
715         /* Call "predefined" reload here first */
716         for (i = 0; reload_classes[i].name; i++) {
717                 if (!name || !strcasecmp(name, reload_classes[i].name)) {
718                         reload_classes[i].reload_fn();  /* XXX should check error ? */
719                         res = 2;        /* found and reloaded */
720                 }
721         }
722
723         if (name && res) {
724                 if (ast_opt_lock_confdir) {
725                         ast_unlock_path(ast_config_AST_CONFIG_DIR);
726                 }
727                 ast_mutex_unlock(&reloadlock);
728                 return res;
729         }
730
731         AST_LIST_LOCK(&module_list);
732         AST_LIST_TRAVERSE(&module_list, cur, entry) {
733                 const struct ast_module_info *info = cur->info;
734
735                 if (name && resource_name_match(name, cur->resource))
736                         continue;
737
738                 if (!cur->flags.running || cur->flags.declined) {
739                         if (!name)
740                                 continue;
741                         ast_log(LOG_NOTICE, "The module '%s' was not properly initialized.  "
742                                 "Before reloading the module, you must run \"module load %s\" "
743                                 "and fix whatever is preventing the module from being initialized.\n",
744                                 name, name);
745                         res = 2; /* Don't report that the module was not found */
746                         break;
747                 }
748
749                 if (!info->reload) {    /* cannot be reloaded */
750                         if (res < 1)    /* store result if possible */
751                                 res = 1;        /* 1 = no reload() method */
752                         continue;
753                 }
754
755                 res = 2;
756                 ast_verb(3, "Reloading module '%s' (%s)\n", cur->resource, info->description);
757                 info->reload();
758         }
759         AST_LIST_UNLOCK(&module_list);
760
761         if (ast_opt_lock_confdir) {
762                 ast_unlock_path(ast_config_AST_CONFIG_DIR);
763         }
764         ast_mutex_unlock(&reloadlock);
765
766         return res;
767 }
768
769 static unsigned int inspect_module(const struct ast_module *mod)
770 {
771         if (!mod->info->description) {
772                 ast_log(LOG_WARNING, "Module '%s' does not provide a description.\n", mod->resource);
773                 return 1;
774         }
775
776         if (!mod->info->key) {
777                 ast_log(LOG_WARNING, "Module '%s' does not provide a license key.\n", mod->resource);
778                 return 1;
779         }
780
781         if (verify_key((unsigned char *) mod->info->key)) {
782                 ast_log(LOG_WARNING, "Module '%s' did not provide a valid license key.\n", mod->resource);
783                 return 1;
784         }
785
786         if (!ast_strlen_zero(mod->info->buildopt_sum) &&
787             strcmp(buildopt_sum, mod->info->buildopt_sum)) {
788                 ast_log(LOG_WARNING, "Module '%s' was not compiled with the same compile-time options as this version of Asterisk.\n", mod->resource);
789                 ast_log(LOG_WARNING, "Module '%s' will not be initialized as it may cause instability.\n", mod->resource);
790                 return 1;
791         }
792
793         return 0;
794 }
795
796 static enum ast_module_load_result start_resource(struct ast_module *mod)
797 {
798         char tmp[256];
799         enum ast_module_load_result res;
800
801         if (!mod->info->load) {
802                 return AST_MODULE_LOAD_FAILURE;
803         }
804
805         res = mod->info->load();
806
807         switch (res) {
808         case AST_MODULE_LOAD_SUCCESS:
809                 if (!ast_fully_booted) {
810                         ast_verb(1, "%s => (%s)\n", mod->resource, term_color(tmp, mod->info->description, COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
811                         if (ast_opt_console && !option_verbose) {
812                                 /* This never looks good on anything but the root console, so
813                                  * it's best not to try to funnel it through the logger. */
814                                 fprintf(stdout, ".");
815                         }
816                 } else {
817                         ast_verb(1, "Loaded %s => (%s)\n", mod->resource, mod->info->description);
818                 }
819
820                 mod->flags.running = 1;
821
822                 ast_update_use_count();
823                 break;
824         case AST_MODULE_LOAD_DECLINE:
825                 mod->flags.declined = 1;
826                 break;
827         case AST_MODULE_LOAD_FAILURE:
828         case AST_MODULE_LOAD_SKIP: /* modules should never return this value */
829         case AST_MODULE_LOAD_PRIORITY:
830                 break;
831         }
832
833         return res;
834 }
835
836 /*! loads a resource based upon resource_name. If global_symbols_only is set
837  *  only modules with global symbols will be loaded.
838  *
839  *  If the ast_heap is provided (not NULL) the module is found and added to the
840  *  heap without running the module's load() function.  By doing this, modules
841  *  added to the resource_heap can be initialized later in order by priority.
842  *
843  *  If the ast_heap is not provided, the module's load function will be executed
844  *  immediately */
845 static enum ast_module_load_result load_resource(const char *resource_name, unsigned int global_symbols_only, struct ast_heap *resource_heap, int required)
846 {
847         struct ast_module *mod;
848         enum ast_module_load_result res = AST_MODULE_LOAD_SUCCESS;
849
850         if ((mod = find_resource(resource_name, 0))) {
851                 if (mod->flags.running) {
852                         ast_log(LOG_WARNING, "Module '%s' already exists.\n", resource_name);
853                         return AST_MODULE_LOAD_DECLINE;
854                 }
855                 if (global_symbols_only && !ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS))
856                         return AST_MODULE_LOAD_SKIP;
857         } else {
858 #ifdef LOADABLE_MODULES
859                 if (!(mod = load_dynamic_module(resource_name, global_symbols_only))) {
860                         /* don't generate a warning message during load_modules() */
861                         if (!global_symbols_only) {
862                                 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
863                                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
864                         } else {
865                                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SKIP;
866                         }
867                 }
868 #else
869                 ast_log(LOG_WARNING, "Module support is not available. Module '%s' could not be loaded.\n", resource_name);
870                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
871 #endif
872         }
873
874         if (inspect_module(mod)) {
875                 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
876 #ifdef LOADABLE_MODULES
877                 unload_dynamic_module(mod);
878 #endif
879                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
880         }
881
882         if (!mod->lib && mod->info->backup_globals && mod->info->backup_globals()) {
883                 ast_log(LOG_WARNING, "Module '%s' was unable to backup its global data.\n", resource_name);
884                 return required ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_DECLINE;
885         }
886
887         mod->flags.declined = 0;
888
889         if (resource_heap) {
890                 ast_heap_push(resource_heap, mod);
891                 res = AST_MODULE_LOAD_PRIORITY;
892         } else {
893                 res = start_resource(mod);
894         }
895
896         /* Now make sure that the list is sorted */
897         AST_LIST_LOCK(&module_list);
898         AST_LIST_REMOVE(&module_list, mod, entry);
899         AST_LIST_INSERT_SORTALPHA(&module_list, mod, entry, resource);
900         AST_LIST_UNLOCK(&module_list);
901
902         return res;
903 }
904
905 int ast_load_resource(const char *resource_name)
906 {
907         int res;
908         AST_LIST_LOCK(&module_list);
909         res = load_resource(resource_name, 0, NULL, 0);
910         AST_LIST_UNLOCK(&module_list);
911
912         return res;
913 }
914
915 struct load_order_entry {
916         char *resource;
917         int required;
918         AST_LIST_ENTRY(load_order_entry) entry;
919 };
920
921 AST_LIST_HEAD_NOLOCK(load_order, load_order_entry);
922
923 static struct load_order_entry *add_to_load_order(const char *resource, struct load_order *load_order, int required)
924 {
925         struct load_order_entry *order;
926
927         AST_LIST_TRAVERSE(load_order, order, entry) {
928                 if (!resource_name_match(order->resource, resource)) {
929                         /* Make sure we have the proper setting for the required field
930                            (we might have both load= and required= lines in modules.conf) */
931                         order->required |= required;
932                         return NULL;
933                 }
934         }
935
936         if (!(order = ast_calloc(1, sizeof(*order))))
937                 return NULL;
938
939         order->resource = ast_strdup(resource);
940         order->required = required;
941         AST_LIST_INSERT_TAIL(load_order, order, entry);
942
943         return order;
944 }
945
946 static int mod_load_cmp(void *a, void *b)
947 {
948         struct ast_module *a_mod = (struct ast_module *) a;
949         struct ast_module *b_mod = (struct ast_module *) b;
950         int res = -1;
951         /* if load_pri is not set, default is 128.  Lower is better*/
952         unsigned char a_pri = ast_test_flag(a_mod->info, AST_MODFLAG_LOAD_ORDER) ? a_mod->info->load_pri : 128;
953         unsigned char b_pri = ast_test_flag(b_mod->info, AST_MODFLAG_LOAD_ORDER) ? b_mod->info->load_pri : 128;
954         if (a_pri == b_pri) {
955                 res = 0;
956         } else if (a_pri < b_pri) {
957                 res = 1;
958         }
959         return res;
960 }
961
962 /*! loads modules in order by load_pri, updates mod_count
963         \return -1 on failure to load module, -2 on failure to load required module, otherwise 0
964 */
965 static int load_resource_list(struct load_order *load_order, unsigned int global_symbols, int *mod_count)
966 {
967         struct ast_heap *resource_heap;
968         struct load_order_entry *order;
969         struct ast_module *mod;
970         int count = 0;
971         int res = 0;
972
973         if(!(resource_heap = ast_heap_create(8, mod_load_cmp, -1))) {
974                 return -1;
975         }
976
977         /* first, add find and add modules to heap */
978         AST_LIST_TRAVERSE_SAFE_BEGIN(load_order, order, entry) {
979                 switch (load_resource(order->resource, global_symbols, resource_heap, order->required)) {
980                 case AST_MODULE_LOAD_SUCCESS:
981                 case AST_MODULE_LOAD_DECLINE:
982                         AST_LIST_REMOVE_CURRENT(entry);
983                         ast_free(order->resource);
984                         ast_free(order);
985                         break;
986                 case AST_MODULE_LOAD_FAILURE:
987                         ast_log(LOG_ERROR, "*** Failed to load module %s - %s\n", order->resource, order->required ? "Required" : "Not required");
988                         fprintf(stderr, "*** Failed to load module %s - %s\n", order->resource, order->required ? "Required" : "Not required");
989                         res = order->required ? -2 : -1;
990                         goto done;
991                 case AST_MODULE_LOAD_SKIP:
992                         break;
993                 case AST_MODULE_LOAD_PRIORITY:
994                         AST_LIST_REMOVE_CURRENT(entry);
995                         break;
996                 }
997         }
998         AST_LIST_TRAVERSE_SAFE_END;
999
1000         /* second remove modules from heap sorted by priority */
1001         while ((mod = ast_heap_pop(resource_heap))) {
1002                 switch (start_resource(mod)) {
1003                 case AST_MODULE_LOAD_SUCCESS:
1004                         count++;
1005                 case AST_MODULE_LOAD_DECLINE:
1006                         break;
1007                 case AST_MODULE_LOAD_FAILURE:
1008                         res = -1;
1009                         goto done;
1010                 case AST_MODULE_LOAD_SKIP:
1011                 case AST_MODULE_LOAD_PRIORITY:
1012                         break;
1013                 }
1014         }
1015
1016 done:
1017         if (mod_count) {
1018                 *mod_count += count;
1019         }
1020         ast_heap_destroy(resource_heap);
1021
1022         return res;
1023 }
1024
1025 int load_modules(unsigned int preload_only)
1026 {
1027         struct ast_config *cfg;
1028         struct ast_module *mod;
1029         struct load_order_entry *order;
1030         struct ast_variable *v;
1031         unsigned int load_count;
1032         struct load_order load_order;
1033         int res = 0;
1034         struct ast_flags config_flags = { 0 };
1035         int modulecount = 0;
1036
1037 #ifdef LOADABLE_MODULES
1038         struct dirent *dirent;
1039         DIR *dir;
1040 #endif
1041
1042         /* all embedded modules have registered themselves by now */
1043         embedding = 0;
1044
1045         ast_verb(1, "Asterisk Dynamic Loader Starting:\n");
1046
1047         AST_LIST_HEAD_INIT_NOLOCK(&load_order);
1048
1049         AST_LIST_LOCK(&module_list);
1050
1051         if (embedded_module_list.first) {
1052                 module_list.first = embedded_module_list.first;
1053                 module_list.last = embedded_module_list.last;
1054                 embedded_module_list.first = NULL;
1055         }
1056
1057         cfg = ast_config_load2(AST_MODULE_CONFIG, "" /* core, can't reload */, config_flags);
1058         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
1059                 ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
1060                 goto done;
1061         }
1062
1063         /* first, find all the modules we have been explicitly requested to load */
1064         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
1065                 if (!strcasecmp(v->name, preload_only ? "preload" : "load")) {
1066                         add_to_load_order(v->value, &load_order, 0);
1067                 }
1068                 if (!strcasecmp(v->name, preload_only ? "preload-require" : "require")) {
1069                         /* Add the module to the list and make sure it's required */
1070                         add_to_load_order(v->value, &load_order, 1);
1071                         ast_debug(2, "Adding module to required list: %s (%s)\n", v->value, v->name);
1072                 }
1073
1074         }
1075
1076         /* check if 'autoload' is on */
1077         if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
1078                 /* if so, first add all the embedded modules that are not already running to the load order */
1079                 AST_LIST_TRAVERSE(&module_list, mod, entry) {
1080                         /* if it's not embedded, skip it */
1081                         if (mod->lib)
1082                                 continue;
1083
1084                         if (mod->flags.running)
1085                                 continue;
1086
1087                         add_to_load_order(mod->resource, &load_order, 0);
1088                 }
1089
1090 #ifdef LOADABLE_MODULES
1091                 /* if we are allowed to load dynamic modules, scan the directory for
1092                    for all available modules and add them as well */
1093                 if ((dir = opendir(ast_config_AST_MODULE_DIR))) {
1094                         while ((dirent = readdir(dir))) {
1095                                 int ld = strlen(dirent->d_name);
1096
1097                                 /* Must end in .so to load it.  */
1098
1099                                 if (ld < 4)
1100                                         continue;
1101
1102                                 if (strcasecmp(dirent->d_name + ld - 3, ".so"))
1103                                         continue;
1104
1105                                 /* if there is already a module by this name in the module_list,
1106                                    skip this file */
1107                                 if (find_resource(dirent->d_name, 0))
1108                                         continue;
1109
1110                                 add_to_load_order(dirent->d_name, &load_order, 0);
1111                         }
1112
1113                         closedir(dir);
1114                 } else {
1115                         if (!ast_opt_quiet)
1116                                 ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
1117                                         ast_config_AST_MODULE_DIR);
1118                 }
1119 #endif
1120         }
1121
1122         /* now scan the config for any modules we are prohibited from loading and
1123            remove them from the load order */
1124         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
1125                 if (strcasecmp(v->name, "noload"))
1126                         continue;
1127
1128                 AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
1129                         if (!resource_name_match(order->resource, v->value)) {
1130                                 AST_LIST_REMOVE_CURRENT(entry);
1131                                 ast_free(order->resource);
1132                                 ast_free(order);
1133                         }
1134                 }
1135                 AST_LIST_TRAVERSE_SAFE_END;
1136         }
1137
1138         /* we are done with the config now, all the information we need is in the
1139            load_order list */
1140         ast_config_destroy(cfg);
1141
1142         load_count = 0;
1143         AST_LIST_TRAVERSE(&load_order, order, entry)
1144                 load_count++;
1145
1146         if (load_count)
1147                 ast_log(LOG_NOTICE, "%d modules will be loaded.\n", load_count);
1148
1149         /* first, load only modules that provide global symbols */
1150         if ((res = load_resource_list(&load_order, 1, &modulecount)) < 0) {
1151                 goto done;
1152         }
1153
1154         /* now load everything else */
1155         if ((res = load_resource_list(&load_order, 0, &modulecount)) < 0) {
1156                 goto done;
1157         }
1158
1159 done:
1160         while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
1161                 ast_free(order->resource);
1162                 ast_free(order);
1163         }
1164
1165         AST_LIST_UNLOCK(&module_list);
1166
1167         /* Tell manager clients that are aggressive at logging in that we're done
1168            loading modules. If there's a DNS problem in chan_sip, we might not
1169            even reach this */
1170         /*** DOCUMENTATION
1171                 <managerEventInstance>
1172                         <synopsis>Raised when all dynamic modules have finished their initial loading.</synopsis>
1173                         <syntax>
1174                                 <parameter name="ModuleSelection">
1175                                         <enumlist>
1176                                                 <enum name="Preload"/>
1177                                                 <enum name="All"/>
1178                                         </enumlist>
1179                                 </parameter>
1180                         </syntax>
1181                 </managerEventInstance>
1182         ***/
1183         manager_event(EVENT_FLAG_SYSTEM, "ModuleLoadReport", "ModuleLoadStatus: Done\r\nModuleSelection: %s\r\nModuleCount: %d\r\n", preload_only ? "Preload" : "All", modulecount);
1184
1185         return res;
1186 }
1187
1188 void ast_update_use_count(void)
1189 {
1190         /* Notify any module monitors that the use count for a
1191            resource has changed */
1192         struct loadupdate *m;
1193
1194         AST_LIST_LOCK(&updaters);
1195         AST_LIST_TRAVERSE(&updaters, m, entry)
1196                 m->updater();
1197         AST_LIST_UNLOCK(&updaters);
1198 }
1199
1200 int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like),
1201                            const char *like)
1202 {
1203         struct ast_module *cur;
1204         int unlock = -1;
1205         int total_mod_loaded = 0;
1206
1207         if (AST_LIST_TRYLOCK(&module_list))
1208                 unlock = 0;
1209
1210         AST_LIST_TRAVERSE(&module_list, cur, entry) {
1211                 total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount, like);
1212         }
1213
1214         if (unlock)
1215                 AST_LIST_UNLOCK(&module_list);
1216
1217         return total_mod_loaded;
1218 }
1219
1220 /*! \brief Check if module exists */
1221 int ast_module_check(const char *name)
1222 {
1223         struct ast_module *cur;
1224
1225         if (ast_strlen_zero(name))
1226                 return 0;       /* FALSE */
1227
1228         cur = find_resource(name, 1);
1229
1230         return (cur != NULL);
1231 }
1232
1233
1234 int ast_loader_register(int (*v)(void))
1235 {
1236         struct loadupdate *tmp;
1237
1238         if (!(tmp = ast_malloc(sizeof(*tmp))))
1239                 return -1;
1240
1241         tmp->updater = v;
1242         AST_LIST_LOCK(&updaters);
1243         AST_LIST_INSERT_HEAD(&updaters, tmp, entry);
1244         AST_LIST_UNLOCK(&updaters);
1245
1246         return 0;
1247 }
1248
1249 int ast_loader_unregister(int (*v)(void))
1250 {
1251         struct loadupdate *cur;
1252
1253         AST_LIST_LOCK(&updaters);
1254         AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, entry) {
1255                 if (cur->updater == v)  {
1256                         AST_LIST_REMOVE_CURRENT(entry);
1257                         break;
1258                 }
1259         }
1260         AST_LIST_TRAVERSE_SAFE_END;
1261         AST_LIST_UNLOCK(&updaters);
1262
1263         return cur ? 0 : -1;
1264 }
1265
1266 struct ast_module *ast_module_ref(struct ast_module *mod)
1267 {
1268         if (!mod) {
1269                 return NULL;
1270         }
1271
1272         ast_atomic_fetchadd_int(&mod->usecount, +1);
1273         ast_update_use_count();
1274
1275         return mod;
1276 }
1277
1278 void ast_module_unref(struct ast_module *mod)
1279 {
1280         if (!mod) {
1281                 return;
1282         }
1283
1284         ast_atomic_fetchadd_int(&mod->usecount, -1);
1285         ast_update_use_count();
1286 }