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