small cleanups to module.h and loader.c to start playing with
[asterisk/asterisk.git] / loader.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Module Loader
22  *
23  * \author Mark Spencer <markster@digium.com> 
24  * - See ModMngMnt
25  */
26
27 #include <stdio.h>
28 #include <dirent.h>
29 #include <unistd.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include "asterisk/linkedlists.h"
38 #include "asterisk/module.h"
39 #include "asterisk/options.h"
40 #include "asterisk/config.h"
41 #include "asterisk/logger.h"
42 #include "asterisk/channel.h"
43 #include "asterisk/term.h"
44 #include "asterisk/manager.h"
45 #include "asterisk/cdr.h"
46 #include "asterisk/enum.h"
47 #include "asterisk/rtp.h"
48 #include "asterisk/http.h"
49 #include "asterisk/lock.h"
50 #ifdef DLFCNCOMPAT
51 #include "asterisk/dlfcn-compat.h"
52 #else
53 #include <dlfcn.h>
54 #endif
55 #include "asterisk/md5.h"
56 #include "asterisk/utils.h"
57
58 #ifndef RTLD_NOW
59 #define RTLD_NOW 0
60 #endif
61
62 static int modlistver = 0; /* increase whenever the list changes, to protect reload */
63
64 static unsigned char expected_key[] =
65 { 0x8e, 0x93, 0x22, 0x83, 0xf5, 0xc3, 0xc0, 0x75,
66   0xff, 0x8b, 0xa9, 0xbe, 0x7c, 0x43, 0x74, 0x63 };
67
68 /*
69  * Modules can be in a number of different states, as below:
70  * MS_FAILED    attempt to load failed. This is final.
71  * MS_NEW       just added to the list, symbols unresolved.
72  * MS_RESOLVED  all symbols resolved, but supplier modules not active yet.
73  * MS_CANLOAD   all symbols resolved and suppliers are all active
74  *              (or we are in a cyclic dependency and we are breaking a loop)
75  * MS_ACTIVE    load() returned successfully.
76  */
77 enum st_t {  /* possible states of a module */
78         MS_FAILED = 0,              /*!< cannot load */
79         MS_NEW = 1,                 /*!< nothing known */
80         MS_RESOLVED = 2,            /*!< all required resolved */
81         MS_CANLOAD = 3,             /*!< as above, plus cyclic depend.*/
82         MS_ACTIVE = 4,              /*!< all done */
83 };
84
85 /*! \note
86  * All module symbols are in module_symbols.
87  * Modules are then linked in a list of struct module,
88  * whereas updaters are in a list of struct loadupdate.
89  *
90  * Both lists (basically, the entire loader) are protected by
91  * the lock in module_list.
92  *
93  * A second lock, reloadlock, is used to prevent concurrent reloads
94  */
95 struct module {
96         AST_LIST_ENTRY(module) next;
97         struct module_symbols cb;
98         void *lib;              /* the shared lib */
99         char resource[256];
100
101         enum st_t state;
102         int export_refcount;    /* how many users of exported symbols */
103
104         ast_mutex_t mtx;        /* XXX use yet ? */
105         struct localuser *lu;
106         int localusecnt;
107 };
108
109
110 struct loadupdate {
111         AST_LIST_ENTRY(loadupdate) next;
112         int (*updater)(void);
113 };
114
115 static AST_LIST_HEAD_STATIC(module_list, module);
116 static AST_LIST_HEAD_STATIC(updaters, loadupdate);
117 AST_MUTEX_DEFINE_STATIC(reloadlock);
118
119 /*! \note
120  * helper localuser routines.
121  * All of these routines are extremely expensive, so the use of
122  * macros is totally unnecessary from the point of view of performance:
123  * the extra function call will be totally negligible in all cases.
124  */
125
126 struct localuser *ast_localuser_add(struct ast_module_lock *m,
127         struct ast_channel *chan)
128 {
129         struct localuser *u = ast_calloc(1, sizeof(*u));
130         if (u == NULL)
131                 return NULL;
132         u->chan = chan;
133         ast_mutex_lock(&m->lock);
134         AST_LIST_INSERT_HEAD(&m->u, u, next);
135         m->usecnt++;
136         ast_mutex_unlock(&m->lock);
137         ast_update_use_count();
138         return u;
139 }
140
141 void ast_localuser_remove(struct ast_module_lock *m, struct localuser *u)
142 {
143         ast_mutex_lock(&m->lock);
144         AST_LIST_REMOVE(&m->u, u, next);
145         m->usecnt--;
146         free(u);
147         ast_mutex_unlock(&m->lock);
148         ast_update_use_count();
149 }
150
151 void ast_hangup_localusers(struct ast_module_lock *m)
152 {
153         struct localuser *u;
154         ast_mutex_lock(&m->lock);
155         AST_LIST_TRAVERSE_SAFE_BEGIN(&m->u, u, next) {
156                 ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
157                 free(u);
158                 AST_LIST_REMOVE_CURRENT(&m->u, next);
159         }
160         AST_LIST_TRAVERSE_SAFE_END
161         m->usecnt = 0;
162         ast_mutex_unlock(&m->lock);
163         ast_update_use_count();
164 }
165
166 /*--- new-style loader routines ---*/
167
168 /*
169  * For backward compatibility, we have 3 types of loadable modules:
170  *
171  * MOD_0 these are the 'old style' modules, which export a number
172  *       of callbacks, and their full interface, as globally visible
173  *       symbols. The module needs to be loaded with RTLD_LAZY and
174  *       RTLD_GLOBAL to make symbols visible to other modules, and
175  *       to avoid load failures due to cross dependencies.
176  *
177  * MOD_1 almost as above, but the generic callbacks are all into a
178  *       a structure, mod_data. Same load requirements as above.
179  *
180  * MOD_2 this is the 'new style' format for modules. The module must
181  *       explictly declare which simbols are exported and which
182  *       symbols from other modules are used, and the code in this
183  *       loader will implement appropriate checks to load the modules
184  *       in the correct order. Also this allows to load modules
185  *       with RTLD_NOW and RTLD_LOCAL so there is no chance of run-time
186  *       bugs due to unresolved symbols or name conflicts.
187  */
188
189 /*
190  * helper routine to print the symbolic name associated to a state
191  */
192 static const char *st_name(enum st_t state)
193 {
194         /* try to resolve required symbols */
195         const char *st;
196         switch (state) {
197 #define ST(x)  case x: st = # x; break;
198         ST(MS_NEW);
199         ST(MS_FAILED);
200         ST(MS_RESOLVED);
201         ST(MS_ACTIVE);
202         ST(MS_CANLOAD);
203         default:
204                 st = "unknown";
205         }
206         return st;
207 #undef ST
208 }
209
210 /*! \brief
211  * Fetch/release an exported symbol - modify export_refcount by delta
212  * \param delta 1 to fetch a symbol, -1 to release it.
213  * \return on success, return symbol value.
214  * \note Note, modules in MS_FAIL will never match in a 'get' request.
215  * If src is non-NULL, on exit *src points to the source module.
216  *
217  * Must be called with the lock held.
218  */
219 static void *module_symbol_helper(const char *name,
220                 int delta, struct module **src)
221 {
222         void *ret = NULL;
223         struct module *m;
224
225         AST_LIST_TRAVERSE(&module_list, m, next) {
226                 struct symbol_entry *es;
227                 if (delta > 0 && m->state == MS_FAILED)
228                         continue; /* cannot 'get' a symbol from a failed module */
229                 for (es = m->cb.exported_symbols; ret == NULL && es && es->name; es++) {
230                         if (!strcmp(es->name, name)) {
231                                 ret = es->value;
232                                 m->export_refcount += delta;
233                                 if (src)
234                                         *src = m;
235                                 break;
236                         }
237                 }
238                 if (ret)
239                         break;
240         }
241         if (ret == NULL)
242                 ast_log(LOG_WARNING, "symbol %s not found\n", name);
243         return ret;
244 }
245
246 static void *release_module_symbol(const char *name)
247 {
248         return module_symbol_helper(name, -1, NULL);
249 }
250
251 static void *get_module_symbol(const char *name, struct module **src)
252 {
253         return module_symbol_helper(name, +1, src);
254 }
255
256 /*!
257  * \brief Release refcounts to all imported symbols,
258  * and change module state to MS_FAILED.
259  */
260 static void release_module(struct module *m)
261 {
262         struct symbol_entry *s;
263
264         for (s = m->cb.required_symbols; s && s->name != NULL; s++) {
265                 if (s->value != NULL) {
266                         release_module_symbol(s->name);
267                         s->value = NULL;
268                 }
269         }
270         m->state = MS_FAILED;
271 }
272
273 /*! \brief check that no NULL symbols are exported  - the algorithms rely on that. */
274 static int check_exported(struct module *m)
275 {
276         struct symbol_entry *es = m->cb.exported_symbols;
277         int errors = 0;
278
279         if (es == NULL)
280                 return 0;
281         ast_log(LOG_WARNING, "module %s exports the following symbols\n",
282                 es->name);
283         for (; es->name; es++) {
284                 void **p = es->value;
285                 int i;
286
287                 ast_log(LOG_WARNING, "\taddr %p size %8d %s\n",
288                         es->value, es->size, es->name);
289                 for (i = 0; i <  es->size / sizeof(void *); i++, p++) {
290                         if (*p == NULL) {
291                                 ast_log(LOG_WARNING, "\t *** null field at offset %d\n", i);
292                                         errors++;
293                         }
294                 }
295         }
296         return errors;
297 }
298
299 /*!
300  * \brief Resolve symbols and change state accordingly.
301  * \return Return 1 if state changed, 0 otherwise.
302  * \note If MS_FAILED, MS_ACTIVE or MS_CANLOAD there is nothing to do.
303  * If a symbol cannot be resolved (no supplier or supplier in MS_FAIL),
304  * move to MS_FAIL and release all symbols;
305  * If all suppliers are MS_ACTIVE, move to MS_CANLOAD
306  * otherwise move to MS_RESOLVED.
307  */
308 static int resolve(struct module *m)
309 {
310         struct symbol_entry *s;
311
312         if (m->state == MS_FAILED || m->state == MS_ACTIVE || m->state == MS_CANLOAD)
313                 return 0;       /* already decided what to do */
314         /* now it's either MS_NEW or MS_RESOLVED.
315          * Be optimistic and put it in MS_CANLOAD, then try to
316          * resolve and verify symbols, and downgrade as appropriate.
317          */
318         m->state = MS_CANLOAD;
319         for (s = m->cb.required_symbols; s && s->name != NULL; s++) {
320                 void **p = (void **)(s->value);
321
322                 if (*p == NULL)         /* symbol not resolved yet */
323                         *p = get_module_symbol(s->name, &s->src);
324                 if (*p == NULL || s->src->state == MS_FAILED) {        /* fail */
325                         ast_log(LOG_WARNING,
326                                 "Unresolved symbol %s for module %s\n",
327                                 s->name, m->resource);
328                         release_module(m); /* and set to MS_FAILED */
329                         break;
330                 }
331                 if (s->src->state != MS_ACTIVE)
332                         m->state = MS_RESOLVED; /* downgrade */
333         }
334         return 1;
335 }
336
337 /*!
338  * \brief Fixup references and load modules according to their dependency order.
339  * Called when new modules are added to the list.
340  * The algorithm is as follows:
341  * - all modules MS_FAILED are changed to MS_NEW, in case something
342  *      happened that could help them.
343  * - first try to resolve symbols. If successful, change the
344  *   module's state to MS_RESOLVED otherwise to MS_FAILED
345  * - repeat on all modules until there is progress:
346  *    - if it is MS_ACTIVE or MS_FAILED, continue (no progress)
347  *    - if one has all required modules in MS_ACTIVE, try to load it.
348  *      If successful it becomes MS_ACTIVE itself, otherwise
349  *             MS_FAILED and releases all symbols.
350  *             In any case, we have progress.
351  *    - if one of the dependencies is MS_FAILED, release and set to
352  *      MS_FAILED here too. We have progress.
353  * - if we have no progress there is a cyclic dependency.
354  *      Take first and change to MS_CANLOAD, i.e. as if all required are
355  *      MS_ACTIVE. we have progress, so repeat.
356  * \par NOTE:
357  *   - must be called with lock held
358  *   - recursive calls simply return success.
359  */
360 static int fixup(const char *caller)
361 {
362         struct module *m;
363         int total = 0, new = 0, cycle = 0;
364         static int in_fixup = 0;        /* disable recursive calls */
365
366         if (in_fixup)
367                 return 0;
368         in_fixup++;
369         AST_LIST_TRAVERSE(&module_list, m, next) {
370                 total++;
371                 if (m->state == MS_FAILED)
372                         m->state = MS_NEW;
373                 if (m->state == MS_NEW)
374                         new++;
375                 /* print some debugging info for new modules */
376                 if (m->state == MS_NEW &&
377                     (m->cb.exported_symbols || m->cb.required_symbols))
378                         ast_log(LOG_NOTICE,
379                             "module %-30s exports %p requires %p state %s(%d)\n",
380                                 m->resource, m->cb.exported_symbols,
381                                 m->cb.required_symbols,
382                                 st_name(m->state), m->state);
383         }
384         ast_log(LOG_DEBUG, "---- fixup (%s): %d modules, %d new ---\n",
385                 caller, total, new);
386         for (;;cycle++) {
387                 int again = 0;  /* set if we need another round */
388                 
389                 ast_log(LOG_DEBUG, "---- fixup: cycle %d ---\n", cycle);
390                 AST_LIST_TRAVERSE(&module_list, m, next) {
391                         if (resolve(m))
392                                 again = 1;      /* something changed */
393                         if (m->state != MS_CANLOAD)     /* for now, done with this module */
394                                 continue;
395                         /* try to run the load routine */
396                         if (m->cb.load_module()) { /* error */
397                                 ast_log(LOG_WARNING, "load_module %s fail\n",
398                                         m->resource);
399                                 release_module(m); /* and set to MS_FAIL */
400                         } else {
401                                 ast_log(LOG_WARNING, "load_module %s success\n",
402                                         m->resource);
403                                 m->state = MS_ACTIVE;
404                         }
405                         again = 1;      /* something has changed */
406                 }
407                 /* Modules in MS_RESOLVED mean a possible cyclic dependency.
408                  * Break the indecision by setting one to CANLOAD, and repeat.
409                  */
410                 AST_LIST_TRAVERSE(&module_list, m, next) {
411                         if (m->state == MS_RESOLVED) {
412                                 m->state = MS_CANLOAD;
413                                 again = 1;
414                                 break;
415                         }
416                 }
417                 if (!again)     /* we are done */
418                         break;
419         }
420         ast_log(LOG_DEBUG, "---- fixup complete ---\n");
421         in_fixup--;
422         return 0;
423 }
424
425 /* test routines to see which modules depend on global symbols
426  * exported by other modules.
427  */
428 static void check_symbols(void)
429 {
430         struct dirent *d;
431         DIR *mods = opendir(ast_config_AST_MODULE_DIR);
432         void *lib;
433         char buf[1024];
434
435         ast_log(LOG_WARNING, "module dir <%s>\n", ast_config_AST_MODULE_DIR);
436         if (!mods)
437                 return;
438         while((d = readdir(mods))) {
439                 int ld = strlen(d->d_name);
440                 /* Must end in .so to load it.  */
441                 if (ld <= 3 || strcasecmp(d->d_name + ld - 3, ".so"))
442                         continue;
443                 snprintf(buf, sizeof(buf), "%s/%s", ast_config_AST_MODULE_DIR, d->d_name);
444                 lib = dlopen(buf, RTLD_NOW | RTLD_LOCAL);
445                 if (lib == NULL) {
446                         ast_log(LOG_WARNING, "(notice only) module %s error %s\n", d->d_name, dlerror());
447                 }
448                 dlclose(lib);
449         }
450 }
451 /*--- end new-style routines ---*/
452
453 /*! \note
454  * In addition to modules, the reload command handles some extra keywords
455  * which are listed here together with the corresponding handlers.
456  * This table is also used by the command completion code.
457  */
458 static struct reload_classes_t {
459         const char *name;
460         int (*reload_fn)(void);
461 } reload_classes[] = {  /* list in alpha order, longest match first */
462         { "cdr",        ast_cdr_engine_reload },
463         { "dnsmgr",     dnsmgr_reload },
464         { "extconfig",  read_config_maps },
465         { "enum",       ast_enum_reload },
466         { "manager",    reload_manager },
467         { "rtp",        ast_rtp_reload },
468         { "http",       ast_http_reload },
469         { NULL, NULL }
470 };
471
472 static int printdigest(const unsigned char *d)
473 {
474         int x, pos;
475         char buf[256]; /* large enough so we don't have to worry */
476
477         for (pos = 0, x=0; x<16; x++)
478                 pos += sprintf(buf + pos, " %02x", *d++);
479         ast_log(LOG_DEBUG, "Unexpected signature:%s\n", buf);
480         return 0;
481 }
482
483 static int key_matches(const unsigned char *key1, const unsigned char *key2)
484 {
485         int x;
486         for (x=0; x<16; x++) {
487                 if (key1[x] != key2[x]) /* mismatch - fail now. */
488                         return 0;
489         }
490         return 1;
491 }
492
493 static int verify_key(const unsigned char *key)
494 {
495         struct MD5Context c;
496         unsigned char digest[16];
497         MD5Init(&c);
498         MD5Update(&c, key, strlen((char *)key));
499         MD5Final(digest, &c);
500         if (key_matches(expected_key, digest))
501                 return 0;
502         printdigest(digest);
503         return -1;
504 }
505
506 int ast_unload_resource(const char *resource_name, int force)
507 {
508         struct module *cur;
509         int res = -1;
510         int error = 0;
511         if (AST_LIST_LOCK(&module_list)) /* XXX should fail here ? */
512                 ast_log(LOG_WARNING, "Failed to lock\n");
513         AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, cur, next) {
514                 struct module_symbols *m = &cur->cb;
515                 
516                 if (strcasecmp(cur->resource, resource_name))   /* not us */
517                         continue;
518                 if ((res = m->usecount()) > 0)  {
519                         if (force) 
520                                 ast_log(LOG_WARNING, "Warning:  Forcing removal of module %s with use count %d\n", resource_name, res);
521                         else {
522                                 ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name, res);
523                                 error = 1;
524                                 break;
525                         }
526                 }
527                 res = m->unload_module();
528                 if (res) {
529                         ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
530                         if (force <= AST_FORCE_FIRM) {
531                                 error = 1;
532                                 break;
533                         } else
534                                 ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
535                 }
536                 release_module(cur);    /* XXX */
537                 AST_LIST_REMOVE_CURRENT(&module_list, next);
538                 dlclose(cur->lib);
539                 free(cur);
540                 break;
541         }
542         AST_LIST_TRAVERSE_SAFE_END;
543         if (!error)
544                 modlistver++;
545         AST_LIST_UNLOCK(&module_list);
546         if (!error)     /* XXX maybe within the lock ? */
547                 ast_update_use_count();
548         return res;
549 }
550
551 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload)
552 {
553         struct module *cur;
554         int i, which=0, l = strlen(word);
555         char *ret = NULL;
556
557         if (pos != rpos)
558                 return NULL;
559         AST_LIST_LOCK(&module_list);
560         AST_LIST_TRAVERSE(&module_list, cur, next) {
561                 if (!strncasecmp(word, cur->resource, l) && (cur->cb.reload || !needsreload) &&
562                                 ++which > state) {
563                         ret = strdup(cur->resource);
564                         break;
565                 }
566         }
567         AST_LIST_UNLOCK(&module_list);
568         if (!ret) {
569                 for (i=0; !ret && reload_classes[i].name; i++) {
570                         if (!strncasecmp(word, reload_classes[i].name, l) && ++which > state)
571                                 ret = strdup(reload_classes[i].name);
572                 }
573         }
574         return ret;
575 }
576
577 /*!
578  * \brief Given a function address, find the corresponding module.
579  * This is required as a workaround to the fact that we do not
580  * have a module argument to the load_module() function.
581  * Hopefully the performance implications are small.
582  */
583 struct module *ast_find_module(int (*load_fn)(void))
584 {
585         struct module *cur;
586         AST_LIST_LOCK(&module_list);
587         AST_LIST_TRAVERSE(&module_list, cur, next) {
588                 if (cur->cb.load_module == load_fn)
589                         break;
590         }
591         AST_LIST_UNLOCK(&module_list);
592         return cur;
593 }
594
595 int ast_module_reload(const char *name)
596 {
597         struct module *cur;
598         int res = 0; /* return value. 0 = not found, others, see below */
599         int i, oldversion;
600         int (*reload)(void);
601
602         if (ast_mutex_trylock(&reloadlock)) {
603                 ast_verbose("The previous reload command didn't finish yet\n");
604                 return -1;      /* reload already in progress */
605         }
606         /* Call "predefined" reload here first */
607         for (i = 0; reload_classes[i].name; i++) {
608                 if (!name || !strcasecmp(name, reload_classes[i].name)) {
609                         reload_classes[i].reload_fn();  /* XXX should check error ? */
610                         res = 2;        /* found and reloaded */
611                 }
612         }
613         ast_lastreloadtime = time(NULL);
614
615         AST_LIST_LOCK(&module_list);
616         oldversion = modlistver;
617         AST_LIST_TRAVERSE(&module_list, cur, next) {
618                 struct module_symbols *m = &cur->cb;
619                 if (name && strcasecmp(name, cur->resource))    /* not ours */
620                         continue;
621                 reload = m->reload;
622                 if (!reload) {  /* cannot be reloaded */
623                         if (res < 1)    /* store result if possible */
624                                 res = 1;        /* 1 = no reload() method */
625                         continue;
626                 }
627                 /* drop the lock and try a reload. if successful, break */
628                 AST_LIST_UNLOCK(&module_list);
629                 res = 2;
630                 if (option_verbose > 2) 
631                         ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", cur->resource, m->description());
632                 reload();
633                 AST_LIST_LOCK(&module_list);
634                 if (oldversion != modlistver) /* something changed, abort */
635                         break;
636         }
637         AST_LIST_UNLOCK(&module_list);
638         ast_mutex_unlock(&reloadlock);
639         return res;
640 }
641
642 static int resource_exists(const char *resource, int do_lock)
643 {
644         struct module *cur;
645         if (do_lock && AST_LIST_LOCK(&module_list))
646                 ast_log(LOG_WARNING, "Failed to lock\n");
647         AST_LIST_TRAVERSE(&module_list, cur, next) {
648                 if (!strcasecmp(resource, cur->resource))
649                         break;
650         }
651         if (do_lock)
652                 AST_LIST_UNLOCK(&module_list);
653         return cur ? -1 : 0;
654 }
655
656 /* lookup a symbol with or without leading '_', accept either form in input */
657 static void *find_symbol(struct module *m, const char *name, int verbose)
658 {
659         char *n1;
660         void *s;
661
662         if (name[0] == '_')
663                 name++;
664         if (!(n1 = alloca(strlen(name) + 2))) /* room for leading '_' and final '\0' */
665                 return NULL;
666         n1[0] = '_';
667         strcpy(n1+1, name);
668         s = dlsym(m->lib, n1+1);        /* try without '_' */
669         if (s == NULL)
670                 s = dlsym(m->lib, n1);
671         if (verbose && s == NULL)
672                 ast_log(LOG_WARNING, "No symbol '%s' in module '%s\n",
673                         n1, m->resource);
674         return s;
675 }
676
677 /* XXX cfg is only used for !res_* and #ifdef RTLD_GLOBAL */
678 static struct module * __load_resource(const char *resource_name,
679         const struct ast_config *cfg)
680 {
681         static char fn[256];
682         int errors=0;
683         int res;
684         struct module *cur;
685         struct module_symbols *m, *m1;
686         int flags = RTLD_NOW;
687         unsigned char *key;
688         char tmp[80];
689
690 #ifndef RTLD_GLOBAL
691 #define RTLD_GLOBAL     0       /* so it is a No-op */
692 #endif
693         if (strncasecmp(resource_name, "res_", 4) && cfg) {
694                 char *val = ast_variable_retrieve(cfg, "global", resource_name);
695                 if (val && ast_true(val))
696                         flags |= RTLD_GLOBAL;
697         } else {
698                 /* Resource modules are always loaded global and lazy */
699                 flags = (RTLD_GLOBAL | RTLD_LAZY);
700         }
701         
702         if (AST_LIST_LOCK(&module_list))
703                 ast_log(LOG_WARNING, "Failed to lock\n");
704         if (resource_exists(resource_name, 0)) {
705                 ast_log(LOG_WARNING, "Module '%s' already exists\n", resource_name);
706                 AST_LIST_UNLOCK(&module_list);
707                 return NULL;
708         }
709         if (!(cur = ast_calloc(1, sizeof(*cur)))) {
710                 AST_LIST_UNLOCK(&module_list);
711                 return NULL;
712         }
713         m = &cur->cb;
714         ast_copy_string(cur->resource, resource_name, sizeof(cur->resource));
715         if (resource_name[0] == '/')
716                 ast_copy_string(fn, resource_name, sizeof(fn));
717         else
718                 snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR, resource_name);
719
720         /* open in a sane way */
721         cur->lib = dlopen(fn, RTLD_NOW | RTLD_LOCAL);
722         if (cur->lib == NULL) {
723                 ast_log(LOG_WARNING, "cannot load %s %s\n", fn, dlerror());
724         } else if ( (m1 = find_symbol(cur, "mod_data", 0)) == NULL || m1->type == MOD_0) {
725                 /* old-style module, close and reload with standard flags */
726                 dlclose(cur->lib);
727                 cur->lib = NULL;
728         }
729         if (cur->lib == NULL)   /* try reopen with the old style */
730                 cur->lib = dlopen(fn, flags);
731
732         if (!cur->lib) {
733                 ast_log(LOG_WARNING, "%s\n", dlerror());
734                 free(cur);
735                 AST_LIST_UNLOCK(&module_list);
736                 return NULL;
737         }
738         m1 = find_symbol(cur, "mod_data", 0);
739         if (m1 != NULL) {       /* new style module */
740                 ast_log(LOG_WARNING, "new style %s (%d) loaded RTLD_LOCAL\n",
741                         resource_name, m1->type);
742                 errors = check_exported(cur);
743                 *m = *m1;
744         } else {
745                 m->type = MOD_0;
746                 m->load_module = find_symbol(cur, "load_module", 1);
747                 m->unload_module = find_symbol(cur, "unload_module", 1);
748                 m->usecount = find_symbol(cur, "usecount", 1);
749                 m->description = find_symbol(cur, "description", 1);
750                 m->key = find_symbol(cur, "key", 1);
751                 m->reload = find_symbol(cur, "reload", 0);
752         }
753         if (!m->load_module)
754                 errors++;
755         if (!m->unload_module)
756                 errors++;
757         if (!m->usecount)
758                 errors++;
759         if (!m->description)
760                 errors++;
761         if (!m->key)
762                 errors++;
763         if (!m->key || !(key = (unsigned char *) m->key())) {
764                 ast_log(LOG_WARNING, "Key routine returned NULL in module %s\n", fn);
765                 key = NULL;
766                 errors++;
767         }
768         if (key && verify_key(key)) {
769                 ast_log(LOG_WARNING, "Unexpected key returned by module %s\n", fn);
770                 errors++;
771         }
772         if (errors) {
773                 ast_log(LOG_WARNING, "%d error%s loading module %s, aborted\n", errors, (errors != 1) ? "s" : "", fn);
774                 dlclose(cur->lib);
775                 free(cur);
776                 AST_LIST_UNLOCK(&module_list);
777                 return NULL;
778         }
779         if (!ast_fully_booted) {
780                 if (option_verbose) 
781                         ast_verbose( " => (%s)\n", term_color(tmp, m->description(), COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
782                 if (ast_opt_console && !option_verbose)
783                         ast_verbose( ".");
784         } else {
785                 if (option_verbose)
786                         ast_verbose(VERBOSE_PREFIX_1 "Loaded %s => (%s)\n", fn, m->description());
787         }
788
789         AST_LIST_INSERT_TAIL(&module_list, cur, next);
790         /* add module to end of module_list chain
791            so reload commands will be issued in same order modules were loaded */
792         
793         modlistver++;
794         if (m->type == MOD_2) {
795                 ast_log(LOG_WARNING, "new-style module %s, deferring load()\n",
796                         resource_name);
797                 cur->state = MS_NEW;
798         } else
799                 cur->state = MS_CANLOAD;
800         /* XXX make sure the usecount is 1 before releasing the lock */
801         AST_LIST_UNLOCK(&module_list);
802         
803         if (cur->state == MS_CANLOAD && (res = m->load_module())) {
804                 ast_log(LOG_WARNING, "%s: load_module failed, returning %d\n", resource_name, res);
805                 ast_unload_resource(resource_name, 0);
806                 return NULL;
807         }
808         cur->state = MS_ACTIVE;
809         ast_update_use_count();
810         return cur;
811 }
812
813 /*!
814  * \brief load a single module (API call).
815  * (recursive calls from load_module() succeed.
816  * \return Returns 0 on success, -1 on error.
817  */
818 int ast_load_resource(const char *resource_name)
819 {
820         int o = option_verbose;
821         struct ast_config *cfg = NULL;
822         struct module *m;
823
824         option_verbose = 0;     /* Keep the module file parsing silent */
825         cfg = ast_config_load(AST_MODULE_CONFIG);
826         option_verbose = o;     /* restore verbosity */
827         m = __load_resource(resource_name, cfg);
828         if (cfg)
829                 ast_config_destroy(cfg);
830         return m ? 0 : -1;
831 }       
832
833 #if 0
834 +/*
835 + * load a single module (API call).
836 + * (recursive calls from load_module() succeed.
837 + */
838 +int ast_load_resource(const char *resource_name)
839 +{
840 +       struct module *m;
841 +       int ret;
842 +
843 +       ast_mutex_lock(&modlock);
844 +       m = __load_resource(resource_name, 0);
845 +       fixup(resource_name);
846 +       ret = (m->state == MS_FAILED) ? -1 : 0;
847 +       ast_mutex_unlock(&modlock);
848 +       return ret;
849 +}
850 #endif
851
852 /*! \brief if enabled, log and output on console the module's name, and try load it */
853 static int print_and_load(const char *s, struct ast_config *cfg)
854 {
855         char tmp[80];
856
857         if (option_debug && !option_verbose)
858                 ast_log(LOG_DEBUG, "Loading module %s\n", s);
859         if (option_verbose) {
860                 ast_verbose(VERBOSE_PREFIX_1 "[%s]",
861                         term_color(tmp, s, COLOR_BRWHITE, 0, sizeof(tmp)));
862                 fflush(stdout);
863         }
864         if (__load_resource(s, cfg))
865                 return 0; /* success */
866         ast_log(LOG_WARNING, "Loading module %s failed!\n", s);
867         return -1;
868 }
869
870 static const char *loadorder[] =
871 {
872         "res_",
873         "pbx_",
874         "chan_",
875         NULL,
876 };
877
878 int load_modules(const int preload_only)
879 {
880         struct ast_config *cfg;
881         int x;
882
883         if (option_verbose) {
884                 ast_verbose(preload_only ?
885                         "Asterisk Dynamic Loader loading preload modules:\n" :
886                         "Asterisk Dynamic Loader Starting:\n");
887         }
888
889         if (0)
890                 check_symbols();
891
892         cfg = ast_config_load(AST_MODULE_CONFIG);
893
894         if (cfg) {
895                 const char *cmd = preload_only ? "preload" : "load";
896                 struct ast_variable *v;
897                 /* Load explicitly defined modules */
898                 for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
899                         if (strcasecmp(v->name, cmd)) /* not what we are looking for */
900                                 continue;
901                         if (print_and_load(v->value, cfg)) {    /* XXX really fatal ? */
902                                 ast_config_destroy(cfg);
903                                 return -1;
904                         }
905                 }
906         }
907
908         if (preload_only)
909                 goto done;
910
911         if (cfg && !ast_true(ast_variable_retrieve(cfg, "modules", "autoload")))
912                 /* no autoload */
913                 goto done;
914         /*
915          * Load all modules. To help resolving dependencies, we load modules
916          * in the order defined by loadorder[], with the final step for
917          * all modules with other prefixes.
918          * (XXX the new loader does not need this).
919          */
920
921         for (x=0; x<sizeof(loadorder) / sizeof(loadorder[0]); x++) {
922                 struct dirent *d;
923                 DIR *mods = opendir(ast_config_AST_MODULE_DIR);
924                 const char *base = loadorder[x];
925                 int lx = base ? strlen(base) : 0;
926
927                 if (!mods) {
928                         if (!ast_opt_quiet)
929                                 ast_log(LOG_WARNING, "Unable to open modules directory %s.\n",
930                                         ast_config_AST_MODULE_DIR);
931                         break; /* suffices to try once! */
932                 }
933                 while((d = readdir(mods))) {
934                         int ld = strlen(d->d_name);
935                         /* Must end in .so to load it.  */
936                         if (ld > 3 && (!base || !strncasecmp(d->d_name, base, lx)) && 
937                                         !strcasecmp(d->d_name + ld - 3, ".so") &&
938                                         !resource_exists(d->d_name, 1)) {
939                                 /* It's a shared library, check if we are allowed to load it
940                                  * (very inefficient, but oh well).
941                                  */
942                                 if (cfg) {
943                                         struct ast_variable *v;
944                                         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
945                                                 if (!strcasecmp(v->name, "noload") &&
946                                                                 !strcasecmp(v->value, d->d_name)) 
947                                                         break;
948                                         }
949                                         if (v) {
950                                                 if (option_verbose) {
951                                                         ast_verbose( VERBOSE_PREFIX_1 "[skipping %s]\n",
952                                                                         d->d_name);
953                                                         fflush(stdout);
954                                                 }
955                                                 continue;
956                                         }
957                                         
958                                 }
959                                 if (print_and_load(d->d_name, cfg)) {
960                                         ast_config_destroy(cfg);
961                                         return -1;
962                                 }
963                         }
964                 }
965                 closedir(mods);
966         }
967 done:
968         fixup("load_modules");
969         ast_config_destroy(cfg);
970         return 0;
971 }
972
973 void ast_update_use_count(void)
974 {
975         /* Notify any module monitors that the use count for a 
976            resource has changed */
977         struct loadupdate *m;
978         if (AST_LIST_LOCK(&module_list))
979                 ast_log(LOG_WARNING, "Failed to lock\n");
980         AST_LIST_TRAVERSE(&updaters, m, next)
981                 m->updater();
982         AST_LIST_UNLOCK(&module_list);
983 }
984
985 int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like),
986                            const char *like)
987 {
988         struct module *cur;
989         int unlock = -1;
990         int total_mod_loaded = 0;
991
992         if (ast_mutex_trylock(&module_list.lock))
993                 unlock = 0;
994         AST_LIST_TRAVERSE(&module_list, cur, next)
995                 total_mod_loaded += modentry(cur->resource, cur->cb.description(), cur->cb.usecount(), like);
996         if (unlock)
997                 AST_LIST_UNLOCK(&module_list);
998
999         return total_mod_loaded;
1000 }
1001
1002 int ast_loader_register(int (*v)(void)) 
1003 {
1004         /* XXX Should be more flexible here, taking > 1 verboser XXX */
1005         struct loadupdate *tmp; 
1006         if (!(tmp = ast_malloc(sizeof(*tmp))))
1007                 return -1;
1008         tmp->updater = v;
1009         if (AST_LIST_LOCK(&module_list))
1010                 ast_log(LOG_WARNING, "Failed to lock\n");
1011         AST_LIST_INSERT_HEAD(&updaters, tmp, next);
1012         AST_LIST_UNLOCK(&module_list);
1013         return 0;
1014 }
1015
1016 int ast_loader_unregister(int (*v)(void))
1017 {
1018         struct loadupdate *cur;
1019
1020         if (AST_LIST_LOCK(&module_list))
1021                 ast_log(LOG_WARNING, "Failed to lock\n");
1022         AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, next) {
1023                 if (cur->updater == v)  {
1024                         AST_LIST_REMOVE_CURRENT(&updaters, next);
1025                         break;
1026                 }
1027         }
1028         AST_LIST_TRAVERSE_SAFE_END;
1029         AST_LIST_UNLOCK(&module_list);
1030         return cur ? 0 : -1;
1031 }