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