cleanup the show uptime code, and minor changes
[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/lock.h"
47 #ifdef DLFCNCOMPAT
48 #include "asterisk/dlfcn-compat.h"
49 #else
50 #include <dlfcn.h>
51 #endif
52 #include "asterisk/md5.h"
53
54 #ifndef RTLD_NOW
55 #define RTLD_NOW 0
56 #endif
57
58 AST_MUTEX_DEFINE_STATIC(modlock);
59 AST_MUTEX_DEFINE_STATIC(reloadlock);
60
61 static struct module *module_list=NULL;
62 static int modlistver = 0;
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 struct module {
69         int (*load_module)(void);
70         int (*unload_module)(void);
71         int (*usecount)(void);
72         char *(*description)(void);
73         char *(*key)(void);
74         int (*reload)(void);
75         void *lib;
76         char resource[256];
77         struct module *next;
78 };
79
80 static struct loadupdate {
81         int (*updater)(void);
82         struct loadupdate *next;
83 } *updaters = NULL;
84
85 static int printdigest(unsigned char *d)
86 {
87         int x;
88         char buf[256];
89         char buf2[16];
90         snprintf(buf, sizeof(buf), "Unexpected signature:");
91         for (x=0; x<16; x++) {
92                 snprintf(buf2, sizeof(buf2), " %02x", *(d++));
93                 strcat(buf, buf2);
94         }
95         strcat(buf, "\n");
96         ast_log(LOG_DEBUG, "%s", buf);
97         return 0;
98 }
99
100 static int key_matches(unsigned char *key1, unsigned char *key2)
101 {
102         int match = 1;
103         int x;
104         for (x=0; x<16; x++) {
105                 match &= (key1[x] == key2[x]);
106         }
107         return match;
108 }
109
110 static int verify_key(unsigned char *key)
111 {
112         struct MD5Context c;
113         unsigned char digest[16];
114         MD5Init(&c);
115         MD5Update(&c, key, strlen((char *)key));
116         MD5Final(digest, &c);
117         if (key_matches(expected_key, digest))
118                 return 0;
119         printdigest(digest);
120         return -1;
121 }
122
123 int ast_unload_resource(const char *resource_name, int force)
124 {
125         struct module *m, *ml = NULL;
126         int res = -1;
127         if (ast_mutex_lock(&modlock))
128                 ast_log(LOG_WARNING, "Failed to lock\n");
129         m = module_list;
130         while(m) {
131                 if (!strcasecmp(m->resource, resource_name)) {
132                         if ((res = m->usecount()) > 0)  {
133                                 if (force) 
134                                         ast_log(LOG_WARNING, "Warning:  Forcing removal of module %s with use count %d\n", resource_name, res);
135                                 else {
136                                         ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name, res);
137                                         ast_mutex_unlock(&modlock);
138                                         return -1;
139                                 }
140                         }
141                         res = m->unload_module();
142                         if (res) {
143                                 ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
144                                 if (force <= AST_FORCE_FIRM) {
145                                         ast_mutex_unlock(&modlock);
146                                         return -1;
147                                 } else
148                                         ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
149                         }
150                         if (ml)
151                                 ml->next = m->next;
152                         else
153                                 module_list = m->next;
154                         dlclose(m->lib);
155                         free(m);
156                         break;
157                 }
158                 ml = m;
159                 m = m->next;
160         }
161         modlistver = rand();
162         ast_mutex_unlock(&modlock);
163         ast_update_use_count();
164         return res;
165 }
166
167 char *ast_module_helper(char *line, char *word, int pos, int state, int rpos, int needsreload)
168 {
169         struct module *m;
170         int which=0;
171         char *ret;
172
173         if (pos != rpos)
174                 return NULL;
175         ast_mutex_lock(&modlock);
176         m = module_list;
177         while(m) {
178                 if (!strncasecmp(word, m->resource, strlen(word)) && (m->reload || !needsreload)) {
179                         if (++which > state)
180                                 break;
181                 }
182                 m = m->next;
183         }
184         if (m) {
185                 ret = strdup(m->resource);
186         } else {
187                 ret = NULL;
188                 if (!strncasecmp(word, "extconfig", strlen(word))) {
189                         if (++which > state)
190                                 ret = strdup("extconfig");
191                 } else if (!strncasecmp(word, "manager", strlen(word))) {
192                         if (++which > state)
193                                 ret = strdup("manager");
194                 } else if (!strncasecmp(word, "enum", strlen(word))) {
195                         if (++which > state)
196                                 ret = strdup("enum");
197                 } else if (!strncasecmp(word, "rtp", strlen(word))) {
198                         if (++which > state)
199                                 ret = strdup("rtp");
200                 }
201                         
202         }
203         ast_mutex_unlock(&modlock);
204         return ret;
205 }
206
207 int ast_module_reload(const char *name)
208 {
209         struct module *m;
210         int reloaded = 0;
211         int oldversion;
212         int (*reload)(void);
213         /* We'll do the logger and manager the favor of calling its reload here first */
214
215         if (ast_mutex_trylock(&reloadlock)) {
216                 ast_verbose("The previous reload command didn't finish yet\n");
217                 return -1;
218         }
219         if (!name || !strcasecmp(name, "extconfig")) {
220                 read_config_maps();
221                 reloaded = 2;
222         }
223         if (!name || !strcasecmp(name, "manager")) {
224                 reload_manager();
225                 reloaded = 2;
226         }
227         if (!name || !strcasecmp(name, "cdr")) {
228                 ast_cdr_engine_reload();
229                 reloaded = 2;
230         }
231         if (!name || !strcasecmp(name, "enum")) {
232                 ast_enum_reload();
233                 reloaded = 2;
234         }
235         if (!name || !strcasecmp(name, "rtp")) {
236                 ast_rtp_reload();
237                 reloaded = 2;
238         }
239         if (!name || !strcasecmp(name, "dnsmgr")) {
240                 dnsmgr_reload();
241                 reloaded = 2;
242         }
243         time(&ast_lastreloadtime);
244
245         ast_mutex_lock(&modlock);
246         oldversion = modlistver;
247         m = module_list;
248         while(m) {
249                 if (!name || !strcasecmp(name, m->resource)) {
250                         if (reloaded < 1)
251                                 reloaded = 1;
252                         reload = m->reload;
253                         ast_mutex_unlock(&modlock);
254                         if (reload) {
255                                 reloaded = 2;
256                                 if (option_verbose > 2) 
257                                         ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", m->resource, m->description());
258                                 reload();
259                         }
260                         ast_mutex_lock(&modlock);
261                         if (oldversion != modlistver)
262                                 break;
263                 }
264                 m = m->next;
265         }
266         ast_mutex_unlock(&modlock);
267         ast_mutex_unlock(&reloadlock);
268         return reloaded;
269 }
270
271 static int __load_resource(const char *resource_name, const struct ast_config *cfg)
272 {
273         static char fn[256];
274         int errors=0;
275         int res;
276         struct module *m;
277         int flags=RTLD_NOW;
278 #ifdef RTLD_GLOBAL
279         char *val;
280 #endif
281         unsigned char *key;
282         char tmp[80];
283
284         if (strncasecmp(resource_name, "res_", 4)) {
285 #ifdef RTLD_GLOBAL
286                 if (cfg) {
287                         if ((val = ast_variable_retrieve(cfg, "global", resource_name))
288                                         && ast_true(val))
289                                 flags |= RTLD_GLOBAL;
290                 }
291 #endif
292         } else {
293                 /* Resource modules are always loaded global and lazy */
294 #ifdef RTLD_GLOBAL
295                 flags = (RTLD_GLOBAL | RTLD_LAZY);
296 #else
297                 flags = RTLD_LAZY;
298 #endif
299         }
300         
301         if (ast_mutex_lock(&modlock))
302                 ast_log(LOG_WARNING, "Failed to lock\n");
303         m = module_list;
304         while(m) {
305                 if (!strcasecmp(m->resource, resource_name)) {
306                         ast_log(LOG_WARNING, "Module '%s' already exists\n", resource_name);
307                         ast_mutex_unlock(&modlock);
308                         return -1;
309                 }
310                 m = m->next;
311         }
312         m = malloc(sizeof(struct module));      
313         if (!m) {
314                 ast_log(LOG_WARNING, "Out of memory\n");
315                 ast_mutex_unlock(&modlock);
316                 return -1;
317         }
318         strncpy(m->resource, resource_name, sizeof(m->resource)-1);
319         if (resource_name[0] == '/') {
320                 strncpy(fn, resource_name, sizeof(fn)-1);
321         } else {
322                 snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_MODULE_DIR, resource_name);
323         }
324         m->lib = dlopen(fn, flags);
325         if (!m->lib) {
326                 ast_log(LOG_WARNING, "%s\n", dlerror());
327                 free(m);
328                 ast_mutex_unlock(&modlock);
329                 return -1;
330         }
331         m->load_module = dlsym(m->lib, "load_module");
332         if (m->load_module == NULL)
333                 m->load_module = dlsym(m->lib, "_load_module");
334         if (!m->load_module) {
335                 ast_log(LOG_WARNING, "No load_module in module %s\n", fn);
336                 errors++;
337         }
338         m->unload_module = dlsym(m->lib, "unload_module");
339         if (m->unload_module == NULL)
340                 m->unload_module = dlsym(m->lib, "_unload_module");
341         if (!m->unload_module) {
342                 ast_log(LOG_WARNING, "No unload_module in module %s\n", fn);
343                 errors++;
344         }
345         m->usecount = dlsym(m->lib, "usecount");
346         if (m->usecount == NULL)
347                 m->usecount = dlsym(m->lib, "_usecount");
348         if (!m->usecount) {
349                 ast_log(LOG_WARNING, "No usecount in module %s\n", fn);
350                 errors++;
351         }
352         m->description = dlsym(m->lib, "description");
353         if (m->description == NULL)
354                 m->description = dlsym(m->lib, "_description");
355         if (!m->description) {
356                 ast_log(LOG_WARNING, "No description in module %s\n", fn);
357                 errors++;
358         }
359         m->key = dlsym(m->lib, "key");
360         if (m->key == NULL)
361                 m->key = dlsym(m->lib, "_key");
362         if (!m->key) {
363                 ast_log(LOG_WARNING, "No key routine in module %s\n", fn);
364                 errors++;
365         }
366
367         m->reload = dlsym(m->lib, "reload");
368         if (m->reload == NULL)
369                 m->reload = dlsym(m->lib, "_reload");
370
371         if (!m->key || !(key = (unsigned char *) m->key())) {
372                 ast_log(LOG_WARNING, "Key routine returned NULL in module %s\n", fn);
373                 key = NULL;
374                 errors++;
375         }
376         if (key && verify_key(key)) {
377                 ast_log(LOG_WARNING, "Unexpected key returned by module %s\n", fn);
378                 errors++;
379         }
380         if (errors) {
381                 ast_log(LOG_WARNING, "%d error%s loading module %s, aborted\n", errors, (errors != 1) ? "s" : "", fn);
382                 dlclose(m->lib);
383                 free(m);
384                 ast_mutex_unlock(&modlock);
385                 return -1;
386         }
387         if (!ast_fully_booted) {
388                 if (option_verbose) 
389                         ast_verbose( " => (%s)\n", term_color(tmp, m->description(), COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
390                 if (ast_opt_console && !option_verbose)
391                         ast_verbose( ".");
392         } else {
393                 if (option_verbose)
394                         ast_verbose(VERBOSE_PREFIX_1 "Loaded %s => (%s)\n", fn, m->description());
395         }
396
397         /* add module 'm' to end of module_list chain
398            so reload commands will be issued in same order modules were loaded */
399         m->next = NULL;
400         if (module_list == NULL) {
401                 /* empty list so far, add at front */
402                 module_list = m;
403         }
404         else {
405                 struct module *i;
406                 /* find end of chain, and add there */
407                 for (i = module_list; i->next; i = i->next)
408                         ;
409                 i->next = m;
410         }
411         
412         modlistver = rand();
413         ast_mutex_unlock(&modlock);
414         if ((res = m->load_module())) {
415                 ast_log(LOG_WARNING, "%s: load_module failed, returning %d\n", m->resource, res);
416                 ast_unload_resource(resource_name, 0);
417                 return -1;
418         }
419         ast_update_use_count();
420         return 0;
421 }
422
423 int ast_load_resource(const char *resource_name)
424 {
425         int o;
426         struct ast_config *cfg = NULL;
427         int res;
428
429         /* Keep the module file parsing silent */
430         o = option_verbose;
431         option_verbose = 0;
432         cfg = ast_config_load(AST_MODULE_CONFIG);
433         option_verbose = o;
434         res = __load_resource(resource_name, cfg);
435         if (cfg)
436                 ast_config_destroy(cfg);
437         return res;
438 }       
439
440 static int ast_resource_exists(char *resource)
441 {
442         struct module *m;
443         if (ast_mutex_lock(&modlock))
444                 ast_log(LOG_WARNING, "Failed to lock\n");
445         m = module_list;
446         while(m) {
447                 if (!strcasecmp(resource, m->resource))
448                         break;
449                 m = m->next;
450         }
451         ast_mutex_unlock(&modlock);
452         if (m)
453                 return -1;
454         else
455                 return 0;
456 }
457
458 static const char *loadorder[] =
459 {
460         "res_",
461         "chan_",
462         "pbx_",
463         NULL,
464 };
465
466 int load_modules(const int preload_only)
467 {
468         struct ast_config *cfg;
469         struct ast_variable *v;
470         char tmp[80];
471
472         if (option_verbose) {
473                 if (preload_only)
474                         ast_verbose("Asterisk Dynamic Loader loading preload modules:\n");
475                 else
476                         ast_verbose("Asterisk Dynamic Loader Starting:\n");
477         }
478
479         cfg = ast_config_load(AST_MODULE_CONFIG);
480         if (cfg) {
481                 int doload;
482
483                 /* Load explicitly defined modules */
484                 for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
485                         doload = 0;
486
487                         if (preload_only)
488                                 doload = !strcasecmp(v->name, "preload");
489                         else
490                                 doload = !strcasecmp(v->name, "load");
491
492                        if (doload) {
493                                 if (option_debug && !option_verbose)
494                                         ast_log(LOG_DEBUG, "Loading module %s\n", v->value);
495                                 if (option_verbose) {
496                                         ast_verbose(VERBOSE_PREFIX_1 "[%s]", term_color(tmp, v->value, COLOR_BRWHITE, 0, sizeof(tmp)));
497                                         fflush(stdout);
498                                 }
499                                 if (__load_resource(v->value, cfg)) {
500                                         ast_log(LOG_WARNING, "Loading module %s failed!\n", v->value);
501                                         ast_config_destroy(cfg);
502                                         return -1;
503                                 }
504                         }
505                 }
506         }
507
508         if (preload_only) {
509                 ast_config_destroy(cfg);
510                 return 0;
511         }
512
513         if (!cfg || ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
514                 /* Load all modules */
515                 DIR *mods;
516                 struct dirent *d;
517                 int x;
518
519                 /* Loop through each order */
520                 for (x=0; x<sizeof(loadorder) / sizeof(loadorder[0]); x++) {
521                         mods = opendir((char *)ast_config_AST_MODULE_DIR);
522                         if (mods) {
523                                 while((d = readdir(mods))) {
524                                         /* Must end in .so to load it.  */
525                                         if ((strlen(d->d_name) > 3) && 
526                                             (!loadorder[x] || !strncasecmp(d->d_name, loadorder[x], strlen(loadorder[x]))) && 
527                                             !strcasecmp(d->d_name + strlen(d->d_name) - 3, ".so") &&
528                                                 !ast_resource_exists(d->d_name)) {
529                                                 /* It's a shared library -- Just be sure we're allowed to load it -- kinda
530                                                    an inefficient way to do it, but oh well. */
531                                                 if (cfg) {
532                                                         v = ast_variable_browse(cfg, "modules");
533                                                         while(v) {
534                                                                 if (!strcasecmp(v->name, "noload") &&
535                                                                     !strcasecmp(v->value, d->d_name)) 
536                                                                         break;
537                                                                 v = v->next;
538                                                         }
539                                                         if (v) {
540                                                                 if (option_verbose) {
541                                                                         ast_verbose( VERBOSE_PREFIX_1 "[skipping %s]\n", d->d_name);
542                                                                         fflush(stdout);
543                                                                 }
544                                                                 continue;
545                                                         }
546                                                         
547                                                 }
548                                                 if (option_debug && !option_verbose)
549                                                         ast_log(LOG_DEBUG, "Loading module %s\n", d->d_name);
550                                                 if (option_verbose) {
551                                                         ast_verbose( VERBOSE_PREFIX_1 "[%s]", term_color(tmp, d->d_name, COLOR_BRWHITE, 0, sizeof(tmp)));
552                                                         fflush(stdout);
553                                                 }
554                                                 if (__load_resource(d->d_name, cfg)) {
555                                                         ast_log(LOG_WARNING, "Loading module %s failed!\n", d->d_name);
556                                                         if (cfg)
557                                                                 ast_config_destroy(cfg);
558                                                         return -1;
559                                                 }
560                                         }
561                                 }
562                                 closedir(mods);
563                         } else {
564                                 if (!ast_opt_quiet)
565                                         ast_log(LOG_WARNING, "Unable to open modules directory %s.\n", (char *)ast_config_AST_MODULE_DIR);
566                         }
567                 }
568         } 
569         ast_config_destroy(cfg);
570         return 0;
571 }
572
573 void ast_update_use_count(void)
574 {
575         /* Notify any module monitors that the use count for a 
576            resource has changed */
577         struct loadupdate *m;
578         if (ast_mutex_lock(&modlock))
579                 ast_log(LOG_WARNING, "Failed to lock\n");
580         m = updaters;
581         while(m) {
582                 m->updater();
583                 m = m->next;
584         }
585         ast_mutex_unlock(&modlock);
586         
587 }
588
589 int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like),
590                            const char *like)
591 {
592         struct module *m;
593         int unlock = -1;
594         int total_mod_loaded = 0;
595
596         if (ast_mutex_trylock(&modlock))
597                 unlock = 0;
598         m = module_list;
599         while (m) {
600                 total_mod_loaded += modentry(m->resource, m->description(), m->usecount(), like);
601                 m = m->next;
602         }
603         if (unlock)
604                 ast_mutex_unlock(&modlock);
605
606         return total_mod_loaded;
607 }
608
609 int ast_loader_register(int (*v)(void)) 
610 {
611         struct loadupdate *tmp;
612         /* XXX Should be more flexible here, taking > 1 verboser XXX */
613         if ((tmp = malloc(sizeof (struct loadupdate)))) {
614                 tmp->updater = v;
615                 if (ast_mutex_lock(&modlock))
616                         ast_log(LOG_WARNING, "Failed to lock\n");
617                 tmp->next = updaters;
618                 updaters = tmp;
619                 ast_mutex_unlock(&modlock);
620                 return 0;
621         }
622         return -1;
623 }
624
625 int ast_loader_unregister(int (*v)(void))
626 {
627         int res = -1;
628         struct loadupdate *tmp, *tmpl=NULL;
629         if (ast_mutex_lock(&modlock))
630                 ast_log(LOG_WARNING, "Failed to lock\n");
631         tmp = updaters;
632         while(tmp) {
633                 if (tmp->updater == v)  {
634                         if (tmpl)
635                                 tmpl->next = tmp->next;
636                         else
637                                 updaters = tmp->next;
638                         break;
639                 }
640                 tmpl = tmp;
641                 tmp = tmp->next;
642         }
643         if (tmp)
644                 res = 0;
645         ast_mutex_unlock(&modlock);
646         return res;
647 }