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