00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #include "asterisk.h"
00031
00032 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 104596 $")
00033
00034 #include <stdio.h>
00035 #include <dirent.h>
00036 #include <unistd.h>
00037 #include <stdlib.h>
00038 #include <errno.h>
00039 #include <string.h>
00040
00041 #include "asterisk/linkedlists.h"
00042 #include "asterisk/module.h"
00043 #include "asterisk/options.h"
00044 #include "asterisk/config.h"
00045 #include "asterisk/logger.h"
00046 #include "asterisk/channel.h"
00047 #include "asterisk/term.h"
00048 #include "asterisk/manager.h"
00049 #include "asterisk/cdr.h"
00050 #include "asterisk/enum.h"
00051 #include "asterisk/rtp.h"
00052 #include "asterisk/http.h"
00053 #include "asterisk/lock.h"
00054
00055 #ifdef DLFCNCOMPAT
00056 #include "asterisk/dlfcn-compat.h"
00057 #else
00058 #include <dlfcn.h>
00059 #endif
00060
00061 #include "asterisk/md5.h"
00062 #include "asterisk/utils.h"
00063
00064 #ifndef RTLD_NOW
00065 #define RTLD_NOW 0
00066 #endif
00067
00068 struct ast_module_user {
00069 struct ast_channel *chan;
00070 AST_LIST_ENTRY(ast_module_user) entry;
00071 };
00072
00073 AST_LIST_HEAD(module_user_list, ast_module_user);
00074
00075 static unsigned char expected_key[] =
00076 { 0x87, 0x76, 0x79, 0x35, 0x23, 0xea, 0x3a, 0xd3,
00077 0x25, 0x2a, 0xbb, 0x35, 0x87, 0xe4, 0x22, 0x24 };
00078
00079 static char buildopt_sum[33] = AST_BUILDOPT_SUM;
00080
00081 static unsigned int embedding = 1;
00082
00083
00084
00085 struct ast_module {
00086 const struct ast_module_info *info;
00087 void *lib;
00088 int usecount;
00089 struct module_user_list users;
00090 struct {
00091 unsigned int running:1;
00092 unsigned int declined:1;
00093 } flags;
00094 AST_LIST_ENTRY(ast_module) entry;
00095 char resource[0];
00096 };
00097
00098 static AST_LIST_HEAD_STATIC(module_list, ast_module);
00099
00100 struct loadupdate {
00101 int (*updater)(void);
00102 AST_LIST_ENTRY(loadupdate) entry;
00103 };
00104
00105 static AST_LIST_HEAD_STATIC(updaters, loadupdate);
00106
00107 AST_MUTEX_DEFINE_STATIC(reloadlock);
00108
00109
00110
00111
00112
00113 struct ast_module *resource_being_loaded;
00114
00115
00116
00117 void ast_module_register(const struct ast_module_info *info)
00118 {
00119 struct ast_module *mod;
00120
00121 if (embedding) {
00122 if (!(mod = ast_calloc(1, sizeof(*mod) + strlen(info->name) + 1)))
00123 return;
00124 strcpy(mod->resource, info->name);
00125 } else {
00126 mod = resource_being_loaded;
00127 }
00128
00129 mod->info = info;
00130 AST_LIST_HEAD_INIT(&mod->users);
00131
00132
00133
00134
00135
00136
00137
00138 if (!embedding)
00139 AST_LIST_LOCK(&module_list);
00140
00141
00142
00143
00144
00145
00146 AST_LIST_INSERT_TAIL(&module_list, mod, entry);
00147
00148 if (!embedding)
00149 AST_LIST_UNLOCK(&module_list);
00150
00151
00152 *((struct ast_module **) &(info->self)) = mod;
00153 }
00154
00155 void ast_module_unregister(const struct ast_module_info *info)
00156 {
00157 struct ast_module *mod = NULL;
00158
00159
00160
00161
00162
00163 AST_LIST_LOCK(&module_list);
00164 AST_LIST_TRAVERSE_SAFE_BEGIN(&module_list, mod, entry) {
00165 if (mod->info == info) {
00166 AST_LIST_REMOVE_CURRENT(&module_list, entry);
00167 break;
00168 }
00169 }
00170 AST_LIST_TRAVERSE_SAFE_END;
00171 AST_LIST_UNLOCK(&module_list);
00172
00173 if (mod) {
00174 AST_LIST_HEAD_DESTROY(&mod->users);
00175 free(mod);
00176 }
00177 }
00178
00179 struct ast_module_user *__ast_module_user_add(struct ast_module *mod,
00180 struct ast_channel *chan)
00181 {
00182 struct ast_module_user *u = ast_calloc(1, sizeof(*u));
00183
00184 if (!u)
00185 return NULL;
00186
00187 u->chan = chan;
00188
00189 AST_LIST_LOCK(&mod->users);
00190 AST_LIST_INSERT_HEAD(&mod->users, u, entry);
00191 AST_LIST_UNLOCK(&mod->users);
00192
00193 ast_atomic_fetchadd_int(&mod->usecount, +1);
00194
00195 ast_update_use_count();
00196
00197 return u;
00198 }
00199
00200 void __ast_module_user_remove(struct ast_module *mod, struct ast_module_user *u)
00201 {
00202 AST_LIST_LOCK(&mod->users);
00203 AST_LIST_REMOVE(&mod->users, u, entry);
00204 AST_LIST_UNLOCK(&mod->users);
00205 ast_atomic_fetchadd_int(&mod->usecount, -1);
00206 free(u);
00207
00208 ast_update_use_count();
00209 }
00210
00211 void __ast_module_user_hangup_all(struct ast_module *mod)
00212 {
00213 struct ast_module_user *u;
00214
00215 AST_LIST_LOCK(&mod->users);
00216 while ((u = AST_LIST_REMOVE_HEAD(&mod->users, entry))) {
00217 ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD);
00218 ast_atomic_fetchadd_int(&mod->usecount, -1);
00219 free(u);
00220 }
00221 AST_LIST_UNLOCK(&mod->users);
00222
00223 ast_update_use_count();
00224 }
00225
00226
00227
00228
00229
00230
00231 static struct reload_classes {
00232 const char *name;
00233 int (*reload_fn)(void);
00234 } reload_classes[] = {
00235 { "cdr", ast_cdr_engine_reload },
00236 { "dnsmgr", dnsmgr_reload },
00237 { "extconfig", read_config_maps },
00238 { "enum", ast_enum_reload },
00239 { "manager", reload_manager },
00240 { "rtp", ast_rtp_reload },
00241 { "http", ast_http_reload },
00242 { "logger", logger_reload },
00243 { NULL, NULL }
00244 };
00245
00246 static int printdigest(const unsigned char *d)
00247 {
00248 int x, pos;
00249 char buf[256];
00250
00251 for (pos = 0, x = 0; x < 16; x++)
00252 pos += sprintf(buf + pos, " %02x", *d++);
00253
00254 ast_log(LOG_DEBUG, "Unexpected signature:%s\n", buf);
00255
00256 return 0;
00257 }
00258
00259 static int key_matches(const unsigned char *key1, const unsigned char *key2)
00260 {
00261 int x;
00262
00263 for (x = 0; x < 16; x++) {
00264 if (key1[x] != key2[x])
00265 return 0;
00266 }
00267
00268 return 1;
00269 }
00270
00271 static int verify_key(const unsigned char *key)
00272 {
00273 struct MD5Context c;
00274 unsigned char digest[16];
00275
00276 MD5Init(&c);
00277 MD5Update(&c, key, strlen((char *)key));
00278 MD5Final(digest, &c);
00279
00280 if (key_matches(expected_key, digest))
00281 return 0;
00282
00283 printdigest(digest);
00284
00285 return -1;
00286 }
00287
00288 static int resource_name_match(const char *name1_in, const char *name2_in)
00289 {
00290 char *name1 = (char *) name1_in;
00291 char *name2 = (char *) name2_in;
00292
00293
00294 if (!strcasecmp(name1 + strlen(name1) - 3, ".so")) {
00295 name1 = ast_strdupa(name1);
00296 name1[strlen(name1) - 3] = '\0';
00297 }
00298 if (!strcasecmp(name2 + strlen(name2) - 3, ".so")) {
00299 name2 = ast_strdupa(name2);
00300 name2[strlen(name2) - 3] = '\0';
00301 }
00302
00303 return strcasecmp(name1, name2);
00304 }
00305
00306 static struct ast_module *find_resource(const char *resource, int do_lock)
00307 {
00308 struct ast_module *cur;
00309
00310 if (do_lock)
00311 AST_LIST_LOCK(&module_list);
00312
00313 AST_LIST_TRAVERSE(&module_list, cur, entry) {
00314 if (!resource_name_match(resource, cur->resource))
00315 break;
00316 }
00317
00318 if (do_lock)
00319 AST_LIST_UNLOCK(&module_list);
00320
00321 return cur;
00322 }
00323
00324 #ifdef LOADABLE_MODULES
00325 static void unload_dynamic_module(struct ast_module *mod)
00326 {
00327 void *lib = mod->lib;
00328
00329
00330
00331
00332
00333 if (lib)
00334 while (!dlclose(lib));
00335 }
00336
00337 static struct ast_module *load_dynamic_module(const char *resource_in, unsigned int global_symbols_only)
00338 {
00339 char fn[256];
00340 void *lib;
00341 struct ast_module *mod;
00342 char *resource = (char *) resource_in;
00343 unsigned int wants_global;
00344
00345 if (strcasecmp(resource + strlen(resource) - 3, ".so")) {
00346 resource = alloca(strlen(resource_in) + 3);
00347 strcpy(resource, resource_in);
00348 strcat(resource, ".so");
00349 }
00350
00351 snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR, resource);
00352
00353
00354
00355
00356
00357 if (!(resource_being_loaded = ast_calloc(1, sizeof(*resource_being_loaded) + strlen(resource) + 1)))
00358 return NULL;
00359
00360 strcpy(resource_being_loaded->resource, resource);
00361
00362
00363
00364 if (!strcasecmp(resource, "chan_h323.so") ||
00365 !strcasecmp(resource, "chan_oh323.so"))
00366 lib = dlopen(fn, RTLD_NOW | RTLD_LOCAL);
00367
00368 if (!(lib = dlopen(fn, RTLD_LAZY | RTLD_LOCAL))) {
00369 ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
00370 free(resource_being_loaded);
00371 return NULL;
00372 }
00373
00374
00375
00376
00377
00378
00379
00380
00381 if (resource_being_loaded != (mod = AST_LIST_LAST(&module_list))) {
00382 ast_log(LOG_WARNING, "Module '%s' did not register itself during load\n", resource_in);
00383
00384 while (!dlclose(lib));
00385
00386
00387 return NULL;
00388 }
00389
00390 wants_global = ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS);
00391
00392
00393
00394 if (global_symbols_only && !wants_global) {
00395 while (!dlclose(lib));
00396 return NULL;
00397 }
00398
00399
00400
00401
00402
00403 #if defined(HAVE_RTLD_NOLOAD) && !defined(__Darwin__)
00404 if (!dlopen(fn, RTLD_NOLOAD | (wants_global ? RTLD_LAZY | RTLD_GLOBAL : RTLD_NOW | RTLD_LOCAL))) {
00405 ast_log(LOG_WARNING, "Unable to promote flags on module '%s': %s\n", resource_in, dlerror());
00406 while (!dlclose(lib));
00407 free(resource_being_loaded);
00408 return NULL;
00409 }
00410 #else
00411 while (!dlclose(lib));
00412 resource_being_loaded = NULL;
00413
00414
00415
00416 if (!(resource_being_loaded = ast_calloc(1, sizeof(*resource_being_loaded) + strlen(resource) + 1)))
00417 return NULL;
00418
00419 strcpy(resource_being_loaded->resource, resource);
00420
00421 if (!(lib = dlopen(fn, wants_global ? RTLD_LAZY | RTLD_GLOBAL : RTLD_NOW | RTLD_LOCAL))) {
00422 ast_log(LOG_WARNING, "Error loading module '%s': %s\n", resource_in, dlerror());
00423 free(resource_being_loaded);
00424 return NULL;
00425 }
00426
00427
00428
00429
00430 #endif
00431
00432 AST_LIST_LAST(&module_list)->lib = lib;
00433 resource_being_loaded = NULL;
00434
00435 return AST_LIST_LAST(&module_list);
00436 }
00437 #endif
00438
00439 void ast_module_shutdown(void)
00440 {
00441 struct ast_module *mod;
00442 AST_LIST_HEAD_NOLOCK_STATIC(local_module_list, ast_module);
00443
00444
00445
00446
00447
00448 AST_LIST_LOCK(&module_list);
00449 while ((mod = AST_LIST_REMOVE_HEAD(&module_list, entry)))
00450 AST_LIST_INSERT_HEAD(&local_module_list, mod, entry);
00451 AST_LIST_UNLOCK(&module_list);
00452
00453 while ((mod = AST_LIST_REMOVE_HEAD(&local_module_list, entry))) {
00454 if (mod->info->unload)
00455 mod->info->unload();
00456
00457
00458
00459 AST_LIST_HEAD_DESTROY(&mod->users);
00460 free(mod);
00461 }
00462 }
00463
00464 int ast_unload_resource(const char *resource_name, enum ast_module_unload_mode force)
00465 {
00466 struct ast_module *mod;
00467 int res = -1;
00468 int error = 0;
00469
00470 AST_LIST_LOCK(&module_list);
00471
00472 if (!(mod = find_resource(resource_name, 0))) {
00473 AST_LIST_UNLOCK(&module_list);
00474 return 0;
00475 }
00476
00477 if (!(mod->flags.running || mod->flags.declined))
00478 error = 1;
00479
00480 if (!mod->lib) {
00481 ast_log(LOG_WARNING, "Unloading embedded modules is not supported.\n");
00482 error = 1;
00483 }
00484
00485 if (!error && (mod->usecount > 0)) {
00486 if (force)
00487 ast_log(LOG_WARNING, "Warning: Forcing removal of module '%s' with use count %d\n",
00488 resource_name, mod->usecount);
00489 else {
00490 ast_log(LOG_WARNING, "Soft unload failed, '%s' has use count %d\n", resource_name,
00491 mod->usecount);
00492 error = 1;
00493 }
00494 }
00495
00496 if (!error) {
00497 __ast_module_user_hangup_all(mod);
00498 res = mod->info->unload();
00499
00500 if (res) {
00501 ast_log(LOG_WARNING, "Firm unload failed for %s\n", resource_name);
00502 if (force <= AST_FORCE_FIRM)
00503 error = 1;
00504 else
00505 ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n");
00506 }
00507 }
00508
00509 if (!error)
00510 mod->flags.running = mod->flags.declined = 0;
00511
00512 AST_LIST_UNLOCK(&module_list);
00513
00514 #ifdef LOADABLE_MODULES
00515 if (!error)
00516 unload_dynamic_module(mod);
00517 #endif
00518
00519 if (!error)
00520 ast_update_use_count();
00521
00522 return res;
00523 }
00524
00525 char *ast_module_helper(const char *line, const char *word, int pos, int state, int rpos, int needsreload)
00526 {
00527 struct ast_module *cur;
00528 int i, which=0, l = strlen(word);
00529 char *ret = NULL;
00530
00531 if (pos != rpos)
00532 return NULL;
00533
00534 AST_LIST_LOCK(&module_list);
00535 AST_LIST_TRAVERSE(&module_list, cur, entry) {
00536 if (!strncasecmp(word, cur->resource, l) &&
00537 (cur->info->reload || !needsreload) &&
00538 ++which > state) {
00539 ret = strdup(cur->resource);
00540 break;
00541 }
00542 }
00543 AST_LIST_UNLOCK(&module_list);
00544
00545 if (!ret) {
00546 for (i=0; !ret && reload_classes[i].name; i++) {
00547 if (!strncasecmp(word, reload_classes[i].name, l) && ++which > state)
00548 ret = strdup(reload_classes[i].name);
00549 }
00550 }
00551
00552 return ret;
00553 }
00554
00555 int ast_module_reload(const char *name)
00556 {
00557 struct ast_module *cur;
00558 int res = 0;
00559 int i;
00560
00561 if (ast_mutex_trylock(&reloadlock)) {
00562 ast_verbose("The previous reload command didn't finish yet\n");
00563 return -1;
00564 }
00565 ast_lastreloadtime = time(NULL);
00566
00567
00568 for (i = 0; reload_classes[i].name; i++) {
00569 if (!name || !strcasecmp(name, reload_classes[i].name)) {
00570 reload_classes[i].reload_fn();
00571 res = 2;
00572 }
00573 }
00574
00575 if (name && res) {
00576 ast_mutex_unlock(&reloadlock);
00577 return res;
00578 }
00579
00580 AST_LIST_LOCK(&module_list);
00581 AST_LIST_TRAVERSE(&module_list, cur, entry) {
00582 const struct ast_module_info *info = cur->info;
00583
00584 if (name && resource_name_match(name, cur->resource))
00585 continue;
00586
00587 if (!cur->flags.running || cur->flags.declined) {
00588 if (!name)
00589 continue;
00590 ast_log(LOG_NOTICE, "The module '%s' was not properly initialized. "
00591 "Before reloading the module, you must run \"module load %s\" "
00592 "and fix whatever is preventing the module from being initialized.\n",
00593 name, name);
00594 res = 2;
00595 break;
00596 }
00597
00598 if (!info->reload) {
00599 if (res < 1)
00600 res = 1;
00601 continue;
00602 }
00603
00604 res = 2;
00605 if (option_verbose > 2)
00606 ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", cur->resource, info->description);
00607 info->reload();
00608 }
00609 AST_LIST_UNLOCK(&module_list);
00610
00611 ast_mutex_unlock(&reloadlock);
00612
00613 return res;
00614 }
00615
00616 static unsigned int inspect_module(const struct ast_module *mod)
00617 {
00618 if (!mod->info->description) {
00619 ast_log(LOG_WARNING, "Module '%s' does not provide a description.\n", mod->resource);
00620 return 1;
00621 }
00622
00623 if (!mod->info->key) {
00624 ast_log(LOG_WARNING, "Module '%s' does not provide a license key.\n", mod->resource);
00625 return 1;
00626 }
00627
00628 if (verify_key((unsigned char *) mod->info->key)) {
00629 ast_log(LOG_WARNING, "Module '%s' did not provide a valid license key.\n", mod->resource);
00630 return 1;
00631 }
00632
00633 if (!ast_test_flag(mod->info, AST_MODFLAG_BUILDSUM)) {
00634
00635
00636
00637 } else if (!ast_strlen_zero(mod->info->buildopt_sum) &&
00638 strcmp(buildopt_sum, mod->info->buildopt_sum)) {
00639 ast_log(LOG_WARNING, "Module '%s' was not compiled with the same compile-time options as this version of Asterisk.\n", mod->resource);
00640 ast_log(LOG_WARNING, "Module '%s' will not be initialized as it may cause instability.\n", mod->resource);
00641 return 1;
00642 }
00643
00644 return 0;
00645 }
00646
00647 static enum ast_module_load_result load_resource(const char *resource_name, unsigned int global_symbols_only)
00648 {
00649 struct ast_module *mod;
00650 enum ast_module_load_result res = AST_MODULE_LOAD_SUCCESS;
00651 char tmp[256];
00652
00653 if ((mod = find_resource(resource_name, 0))) {
00654 if (mod->flags.running) {
00655 ast_log(LOG_WARNING, "Module '%s' already exists.\n", resource_name);
00656 return AST_MODULE_LOAD_DECLINE;
00657 }
00658 if (global_symbols_only && !ast_test_flag(mod->info, AST_MODFLAG_GLOBAL_SYMBOLS))
00659 return AST_MODULE_LOAD_SKIP;
00660 } else {
00661 #ifdef LOADABLE_MODULES
00662 if (!(mod = load_dynamic_module(resource_name, global_symbols_only))) {
00663
00664 if (!global_symbols_only) {
00665 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
00666 return AST_MODULE_LOAD_DECLINE;
00667 } else {
00668 return AST_MODULE_LOAD_SKIP;
00669 }
00670 }
00671 #else
00672 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
00673 return AST_MODULE_LOAD_DECLINE;
00674 #endif
00675 }
00676
00677 if (inspect_module(mod)) {
00678 ast_log(LOG_WARNING, "Module '%s' could not be loaded.\n", resource_name);
00679 #ifdef LOADABLE_MODULES
00680 unload_dynamic_module(mod);
00681 #endif
00682 return AST_MODULE_LOAD_DECLINE;
00683 }
00684
00685 mod->flags.declined = 0;
00686
00687 if (mod->info->load)
00688 res = mod->info->load();
00689
00690 switch (res) {
00691 case AST_MODULE_LOAD_SUCCESS:
00692 if (!ast_fully_booted) {
00693 if (option_verbose)
00694 ast_verbose("%s => (%s)\n", resource_name, term_color(tmp, mod->info->description, COLOR_BROWN, COLOR_BLACK, sizeof(tmp)));
00695 if (ast_opt_console && !option_verbose)
00696 ast_verbose( ".");
00697 } else {
00698 if (option_verbose)
00699 ast_verbose(VERBOSE_PREFIX_1 "Loaded %s => (%s)\n", resource_name, mod->info->description);
00700 }
00701
00702 mod->flags.running = 1;
00703
00704 ast_update_use_count();
00705 break;
00706 case AST_MODULE_LOAD_DECLINE:
00707 mod->flags.declined = 1;
00708 break;
00709 case AST_MODULE_LOAD_FAILURE:
00710 break;
00711 case AST_MODULE_LOAD_SKIP:
00712
00713 break;
00714 }
00715
00716 return res;
00717 }
00718
00719 int ast_load_resource(const char *resource_name)
00720 {
00721 AST_LIST_LOCK(&module_list);
00722 load_resource(resource_name, 0);
00723 AST_LIST_UNLOCK(&module_list);
00724
00725 return 0;
00726 }
00727
00728 struct load_order_entry {
00729 char *resource;
00730 AST_LIST_ENTRY(load_order_entry) entry;
00731 };
00732
00733 AST_LIST_HEAD_NOLOCK(load_order, load_order_entry);
00734
00735 static struct load_order_entry *add_to_load_order(const char *resource, struct load_order *load_order)
00736 {
00737 struct load_order_entry *order;
00738
00739 AST_LIST_TRAVERSE(load_order, order, entry) {
00740 if (!resource_name_match(order->resource, resource))
00741 return NULL;
00742 }
00743
00744 if (!(order = ast_calloc(1, sizeof(*order))))
00745 return NULL;
00746
00747 order->resource = ast_strdup(resource);
00748 AST_LIST_INSERT_TAIL(load_order, order, entry);
00749
00750 return order;
00751 }
00752
00753 int load_modules(unsigned int preload_only)
00754 {
00755 struct ast_config *cfg;
00756 struct ast_module *mod;
00757 struct load_order_entry *order;
00758 struct ast_variable *v;
00759 unsigned int load_count;
00760 struct load_order load_order;
00761 int res = 0;
00762 #ifdef LOADABLE_MODULES
00763 struct dirent *dirent;
00764 DIR *dir;
00765 #endif
00766
00767
00768 embedding = 0;
00769
00770 if (option_verbose)
00771 ast_verbose("Asterisk Dynamic Loader Starting:\n");
00772
00773 AST_LIST_HEAD_INIT_NOLOCK(&load_order);
00774
00775 AST_LIST_LOCK(&module_list);
00776
00777 if (!(cfg = ast_config_load(AST_MODULE_CONFIG))) {
00778 ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
00779 goto done;
00780 }
00781
00782
00783 for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00784 if (!strcasecmp(v->name, preload_only ? "preload" : "load"))
00785 add_to_load_order(v->value, &load_order);
00786 }
00787
00788
00789 if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
00790
00791 AST_LIST_TRAVERSE(&module_list, mod, entry) {
00792
00793 if (mod->lib)
00794 continue;
00795
00796 if (mod->flags.running)
00797 continue;
00798
00799 order = add_to_load_order(mod->resource, &load_order);
00800 }
00801
00802 #ifdef LOADABLE_MODULES
00803
00804
00805 if ((dir = opendir(ast_config_AST_MODULE_DIR))) {
00806 while ((dirent = readdir(dir))) {
00807 int ld = strlen(dirent->d_name);
00808
00809
00810
00811 if (ld < 4)
00812 continue;
00813
00814 if (strcasecmp(dirent->d_name + ld - 3, ".so"))
00815 continue;
00816
00817
00818
00819 if (find_resource(dirent->d_name, 0))
00820 continue;
00821
00822 add_to_load_order(dirent->d_name, &load_order);
00823 }
00824
00825 closedir(dir);
00826 } else {
00827 if (!ast_opt_quiet)
00828 ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
00829 ast_config_AST_MODULE_DIR);
00830 }
00831 #endif
00832 }
00833
00834
00835
00836 for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00837 if (strcasecmp(v->name, "noload"))
00838 continue;
00839
00840 AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00841 if (!resource_name_match(order->resource, v->value)) {
00842 AST_LIST_REMOVE_CURRENT(&load_order, entry);
00843 free(order->resource);
00844 free(order);
00845 }
00846 }
00847 AST_LIST_TRAVERSE_SAFE_END;
00848 }
00849
00850
00851
00852 ast_config_destroy(cfg);
00853
00854 load_count = 0;
00855 AST_LIST_TRAVERSE(&load_order, order, entry)
00856 load_count++;
00857
00858 if (load_count)
00859 ast_log(LOG_NOTICE, "%d modules will be loaded.\n", load_count);
00860
00861
00862 AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00863 switch (load_resource(order->resource, 1)) {
00864 case AST_MODULE_LOAD_SUCCESS:
00865 case AST_MODULE_LOAD_DECLINE:
00866 AST_LIST_REMOVE_CURRENT(&load_order, entry);
00867 free(order->resource);
00868 free(order);
00869 break;
00870 case AST_MODULE_LOAD_FAILURE:
00871 res = -1;
00872 goto done;
00873 case AST_MODULE_LOAD_SKIP:
00874
00875 break;
00876 }
00877 }
00878 AST_LIST_TRAVERSE_SAFE_END;
00879
00880
00881 AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00882 switch (load_resource(order->resource, 0)) {
00883 case AST_MODULE_LOAD_SUCCESS:
00884 case AST_MODULE_LOAD_DECLINE:
00885 AST_LIST_REMOVE_CURRENT(&load_order, entry);
00886 free(order->resource);
00887 free(order);
00888 break;
00889 case AST_MODULE_LOAD_FAILURE:
00890 res = -1;
00891 goto done;
00892 case AST_MODULE_LOAD_SKIP:
00893
00894 break;
00895 }
00896 }
00897 AST_LIST_TRAVERSE_SAFE_END;
00898
00899 done:
00900 while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
00901 free(order->resource);
00902 free(order);
00903 }
00904
00905 AST_LIST_UNLOCK(&module_list);
00906
00907 return res;
00908 }
00909
00910 void ast_update_use_count(void)
00911 {
00912
00913
00914 struct loadupdate *m;
00915
00916 AST_LIST_LOCK(&updaters);
00917 AST_LIST_TRAVERSE(&updaters, m, entry)
00918 m->updater();
00919 AST_LIST_UNLOCK(&updaters);
00920 }
00921
00922 int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like),
00923 const char *like)
00924 {
00925 struct ast_module *cur;
00926 int unlock = -1;
00927 int total_mod_loaded = 0;
00928
00929 if (AST_LIST_TRYLOCK(&module_list))
00930 unlock = 0;
00931
00932 AST_LIST_TRAVERSE(&module_list, cur, entry) {
00933 total_mod_loaded += modentry(cur->resource, cur->info->description, cur->usecount, like);
00934 }
00935
00936 if (unlock)
00937 AST_LIST_UNLOCK(&module_list);
00938
00939 return total_mod_loaded;
00940 }
00941
00942 int ast_loader_register(int (*v)(void))
00943 {
00944 struct loadupdate *tmp;
00945
00946 if (!(tmp = ast_malloc(sizeof(*tmp))))
00947 return -1;
00948
00949 tmp->updater = v;
00950 AST_LIST_LOCK(&updaters);
00951 AST_LIST_INSERT_HEAD(&updaters, tmp, entry);
00952 AST_LIST_UNLOCK(&updaters);
00953
00954 return 0;
00955 }
00956
00957 int ast_loader_unregister(int (*v)(void))
00958 {
00959 struct loadupdate *cur;
00960
00961 AST_LIST_LOCK(&updaters);
00962 AST_LIST_TRAVERSE_SAFE_BEGIN(&updaters, cur, entry) {
00963 if (cur->updater == v) {
00964 AST_LIST_REMOVE_CURRENT(&updaters, entry);
00965 break;
00966 }
00967 }
00968 AST_LIST_TRAVERSE_SAFE_END;
00969 AST_LIST_UNLOCK(&updaters);
00970
00971 return cur ? 0 : -1;
00972 }
00973
00974 struct ast_module *ast_module_ref(struct ast_module *mod)
00975 {
00976 ast_atomic_fetchadd_int(&mod->usecount, +1);
00977 ast_update_use_count();
00978
00979 return mod;
00980 }
00981
00982 void ast_module_unref(struct ast_module *mod)
00983 {
00984 ast_atomic_fetchadd_int(&mod->usecount, -1);
00985 ast_update_use_count();
00986 }