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