main/loader.c

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