fix documentation
[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  */
25
26 #include <stdio.h>
27 #include <dirent.h>
28 #include <unistd.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/module.h"
37 #include "asterisk/options.h"
38 #include "asterisk/config.h"
39 #include "asterisk/logger.h"
40 #include "asterisk/channel.h"
41 #include "asterisk/term.h"
42 #include "asterisk/manager.h"
43 #include "asterisk/cdr.h"
44 #include "asterisk/enum.h"
45 #include "asterisk/rtp.h"
46 #include "asterisk/http.h"
47 #include "asterisk/lock.h"
48 #ifdef DLFCNCOMPAT
49 #include "asterisk/dlfcn-compat.h"
50 #else
51 #include <dlfcn.h>
52 #endif
53 #include "asterisk/md5.h"
54 #include "asterisk/utils.h"
55
56 #ifndef RTLD_NOW
57 #define RTLD_NOW 0
58 #endif
59
60
61 static int modlistver = 0; /* increase whenever the list changes, to protect reload */
62
63 static unsigned char expected_key[] =
64 { 0x8e, 0x93, 0x22, 0x83, 0xf5, 0xc3, 0xc0, 0x75,
65   0xff, 0x8b, 0xa9, 0xbe, 0x7c, 0x43, 0x74, 0x63 };
66
67 /*
68  * All module symbols are in module_symbols.
69  * Modules are then linked in a list of struct module,
70  * whereas updaters are in a list of struct loadupdate.
71  *
72  * Both lists (basically, the entire loader) are protected by
73  * the lock in module_list.
74  *
75  * A second lock, reloadlock, is used to prevent concurrent reloads
76  */
77
78 struct module_symbols {
79         int (*load_module)(void);
80         int (*unload_module)(void);
81         int (*usecount)(void);
82         char *(*description)(void);
83         char *(*key)(void);
84         int (*reload)(void);
85 };
86
87 struct module {
88         AST_LIST_ENTRY(module) next;
89         struct module_symbols cb;
90         void *lib;              /* the shared lib */
91         char resource[256];
92 };
93
94
95 struct loadupdate {
96         AST_LIST_ENTRY(loadupdate) next;
97         int (*updater)(void);
98 };
99
100 static AST_LIST_HEAD_STATIC(module_list, module);
101 static AST_LIST_HEAD_STATIC(updaters, loadupdate);
102 AST_MUTEX_DEFINE_STATIC(reloadlock);
103
104 /*
105  * In addition to modules, the reload command handles some extra keywords
106  * which are listed here together with the corresponding handlers.
107  * This table is also used by the command completion code.
108  */
109 static struct reload_classes_t {
110         const char *name;
111         int (*reload_fn)(void);
112 } reload_classes[] = {  /* list in alpha order, longest match first */
113         { "cdr",        ast_cdr_engine_reload },
114         { "dnsmgr",     dnsmgr_reload },
115         { "extconfig",  read_config_maps },
116         { "enum",       ast_enum_reload },
117         { "manager",    reload_manager },
118         { "rtp",        ast_rtp_reload },
119         { "http",       ast_http_reload },
120         { NULL, NULL }
121 };
122
123 static int printdigest(const unsigned char *d)
124 {
125         int x, pos;
126         char buf[256]; /* large enough so we don't have to worry */
127
128         for (pos = 0, x=0; x<16; x++)
129                 pos += sprintf(buf + pos, " %02x", *d++);
130         ast_log(LOG_DEBUG, "Unexpected signature:%s\n", buf);
131         return 0;
132 }
133
134 static int key_matches(const unsigned char *key1, const unsigned char *key2)
135 {
136         int x;
137         for (x=0; x<16; x++) {
138                 if (key1[x] != key2[x]) /* mismatch - fail now. */
139                         return 0;
140         }
141         return 1;
142 }
143
144 static int verify_key(const unsigned char *key)
145 {
146         struct MD5Context c;
147         unsigned char digest[16];
148         MD5Init(&c);
149         MD5Update(&c, key, strlen((char *)key));
150         MD5Final(digest, &c);
151         if (key_matches(expected_key, digest))
152                 return 0;
153         printdigest(digest);
154         return -1;
155 }
156
157 int ast_unload_resource(const char *resource_name, int force)
158 {
159         struct module *cur;
160         int res = -1;
161         int error = 0;
162         if (AST_LIST_LOCK(&module_list)) /* XXX should fail here ? */
163                 ast_log(LOG_WARNING, "Failed to lock\n");
164         AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, cur, next) {
165                 struct module_symbols *m = &cur->cb;
166                 
167                 if (strcasecmp(cur->resource, resource_name))   /* not us */
168                         continue;
169                 if ((res = m->usecount()) > 0)  {
170                         if (force) 
171                                 ast_log(LOG_WARNING, "Warning:  Forcing removal of module %s with use count %d\n", resource_name, res);
172                         else {
173                                 ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name, res);
174                                 error = 1;
175                                 break;
176                         }
177                 }
178                 res = m->unload_module();
179                 if (res) {
180                         ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
181                         if (force <= AST_FORCE_FIRM) {
182                                 error = 1;
183                                 break;
184                         } else
185                                 ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
186                 }
187                 AST_LIST_REMOVE_CURRENT(&module_list, next);
188                 dlclose(cur->lib);
189                 free(cur);
190                 break;
191         }
192         AST_LIST_TRAVERSE_SAFE_END;
193         if (!error)
194                 modlistver++;
195         AST_LIST_UNLOCK(&module_list);
196         if (!error)     /* XXX maybe within the lock ? */
197                 ast_update_use_count();
198         return res;
199 }
200
201 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload)
202 {
203         struct module *cur;
204         int i, which=0, l = strlen(word);
205         char *ret = NULL;
206
207         if (pos != rpos)
208                 return NULL;
209         AST_LIST_LOCK(&module_list);
210         AST_LIST_TRAVERSE(&module_list, cur, next) {
211                 if (!strncasecmp(word, cur->resource, l) && (cur->cb.reload || !needsreload) &&
212                                 ++which > state) {
213                         ret = strdup(cur->resource);
214                         break;
215                 }
216         }
217         AST_LIST_UNLOCK(&module_list);
218         if (!ret) {
219                 for (i=0; !ret && reload_classes[i].name; i++) {
220                         if (!strncasecmp(word, reload_classes[i].name, l) && ++which > state)
221                                 ret = strdup(reload_classes[i].name);
222                 }
223         }
224         return ret;
225 }
226
227 int ast_module_reload(const char *name)
228 {
229         struct module *cur;
230         int res = 0; /* return value. 0 = not found, others, see below */
231         int i, oldversion;
232         int (*reload)(void);
233
234         if (ast_mutex_trylock(&reloadlock)) {
235                 ast_verbose("The previous reload command didn't finish yet\n");
236                 return -1;      /* reload already in progress */
237         }
238         /* Call "predefined" reload here first */
239         for (i = 0; reload_classes[i].name; i++) {
240                 if (!name || !strcasecmp(name, reload_classes[i].name)) {
241                         reload_classes[i].reload_fn();  /* XXX should check error ? */
242                         res = 2;        /* found and reloaded */
243                 }
244         }
245         ast_lastreloadtime = time(NULL);
246
247         AST_LIST_LOCK(&module_list);
248         oldversion = modlistver;
249         AST_LIST_TRAVERSE(&module_list, cur, next) {
250                 struct module_symbols *m = &cur->cb;
251                 if (name && strcasecmp(name, cur->resource))    /* not ours */
252                         continue;
253                 reload = m->reload;
254                 if (!reload) {  /* cannot be reloaded */
255                         if (res < 1)    /* store result if possible */
256                                 res = 1;        /* 1 = no reload() method */
257                         continue;
258                 }
259                 /* drop the lock and try a reload. if successful, break */
260                 AST_LIST_UNLOCK(&module_list);
261                 res = 2;
262                 if (option_verbose > 2) 
263                         ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", cur->resource, m->description());
264                 reload();
265                 AST_LIST_LOCK(&module_list);
266                 if (oldversion != modlistver) /* something changed, abort */
267                         break;
268         }
269         AST_LIST_UNLOCK(&module_list);
270         ast_mutex_unlock(&reloadlock);
271         return res;
272 }
273
274 static int resource_exists(const char *resource, int do_lock)
275 {
276         struct module *cur;
277         if (do_lock && AST_LIST_LOCK(&module_list))
278                 ast_log(LOG_WARNING, "Failed to lock\n");
279         AST_LIST_TRAVERSE(&module_list, cur, next) {
280                 if (!strcasecmp(resource, cur->resource))
281                         break;
282         }
283         if (do_lock)
284                 AST_LIST_UNLOCK(&module_list);
285         return cur ? -1 : 0;
286 }
287
288 /* lookup a symbol with or without leading '_', accept either form in input */
289 static void *find_symbol(struct module *m, const char *name, int verbose)
290 {
291         char *n1;
292         void *s;
293
294         if (name[0] == '_')
295                 name++;
296         if (!(n1 = alloca(strlen(name) + 2))) /* room for leading '_' and final '\0' */
297                 return NULL;
298         n1[0] = '_';
299         strcpy(n1+1, name);
300         s = dlsym(m->lib, n1+1);        /* try without '_' */
301         if (s == NULL)
302                 s = dlsym(m->lib, n1);
303         if (verbose && s == NULL)
304                 ast_log(LOG_WARNING, "No symbol '%s' in module '%s\n",
305                         n1, m->resource);
306         return s;
307 }
308
309 /* XXX cfg is only used for !res_* and #ifdef RTLD_GLOBAL */
310 static int __load_resource(const char *resource_name, const struct ast_config *cfg)
311 {
312         static char fn[256];
313         int errors=0;
314         int res;
315         struct module *cur;
316         struct module_symbols *m;
317         int flags=RTLD_NOW;
318         unsigned char *key;
319         char tmp[80];
320
321         if (strncasecmp(resource_name, "res_", 4)) {
322 #ifdef RTLD_GLOBAL
323                 if (cfg) {
324                         char *val;
325                         if ((val = ast_variable_retrieve(cfg, "global", resource_name))
326                                         && ast_true(val))
327                                 flags |= RTLD_GLOBAL;
328                 }
329 #endif
330         } else {
331                 /* Resource modules are always loaded global and lazy */
332 #ifdef RTLD_GLOBAL
333                 flags = (RTLD_GLOBAL | RTLD_LAZY);
334 #else
335                 flags = RTLD_LAZY;
336 #endif
337         }
338         
339         if (AST_LIST_LOCK(&module_list))
340                 ast_log(LOG_WARNING, "Failed to lock\n");
341         if (resource_exists(resource_name, 0)) {
342                 ast_log(LOG_WARNING, "Module '%s' already exists\n", resource_name);
343                 AST_LIST_UNLOCK(&module_list);
344                 return -1;
345         }
346         if (!(cur = ast_calloc(1, sizeof(*cur)))) {
347                 AST_LIST_UNLOCK(&module_list);
348                 return -1;
349         }
350         m = &cur->cb;
351         ast_copy_string(cur->resource, resource_name, sizeof(cur->resource));
352         if (resource_name[0] == '/')
353                 ast_copy_string(fn, resource_name, sizeof(fn));
354         else
355                 snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR, resource_name);
356         cur->lib = dlopen(fn, flags);
357         if (!cur->lib) {
358                 ast_log(LOG_WARNING, "%s\n", dlerror());
359                 free(cur);
360                 AST_LIST_UNLOCK(&module_list);
361                 return -1;
362         }
363         m->load_module = find_symbol(cur, "load_module", 1);
364         if (!m->load_module)
365                 errors++;
366         m->unload_module = find_symbol(cur, "unload_module", 1);
367         if (!m->unload_module)
368                 errors++;
369         m->usecount = find_symbol(cur, "usecount", 1);
370         if (!m->usecount)
371                 errors++;
372         m->description = find_symbol(cur, "description", 1);
373         if (!m->description)
374                 errors++;
375         m->key = find_symbol(cur, "key", 1);
376         if (!m->key)
377                 errors++;
378         m->reload = find_symbol(cur, "reload", 0);
379         if (!m->key || !(key = (unsigned char *) m->key())) {
380                 ast_log(LOG_WARNING, "Key routine returned NULL in module %s\n", fn);
381                 key = NULL;
382                 errors++;
383         }
384         if (key && verify_key(key)) {
385                 ast_log(LOG_WARNING, "Unexpected key returned by module %s\n", fn);
386                 errors++;
387         }
388         if (errors) {
389                 ast_log(LOG_WARNING, "%d error%s loading module %s, aborted\n", errors, (errors != 1) ? "s" : "", fn);
390                 dlclose(cur->lib);
391                 free(cur);
392                 AST_LIST_UNLOCK(&module_list);
393                 return -1;
394         }
395         if (!ast_fully_booted) {
396                 if (option_verbose) 
397                         ast_verbose( " => (%s)\n", term_color(tmp, m->description(), COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
398                 if (ast_opt_console && !option_verbose)
399                         ast_verbose( ".");
400         } else {
401                 if (option_verbose)
402                         ast_verbose(VERBOSE_PREFIX_1 "Loaded %s => (%s)\n", fn, m->description());
403         }
404
405         AST_LIST_INSERT_TAIL(&module_list, cur, next);
406         /* add module to end of module_list chain
407            so reload commands will be issued in same order modules were loaded */
408         
409         modlistver++;
410         AST_LIST_UNLOCK(&module_list);
411         if ((res = m->load_module())) {
412                 ast_log(LOG_WARNING, "%s: load_module failed, returning %d\n", resource_name, res);
413                 ast_unload_resource(resource_name, 0);
414                 return -1;
415         }
416         ast_update_use_count();
417         return 0;
418 }
419
420 int ast_load_resource(const char *resource_name)
421 {
422         int res, o = option_verbose;
423         struct ast_config *cfg = NULL;
424
425         option_verbose = 0;     /* Keep the module file parsing silent */
426         cfg = ast_config_load(AST_MODULE_CONFIG);
427         option_verbose = o;     /* restore verbosity */
428         res = __load_resource(resource_name, cfg);
429         if (cfg)
430                 ast_config_destroy(cfg);
431         return res;
432 }       
433
434 /* if enabled, log and output on console the module's name, and try load it */
435 static int print_and_load(const char *s, struct ast_config *cfg)
436 {
437         char tmp[80];
438
439         if (option_debug && !option_verbose)
440                 ast_log(LOG_DEBUG, "Loading module %s\n", s);
441         if (option_verbose) {
442                 ast_verbose(VERBOSE_PREFIX_1 "[%s]",
443                         term_color(tmp, s, COLOR_BRWHITE, 0, sizeof(tmp)));
444                 fflush(stdout);
445         }
446         if (!__load_resource(s, cfg))
447                 return 0; /* success */
448         ast_log(LOG_WARNING, "Loading module %s failed!\n", s);
449         return -1;
450 }
451
452 static const char *loadorder[] =
453 {
454         "res_",
455         "pbx_",
456         "chan_",
457         NULL,
458 };
459
460 int load_modules(const int preload_only)
461 {
462         struct ast_config *cfg;
463         struct ast_variable *v;
464         int x;
465
466         if (option_verbose) {
467                 ast_verbose(preload_only ?
468                         "Asterisk Dynamic Loader loading preload modules:\n" :
469                         "Asterisk Dynamic Loader Starting:\n");
470         }
471
472         cfg = ast_config_load(AST_MODULE_CONFIG);
473         if (cfg) {
474                 const char *cmd = preload_only ? "preload" : "load";
475                 /* Load explicitly defined modules */
476                 for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
477                         if (strcasecmp(v->name, cmd)) /* not what we are looking for */
478                                 continue;
479                         if (print_and_load(v->value, cfg)) {    /* XXX really fatal ? */
480                                 ast_config_destroy(cfg);
481                                 return -1;
482                         }
483                 }
484         }
485
486         if (preload_only) {
487                 ast_config_destroy(cfg);
488                 return 0;
489         }
490
491         if (cfg && !ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
492                 /* no autoload */
493                 ast_config_destroy(cfg);
494                 return 0;
495         }
496         /*
497          * Load all modules. To help resolving dependencies, we load modules
498          * in the order defined by loadorder[], with the final step for
499          * all modules with other prefixes.
500          * (XXX the new loader does not need this).
501          */
502
503         for (x=0; x<sizeof(loadorder) / sizeof(loadorder[0]); x++) {
504                 struct dirent *d;
505                 DIR *mods = opendir(ast_config_AST_MODULE_DIR);
506                 const char *base = loadorder[x];
507                 int lx = base ? strlen(base) : 0;
508
509                 if (!mods) {
510                         if (!ast_opt_quiet)
511                                 ast_log(LOG_WARNING, "Unable to open modules directory %s.\n",
512                                         ast_config_AST_MODULE_DIR);
513                         break; /* suffices to try once! */
514                 }
515                 while((d = readdir(mods))) {
516                         int ld = strlen(d->d_name);
517                         /* Must end in .so to load it.  */
518                         if (ld > 3 && (!base || !strncasecmp(d->d_name, base, lx)) && 
519                                         !strcasecmp(d->d_name + ld - 3, ".so") &&
520                                         !resource_exists(d->d_name, 1)) {
521                                 /* It's a shared library, check if we are allowed to load it
522                                  * (very inefficient, but oh well.
523                                  */
524                                 if (cfg) {
525                                         for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
526                                                 if (!strcasecmp(v->name, "noload") &&
527                                                                 !strcasecmp(v->value, d->d_name)) 
528                                                         break;
529                                         }
530                                         if (v) {
531                                                 if (option_verbose) {
532                                                         ast_verbose( VERBOSE_PREFIX_1 "[skipping %s]\n",
533                                                                         d->d_name);
534                                                         fflush(stdout);
535                                                 }
536                                                 continue;
537                                         }
538                                         
539                                 }
540                                 if (print_and_load(d->d_name, cfg)) {
541                                         ast_config_destroy(cfg);
542                                         return -1;
543                                 }
544                         }
545                 }
546                 closedir(mods);
547         }
548         ast_config_destroy(cfg);
549         return 0;
550 }
551
552 void ast_update_use_count(void)
553 {
554         /* Notify any module monitors that the use count for a 
555            resource has changed */
556         struct loadupdate *m;
557         if (AST_LIST_LOCK(&module_list))
558                 ast_log(LOG_WARNING, "Failed to lock\n");
559         AST_LIST_TRAVERSE(&updaters, m, next)
560                 m->updater();
561         AST_LIST_UNLOCK(&module_list);
562         
563 }
564
565 int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like),
566                            const char *like)
567 {
568         struct module *cur;
569         int unlock = -1;
570         int total_mod_loaded = 0;
571
572         if (ast_mutex_trylock(&module_list.lock))
573                 unlock = 0;
574         AST_LIST_TRAVERSE(&module_list, cur, next)
575                 total_mod_loaded += modentry(cur->resource, cur->cb.description(), cur->cb.usecount(), like);
576         if (unlock)
577                 AST_LIST_UNLOCK(&module_list);
578
579         return total_mod_loaded;
580 }
581
582 int ast_loader_register(int (*v)(void)) 
583 {
584         /* XXX Should be more flexible here, taking > 1 verboser XXX */
585         struct loadupdate *tmp; 
586         if (!(tmp = ast_malloc(sizeof(*tmp))))
587                 return -1;
588         tmp->updater = v;
589         if (AST_LIST_LOCK(&module_list))
590                 ast_log(LOG_WARNING, "Failed to lock\n");
591         AST_LIST_INSERT_HEAD(&updaters, tmp, next);
592         AST_LIST_UNLOCK(&module_list);
593         return 0;
594 }
595
596 int ast_loader_unregister(int (*v)(void))
597 {
598         struct loadupdate *cur;
599
600         if (AST_LIST_LOCK(&module_list))
601                 ast_log(LOG_WARNING, "Failed to lock\n");
602         AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, next) {
603                 if (cur->updater == v)  {
604                         AST_LIST_REMOVE_CURRENT(&updaters, next);
605                         break;
606                 }
607         }
608         AST_LIST_TRAVERSE_SAFE_END;
609         AST_LIST_UNLOCK(&module_list);
610         return cur ? 0 : -1;
611 }