Thu Mar 25 12:09:45 2010

Asterisk developer's documentation


asterisk.h File Reference

Asterisk main include file. File version handling, generic pbx functions. More...

#include "asterisk/autoconfig.h"
#include "asterisk/compat.h"
#include "asterisk/paths.h"

Go to the source code of this file.

Defines

#define ASTERISK_FILE_VERSION(file, version)
 Register/unregister a source code file with the core.
#define DEFAULT_LANGUAGE   "en"
#define DEFAULT_SAMPLE_RATE   8000
#define DEFAULT_SAMPLES_PER_MS   ((DEFAULT_SAMPLE_RATE)/1000)
#define sched_setscheduler   __PLEASE_USE_ast_set_priority_INSTEAD_OF_sched_setscheduler__
#define setpriority   __PLEASE_USE_ast_set_priority_INSTEAD_OF_setpriority__

Functions

int ast_add_profile (const char *, uint64_t scale)
 support for event profiling
void ast_autoservice_init (void)
void ast_builtins_init (void)
 initialize the _full_cmd string in * each of the builtins.
void ast_channels_init (void)
int ast_fd_init (void)
int64_t ast_mark (int, int start1_stop0)
int ast_module_reload (const char *name)
 Reload asterisk modules.
void ast_process_pending_reloads (void)
 Process reload requests received during startup.
int64_t ast_profile (int, int64_t)
int ast_register_atexit (void(*func)(void))
 Register a function to be executed before Asterisk exits.
void ast_register_file_version (const char *file, const char *version)
 Register the version of a source code file with the core.
int ast_set_priority (int)
 We set ourselves to a high priority, that we might pre-empt everything else. If your PBX has heavy activity on it, this is a good thing.
int ast_term_init (void)
void ast_unregister_atexit (void(*func)(void))
 Unregister a function registered with ast_register_atexit().
void ast_unregister_file_version (const char *file)
 Unregister a source code file from the core.
int astdb_init (void)
int astobj2_init (void)
void close_logger (void)
int dnsmgr_init (void)
int dnsmgr_reload (void)
void dnsmgr_start_refresh (void)
int init_framer (void)
int init_logger (void)
int load_modules (unsigned int)
int load_pbx (void)
int reload_logger (int)
void threadstorage_init (void)

Variables

char ast_config_AST_AGI_DIR [PATH_MAX]
char ast_config_AST_CONFIG_DIR [PATH_MAX]
char ast_config_AST_CONFIG_FILE [PATH_MAX]
char ast_config_AST_CTL [PATH_MAX]
char ast_config_AST_CTL_GROUP [PATH_MAX]
char ast_config_AST_CTL_OWNER [PATH_MAX]
char ast_config_AST_CTL_PERMISSIONS [PATH_MAX]
char ast_config_AST_DATA_DIR [PATH_MAX]
char ast_config_AST_DB [PATH_MAX]
char ast_config_AST_KEY_DIR [PATH_MAX]
char ast_config_AST_LOG_DIR [PATH_MAX]
char ast_config_AST_MODULE_DIR [PATH_MAX]
char ast_config_AST_MONITOR_DIR [PATH_MAX]
char ast_config_AST_PID [PATH_MAX]
char ast_config_AST_RUN_DIR [PATH_MAX]
char ast_config_AST_RUN_GROUP [PATH_MAX]
char ast_config_AST_RUN_USER [PATH_MAX]
char ast_config_AST_SOCKET [PATH_MAX]
char ast_config_AST_SPOOL_DIR [PATH_MAX]
char ast_config_AST_SYSTEM_NAME [20]
char ast_config_AST_VAR_DIR [PATH_MAX]


Detailed Description

Asterisk main include file. File version handling, generic pbx functions.

Definition in file asterisk.h.


Define Documentation

#define ASTERISK_FILE_VERSION ( file,
version   ) 

Register/unregister a source code file with the core.

Parameters:
file the source file name
version the version string (typically a CVS revision keyword string)
This macro will place a file-scope constructor and destructor into the source of the module using it; this will cause the version of this file to registered with the Asterisk core (and unregistered) at the appropriate times.

Example:

 ASTERISK_FILE_VERSION(__FILE__, "\$Revision\$")

Note:
The dollar signs above have been protected with backslashes to keep CVS from modifying them in this file; under normal circumstances they would not be present and CVS would expand the Revision keyword into the file's revision number.

Definition at line 220 of file asterisk.h.

#define DEFAULT_LANGUAGE   "en"

Definition at line 31 of file asterisk.h.

Referenced by fileexists_core().

#define DEFAULT_SAMPLE_RATE   8000

Definition at line 33 of file asterisk.h.

Referenced by check_header(), ogg_vorbis_rewrite(), setformat(), and write_header().

#define DEFAULT_SAMPLES_PER_MS   ((DEFAULT_SAMPLE_RATE)/1000)

Definition at line 34 of file asterisk.h.

Referenced by ast_stream_fastforward(), ast_stream_rewind(), and isAnsweringMachine().

#define sched_setscheduler   __PLEASE_USE_ast_set_priority_INSTEAD_OF_sched_setscheduler__

Definition at line 36 of file asterisk.h.

Referenced by ast_set_priority().

#define setpriority   __PLEASE_USE_ast_set_priority_INSTEAD_OF_setpriority__

Definition at line 35 of file asterisk.h.

Referenced by ast_set_priority().


Function Documentation

int ast_add_profile ( const char *  name,
uint64_t  scale 
)

support for event profiling

Returns:
Returns the identifier of the counter.

Definition at line 484 of file asterisk.c.

References ast_calloc, ast_realloc, ast_strdup, profile_data::e, profile_data::entries, profile_entry::events, profile_entry::mark, profile_data::max_size, profile_entry::name, prof_data, profile_entry::scale, and profile_entry::value.

Referenced by extension_match_core().

00485 {
00486    int l = sizeof(struct profile_data);
00487    int n = 10; /* default entries */
00488 
00489    if (prof_data == NULL) {
00490       prof_data = ast_calloc(1, l + n*sizeof(struct profile_entry));
00491       if (prof_data == NULL)
00492          return -1;
00493       prof_data->entries = 0;
00494       prof_data->max_size = n;
00495    }
00496    if (prof_data->entries >= prof_data->max_size) {
00497       void *p;
00498       n = prof_data->max_size + 20;
00499       p = ast_realloc(prof_data, l + n*sizeof(struct profile_entry));
00500       if (p == NULL)
00501          return -1;
00502       prof_data = p;
00503       prof_data->max_size = n;
00504    }
00505    n = prof_data->entries++;
00506    prof_data->e[n].name = ast_strdup(name);
00507    prof_data->e[n].value = 0;
00508    prof_data->e[n].events = 0;
00509    prof_data->e[n].mark = 0;
00510    prof_data->e[n].scale = scale;
00511    return n;
00512 }

void ast_autoservice_init ( void   ) 

Provided by astobj2.c Provided by autoservice.c

Definition at line 324 of file autoservice.c.

References as_cond, and ast_cond_init().

Referenced by main().

00325 {
00326    ast_cond_init(&as_cond, NULL);
00327 }

void ast_builtins_init ( void   ) 

initialize the _full_cmd string in * each of the builtins.

Provided by cli.c

Definition at line 1506 of file cli.c.

References ast_cli_entry::_full_cmd, ast_cli_register_multiple(), ast_join(), ast_log(), builtins, cli_cli, ast_cli_entry::cmda, LOG_WARNING, and strdup.

Referenced by main().

01507 {
01508    struct ast_cli_entry *e;
01509 
01510    for (e = builtins; e->cmda[0] != NULL; e++) {
01511       char buf[80];
01512       ast_join(buf, sizeof(buf), e->cmda);
01513       e->_full_cmd = strdup(buf);
01514       if (!e->_full_cmd)
01515          ast_log(LOG_WARNING, "-- cannot allocate <%s>\n", buf);
01516    }
01517 
01518    ast_cli_register_multiple(cli_cli, sizeof(cli_cli) / sizeof(struct ast_cli_entry));
01519 }

void ast_channels_init ( void   ) 

Provided by channel.c

Definition at line 4924 of file channel.c.

References ast_cli_register_multiple(), and cli_channel.

Referenced by main().

04925 {
04926    ast_cli_register_multiple(cli_channel, sizeof(cli_channel) / sizeof(struct ast_cli_entry));
04927 }

int ast_fd_init ( void   ) 

Provided by astfd.c

Definition at line 266 of file astfd.c.

Referenced by main().

00267 {
00268    return 0;
00269 }

int64_t ast_mark ( int  ,
int  start1_stop0 
)

Definition at line 549 of file asterisk.c.

References profile_data::e, profile_data::entries, profile_entry::events, profile_entry::mark, prof_data, rdtsc(), profile_entry::scale, and profile_entry::value.

Referenced by extension_match_core().

00550 {
00551    if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
00552       return 0;
00553    if (startstop == 1)
00554       prof_data->e[i].mark = rdtsc();
00555    else {
00556       prof_data->e[i].mark = (rdtsc() - prof_data->e[i].mark);
00557       if (prof_data->e[i].scale > 1)
00558          prof_data->e[i].mark /= prof_data->e[i].scale;
00559       prof_data->e[i].value += prof_data->e[i].mark;
00560       prof_data->e[i].events++;
00561    }
00562    return prof_data->e[i].mark;
00563 }

int ast_module_reload ( const char *  name  ) 

Reload asterisk modules.

Parameters:
name the name of the module to reload
This function reloads the specified module, or if no modules are specified, it will reload all loaded modules.

Note:
Modules are reloaded using their reload() functions, not unloading them and loading them again.
Returns:
Zero if the specified module was not found, 1 if the module was found but cannot be reloaded, -1 if a reload operation is already in progress, and 2 if the specfied module was found and reloaded.

Definition at line 636 of file loader.c.

References ast_fully_booted, ast_lastreloadtime, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_mutex_trylock(), ast_mutex_unlock(), ast_verbose(), ast_module::declined, ast_module_info::description, ast_module_user::entry, ast_module::flags, ast_module::info, LOG_NOTICE, option_verbose, queue_reload_request(), ast_module_info::reload, ast_module::resource, resource_name_match(), ast_module::running, and VERBOSE_PREFIX_3.

Referenced by action_updateconfig(), ast_process_pending_reloads(), handle_reload(), handle_reload_deprecated(), and monitor_sig_flags().

00637 {
00638    struct ast_module *cur;
00639    int res = 0; /* return value. 0 = not found, others, see below */
00640    int i;
00641 
00642    /* If we aren't fully booted, we just pretend we reloaded but we queue this
00643       up to run once we are booted up. */
00644    if (!ast_fully_booted) {
00645       queue_reload_request(name);
00646       return 0;
00647    }
00648 
00649    if (ast_mutex_trylock(&reloadlock)) {
00650       ast_verbose("The previous reload command didn't finish yet\n");
00651       return -1;  /* reload already in progress */
00652    }
00653    ast_lastreloadtime = time(NULL);
00654 
00655    /* Call "predefined" reload here first */
00656    for (i = 0; reload_classes[i].name; i++) {
00657       if (!name || !strcasecmp(name, reload_classes[i].name)) {
00658          reload_classes[i].reload_fn();   /* XXX should check error ? */
00659          res = 2; /* found and reloaded */
00660       }
00661    }
00662 
00663    if (name && res) {
00664       ast_mutex_unlock(&reloadlock);
00665       return res;
00666    }
00667 
00668    AST_LIST_LOCK(&module_list);
00669    AST_LIST_TRAVERSE(&module_list, cur, entry) {
00670       const struct ast_module_info *info = cur->info;
00671 
00672       if (name && resource_name_match(name, cur->resource))
00673          continue;
00674 
00675       if (!cur->flags.running || cur->flags.declined) {
00676          if (!name)
00677             continue;
00678          ast_log(LOG_NOTICE, "The module '%s' was not properly initialized.  "
00679             "Before reloading the module, you must run \"module load %s\" "
00680             "and fix whatever is preventing the module from being initialized.\n",
00681             name, name);
00682          res = 2; /* Don't report that the module was not found */
00683          break;
00684       }
00685 
00686       if (!info->reload) { /* cannot be reloaded */
00687          if (res < 1)   /* store result if possible */
00688             res = 1; /* 1 = no reload() method */
00689          continue;
00690       }
00691 
00692       res = 2;
00693       if (option_verbose > 2)
00694          ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", cur->resource, info->description);
00695       info->reload();
00696    }
00697    AST_LIST_UNLOCK(&module_list);
00698 
00699    ast_mutex_unlock(&reloadlock);
00700 
00701    return res;
00702 }

void ast_process_pending_reloads ( void   ) 

Process reload requests received during startup.

This function requests that the loader execute the pending reload requests that were queued during server startup.

Note:
This function will do nothing if the server has not completely started up. Once called, the reload queue is emptied, and further invocations will have no affect.

Definition at line 571 of file loader.c.

References ast_free, ast_fully_booted, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_log(), ast_module_reload(), do_full_reload, ast_module_user::entry, LOG_NOTICE, and reload_queue_item::module.

Referenced by main().

00572 {
00573    struct reload_queue_item *item;
00574 
00575    if (!ast_fully_booted) {
00576       return;
00577    }
00578 
00579    AST_LIST_LOCK(&reload_queue);
00580 
00581    if (do_full_reload) {
00582       do_full_reload = 0;
00583       AST_LIST_UNLOCK(&reload_queue);
00584       ast_log(LOG_NOTICE, "Executing deferred reload request.\n");
00585       ast_module_reload(NULL);
00586       return;
00587    }
00588 
00589    while ((item = AST_LIST_REMOVE_HEAD(&reload_queue, entry))) {
00590       ast_log(LOG_NOTICE, "Executing deferred reload request for module '%s'.\n", item->module);
00591       ast_module_reload(item->module);
00592       ast_free(item);
00593    }
00594 
00595    AST_LIST_UNLOCK(&reload_queue);
00596 }

int64_t ast_profile ( int  ,
int64_t   
)

Definition at line 514 of file asterisk.c.

References profile_data::e, profile_data::entries, profile_entry::events, prof_data, profile_entry::scale, and profile_entry::value.

00515 {
00516    if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
00517       return 0;
00518    if (prof_data->e[i].scale > 1)
00519       delta /= prof_data->e[i].scale;
00520    prof_data->e[i].value += delta;
00521    prof_data->e[i].events++;
00522    return prof_data->e[i].value;
00523 }

int ast_register_atexit ( void(*)(void)  func  ) 

Register a function to be executed before Asterisk exits.

Parameters:
func The callback function to use.
Returns:
Zero on success, -1 on error.

Definition at line 817 of file asterisk.c.

References ast_calloc, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_unregister_atexit(), and ast_atexit::list.

Referenced by do_reload(), and load_module().

00818 {
00819    struct ast_atexit *ae;
00820 
00821    if (!(ae = ast_calloc(1, sizeof(*ae))))
00822       return -1;
00823 
00824    ae->func = func;
00825 
00826    ast_unregister_atexit(func);  
00827 
00828    AST_LIST_LOCK(&atexits);
00829    AST_LIST_INSERT_HEAD(&atexits, ae, list);
00830    AST_LIST_UNLOCK(&atexits);
00831 
00832    return 0;
00833 }

void ast_register_file_version ( const char *  file,
const char *  version 
)

Register the version of a source code file with the core.

Parameters:
file the source file name
version the version string (typically a CVS revision keyword string)
Returns:
nothing
This function should not be called directly, but instead the ASTERISK_FILE_VERSION macro should be used to register a file with the core.

Definition at line 273 of file asterisk.c.

References ast_calloc, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_strdupa, ast_strip(), ast_strip_quoted(), and ast_atexit::list.

00274 {
00275    struct file_version *new;
00276    char *work;
00277    size_t version_length;
00278 
00279    work = ast_strdupa(version);
00280    work = ast_strip(ast_strip_quoted(work, "$", "$"));
00281    version_length = strlen(work) + 1;
00282    
00283    if (!(new = ast_calloc(1, sizeof(*new) + version_length)))
00284       return;
00285 
00286    new->file = file;
00287    new->version = (char *) new + sizeof(*new);
00288    memcpy(new->version, work, version_length);
00289    AST_LIST_LOCK(&file_versions);
00290    AST_LIST_INSERT_HEAD(&file_versions, new, list);
00291    AST_LIST_UNLOCK(&file_versions);
00292 }

int ast_set_priority ( int   ) 

We set ourselves to a high priority, that we might pre-empt everything else. If your PBX has heavy activity on it, this is a good thing.

Provided by asterisk.c

Definition at line 1332 of file asterisk.c.

References ast_log(), ast_verbose(), LOG_WARNING, sched_setscheduler, and setpriority.

Referenced by app_exec(), ast_safe_system(), icesencode(), launch_script(), main(), mp3play(), NBScatplay(), send_waveform_to_fd(), spawn_mp3(), and spawn_ras().

01333 {
01334    struct sched_param sched;
01335    memset(&sched, 0, sizeof(sched));
01336 #ifdef __linux__
01337    if (pri) {  
01338       sched.sched_priority = 10;
01339       if (sched_setscheduler(0, SCHED_RR, &sched)) {
01340          ast_log(LOG_WARNING, "Unable to set high priority\n");
01341          return -1;
01342       } else
01343          if (option_verbose)
01344             ast_verbose("Set to realtime thread\n");
01345    } else {
01346       sched.sched_priority = 0;
01347       /* According to the manpage, these parameters can never fail. */
01348       sched_setscheduler(0, SCHED_OTHER, &sched);
01349    }
01350 #else
01351    if (pri) {
01352       if (setpriority(PRIO_PROCESS, 0, -10) == -1) {
01353          ast_log(LOG_WARNING, "Unable to set high priority\n");
01354          return -1;
01355       } else
01356          if (option_verbose)
01357             ast_verbose("Set to high priority\n");
01358    } else {
01359       /* According to the manpage, these parameters can never fail. */
01360       setpriority(PRIO_PROCESS, 0, 0);
01361    }
01362 #endif
01363    return 0;
01364 }

int ast_term_init ( void   ) 

Provided by term.c

Definition at line 75 of file term.c.

References ast_opt_console, ast_opt_no_color, ast_opt_no_fork, ATTR_BRIGHT, ATTR_RESET, COLOR_BLACK, COLOR_BROWN, COLOR_WHITE, convshort(), and ESC.

Referenced by main().

00076 {
00077    char *term = getenv("TERM");
00078    char termfile[256] = "";
00079    char buffer[512] = "";
00080    int termfd = -1, parseokay = 0, i;
00081 
00082    if (!term)
00083       return 0;
00084    if (!ast_opt_console || ast_opt_no_color || !ast_opt_no_fork)
00085       return 0;
00086 
00087    for (i=0 ;; i++) {
00088       if (termpath[i] == NULL) {
00089          break;
00090       }
00091       snprintf(termfile, sizeof(termfile), "%s/%c/%s", termpath[i], *term, term);
00092       termfd = open(termfile, O_RDONLY);
00093       if (termfd > -1) {
00094          break;
00095       }
00096    }
00097    if (termfd > -1) {
00098       int actsize = read(termfd, buffer, sizeof(buffer) - 1);
00099       short sz_names = convshort(buffer + 2);
00100       short sz_bools = convshort(buffer + 4);
00101       short n_nums   = convshort(buffer + 6);
00102 
00103       /* if ((sz_names + sz_bools) & 1)
00104          sz_bools++; */
00105 
00106       if (sz_names + sz_bools + n_nums < actsize) {
00107          /* Offset 13 is defined in /usr/include/term.h, though we do not
00108           * include it here, as it conflicts with include/asterisk/term.h */
00109          short max_colors = convshort(buffer + 12 + sz_names + sz_bools + 13 * 2);
00110          if (max_colors > 0) {
00111             vt100compat = 1;
00112          }
00113          parseokay = 1;
00114       }
00115       close(termfd);
00116    }
00117 
00118    if (!parseokay) {
00119       /* These comparisons should not be substrings nor case-insensitive, as
00120        * terminal types are very particular about how they treat suffixes and
00121        * capitalization.  For example, terminal type 'linux-m' does NOT
00122        * support color, while 'linux' does.  Not even all vt100* terminals
00123        * support color, either (e.g. 'vt100+fnkeys'). */
00124       if (!strcmp(term, "linux")) {
00125          vt100compat = 1;
00126       } else if (!strcmp(term, "xterm")) {
00127          vt100compat = 1;
00128       } else if (!strcmp(term, "xterm-color")) {
00129          vt100compat = 1;
00130       } else if (!strncmp(term, "Eterm", 5)) {
00131          /* Both entries which start with Eterm support color */
00132          vt100compat = 1;
00133       } else if (!strcmp(term, "vt100")) {
00134          vt100compat = 1;
00135       } else if (!strncmp(term, "crt", 3)) {
00136          /* Both crt terminals support color */
00137          vt100compat = 1;
00138       }
00139    }
00140 
00141    if (vt100compat) {
00142       /* Make commands show up in nice colors */
00143       snprintf(prepdata, sizeof(prepdata), "%c[%d;%d;%dm", ESC, ATTR_BRIGHT, COLOR_BROWN, COLOR_BLACK + 10);
00144       snprintf(enddata, sizeof(enddata), "%c[%d;%d;%dm", ESC, ATTR_RESET, COLOR_WHITE, COLOR_BLACK + 10);
00145       snprintf(quitdata, sizeof(quitdata), "%c[0m", ESC);
00146    }
00147    return 0;
00148 }

void ast_unregister_atexit ( void(*)(void)  func  ) 

Unregister a function registered with ast_register_atexit().

Parameters:
func The callback function to unregister.

Definition at line 835 of file asterisk.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, free, ast_atexit::func, and ast_atexit::list.

Referenced by ast_register_atexit(), and do_reload().

00836 {
00837    struct ast_atexit *ae = NULL;
00838 
00839    AST_LIST_LOCK(&atexits);
00840    AST_LIST_TRAVERSE_SAFE_BEGIN(&atexits, ae, list) {
00841       if (ae->func == func) {
00842          AST_LIST_REMOVE_CURRENT(&atexits, list);
00843          break;
00844       }
00845    }
00846    AST_LIST_TRAVERSE_SAFE_END
00847    AST_LIST_UNLOCK(&atexits);
00848 
00849    if (ae)
00850       free(ae);
00851 }

void ast_unregister_file_version ( const char *  file  ) 

Unregister a source code file from the core.

Parameters:
file the source file name
Returns:
nothing
This function should not be called directly, but instead the ASTERISK_FILE_VERSION macro should be used to automatically unregister the file when the module is unloaded.

Definition at line 294 of file asterisk.c.

References ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, file_version::file, and ast_atexit::list.

00295 {
00296    struct file_version *find;
00297 
00298    AST_LIST_LOCK(&file_versions);
00299    AST_LIST_TRAVERSE_SAFE_BEGIN(&file_versions, find, list) {
00300       if (!strcasecmp(find->file, file)) {
00301          AST_LIST_REMOVE_CURRENT(&file_versions, list);
00302          break;
00303       }
00304    }
00305    AST_LIST_TRAVERSE_SAFE_END;
00306    AST_LIST_UNLOCK(&file_versions);
00307    if (find)
00308       ast_free(find);
00309 }

int astdb_init ( void   ) 

Provided by db.c

Definition at line 588 of file db.c.

References ast_cli_register_multiple(), ast_manager_register, cli_database, dbinit(), EVENT_FLAG_SYSTEM, manager_dbget(), and manager_dbput().

Referenced by main().

00589 {
00590    dbinit();
00591    ast_cli_register_multiple(cli_database, sizeof(cli_database) / sizeof(struct ast_cli_entry));
00592    ast_manager_register("DBGet", EVENT_FLAG_SYSTEM, manager_dbget, "Get DB Entry");
00593    ast_manager_register("DBPut", EVENT_FLAG_SYSTEM, manager_dbput, "Put DB Entry");
00594    return 0;
00595 }

int astobj2_init ( void   ) 

Definition at line 788 of file astobj2.c.

References ARRAY_LEN, and ast_cli_register_multiple().

Referenced by main().

00789 {
00790 #ifdef AO2_DEBUG
00791    ast_cli_register_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
00792 #endif
00793 
00794    return 0;
00795 }

void close_logger ( void   ) 

Provided by logger.c

Definition at line 621 of file logger.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, eventlog, f, logchannel::list, and qlog.

Referenced by quit_handler().

00623 {
00624    struct logchannel *f;
00625 
00626    AST_LIST_LOCK(&logchannels);
00627 
00628    if (eventlog) {
00629       fclose(eventlog);
00630       eventlog = NULL;
00631    }
00632 
00633    if (qlog) {
00634       fclose(qlog);
00635       qlog = NULL;
00636    }
00637 
00638    AST_LIST_TRAVERSE(&logchannels, f, list) {
00639       if (f->fileptr && (f->fileptr != stdout) && (f->fileptr != stderr)) {
00640          fclose(f->fileptr);
00641          f->fileptr = NULL;
00642       }
00643    }
00644 
00645    closelog(); /* syslog */
00646 
00647    AST_LIST_UNLOCK(&logchannels);
00648 
00649    return;

int dnsmgr_init ( void   ) 

Provided by dnsmgr.c

Definition at line 342 of file dnsmgr.c.

References ast_cli_register(), ast_log(), cli_refresh, cli_reload, cli_status, do_reload(), LOG_ERROR, sched, and sched_context_create().

Referenced by main().

00343 {
00344    if (!(sched = sched_context_create())) {
00345       ast_log(LOG_ERROR, "Unable to create schedule context.\n");
00346       return -1;
00347    }
00348    ast_cli_register(&cli_reload);
00349    ast_cli_register(&cli_status);
00350    ast_cli_register(&cli_refresh);
00351    return do_reload(1);
00352 }

int dnsmgr_reload ( void   ) 

Provided by dnsmgr.c

Definition at line 354 of file dnsmgr.c.

References do_reload().

00355 {
00356    return do_reload(0);
00357 }

void dnsmgr_start_refresh ( void   ) 

Provided by dnsmgr.c

Definition at line 252 of file dnsmgr.c.

References ast_sched_add_variable(), AST_SCHED_DEL, master_refresh_info, refresh_list(), and sched.

Referenced by main().

00253 {
00254    if (refresh_sched > -1) {
00255       AST_SCHED_DEL(sched, refresh_sched);
00256       refresh_sched = ast_sched_add_variable(sched, 100, refresh_list, &master_refresh_info, 1);
00257    }
00258 }

int init_framer ( void   ) 

Provided by frame.c

Definition at line 1039 of file frame.c.

References ast_cli_register_multiple(), and my_clis.

Referenced by main().

01040 {
01041    ast_cli_register_multiple(my_clis, sizeof(my_clis) / sizeof(struct ast_cli_entry));
01042    return 0;   
01043 }

int init_logger ( void   ) 

Provided by logger.c

Definition at line 582 of file logger.c.

References ast_cli_register_multiple(), ast_config_AST_LOG_DIR, ast_log(), ast_queue_log(), ast_verbose(), cli_logger, errno, eventlog, EVENTLOG, handle_SIGXFSZ(), init_logger_chain(), LOG_ERROR, LOG_EVENT, logfiles, option_verbose, qlog, and QUEUELOG.

Referenced by main().

00584 {
00585    char tmp[256];
00586    int res = 0;
00587 
00588    /* auto rotate if sig SIGXFSZ comes a-knockin */
00589    (void) signal(SIGXFSZ,(void *) handle_SIGXFSZ);
00590 
00591    /* register the logger cli commands */
00592    ast_cli_register_multiple(cli_logger, sizeof(cli_logger) / sizeof(struct ast_cli_entry));
00593 
00594    mkdir((char *)ast_config_AST_LOG_DIR, 0755);
00595   
00596    /* create log channels */
00597    init_logger_chain();
00598 
00599    /* create the eventlog */
00600    if (logfiles.event_log) {
00601       mkdir((char *)ast_config_AST_LOG_DIR, 0755);
00602       snprintf(tmp, sizeof(tmp), "%s/%s", (char *)ast_config_AST_LOG_DIR, EVENTLOG);
00603       eventlog = fopen((char *)tmp, "a");
00604       if (eventlog) {
00605          ast_log(LOG_EVENT, "Started Asterisk Event Logger\n");
00606          if (option_verbose)
00607             ast_verbose("Asterisk Event Logger Started %s\n",(char *)tmp);
00608       } else {
00609          ast_log(LOG_ERROR, "Unable to create event log: %s\n", strerror(errno));
00610          res = -1;
00611       }
00612    }
00613 
00614    if (logfiles.queue_log) {
00615       snprintf(tmp, sizeof(tmp), "%s/%s", (char *)ast_config_AST_LOG_DIR, QUEUELOG);
00616       qlog = fopen(tmp, "a");
00617       ast_queue_log("NONE", "NONE", "NONE", "QUEUESTART", "%s", "");
00618    }
00619    return res;

int load_modules ( unsigned  int  ) 

Provided by loader.c

Definition at line 872 of file loader.c.

References add_to_load_order(), ast_config_load(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_LOCK, ast_log(), AST_MODULE_CONFIG, ast_variable_browse(), ast_verbose(), embedding, LOG_WARNING, ast_variable::name, ast_variable::next, option_verbose, translate_module_name(), and ast_variable::value.

Referenced by main().

00873 {
00874    struct ast_config *cfg;
00875    struct ast_module *mod;
00876    struct load_order_entry *order;
00877    struct ast_variable *v;
00878    unsigned int load_count;
00879    struct load_order load_order;
00880    int res = 0;
00881    int load_pass;
00882 
00883    int translate_status;
00884    char newname[18]; /* although this would normally be 80, max length in translate_module_name is 18 */
00885 #ifdef LOADABLE_MODULES
00886    struct dirent *dirent;
00887    DIR *dir;
00888 #endif
00889 
00890    /* all embedded modules have registered themselves by now */
00891    embedding = 0;
00892 
00893    if (option_verbose)
00894       ast_verbose("Asterisk Dynamic Loader Starting:\n");
00895 
00896    AST_LIST_HEAD_INIT_NOLOCK(&load_order);
00897 
00898    AST_LIST_LOCK(&module_list);
00899 
00900    if (!(cfg = ast_config_load(AST_MODULE_CONFIG))) {
00901       ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
00902       goto done;
00903    }
00904 
00905    /* first, find all the modules we have been explicitly requested to load */
00906    for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00907       if (!strcasecmp(v->name, preload_only ? "preload" : "load")) {
00908          translate_status = translate_module_name(v->value, newname);
00909             if (!translate_status)
00910                ast_log(LOG_WARNING, "Use of old module name %s is deprecated, please use %s instead.\n", v->value, newname);
00911          add_to_load_order(translate_status ? v->value : newname, &load_order);
00912       }
00913    }
00914 
00915    /* check if 'autoload' is on */
00916    if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
00917       /* if so, first add all the embedded modules that are not already running to the load order */
00918       AST_LIST_TRAVERSE(&module_list, mod, entry) {
00919          /* if it's not embedded, skip it */
00920          if (mod->lib)
00921             continue;
00922 
00923          if (mod->flags.running)
00924             continue;
00925 
00926          order = add_to_load_order(mod->resource, &load_order);
00927       }
00928 
00929 #ifdef LOADABLE_MODULES
00930       /* if we are allowed to load dynamic modules, scan the directory for
00931          for all available modules and add them as well */
00932       if ((dir  = opendir(ast_config_AST_MODULE_DIR))) {
00933          while ((dirent = readdir(dir))) {
00934             int ld = strlen(dirent->d_name);
00935 
00936             /* Must end in .so to load it.  */
00937 
00938             if (ld < 4)
00939                continue;
00940 
00941             if (strcasecmp(dirent->d_name + ld - 3, ".so"))
00942                continue;
00943 
00944             /* if there is already a module by this name in the module_list,
00945                skip this file */
00946             if (find_resource(dirent->d_name, 0))
00947                continue;
00948 
00949             add_to_load_order(dirent->d_name, &load_order);
00950          }
00951 
00952          closedir(dir);
00953       } else {
00954          if (!ast_opt_quiet)
00955             ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
00956                ast_config_AST_MODULE_DIR);
00957       }
00958 #endif
00959    }
00960 
00961    /* now scan the config for any modules we are prohibited from loading and
00962       remove them from the load order */
00963    for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00964       if (strcasecmp(v->name, "noload"))
00965          continue;
00966 
00967       AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00968          translate_status = translate_module_name(v->value, newname);
00969          if (!resource_name_match(order->resource, translate_status ? v->value : newname)) {
00970                if (!translate_status)
00971                   ast_log(LOG_WARNING, "Use of old module name %s is deprecated, please use %s instead.\n", v->value, newname);
00972             AST_LIST_REMOVE_CURRENT(&load_order, entry);
00973             free(order->resource);
00974             free(order);
00975          }
00976       }
00977       AST_LIST_TRAVERSE_SAFE_END;
00978    }
00979 
00980    /* we are done with the config now, all the information we need is in the
00981       load_order list */
00982    ast_config_destroy(cfg);
00983 
00984    load_count = 0;
00985    AST_LIST_TRAVERSE(&load_order, order, entry)
00986       load_count++;
00987 
00988    if (load_count)
00989       ast_log(LOG_NOTICE, "%d modules will be loaded.\n", load_count);
00990 
00991    for (load_pass = 0; load_pass < LOAD_DONE; load_pass++) {
00992       AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00993          switch (load_resource(order->resource, load_pass)) {
00994          case AST_MODULE_LOAD_SUCCESS:
00995          case AST_MODULE_LOAD_DECLINE:
00996             AST_LIST_REMOVE_CURRENT(&load_order, entry);
00997             free(order->resource);
00998             free(order);
00999             break;
01000          case AST_MODULE_LOAD_FAILURE:
01001             res = -1;
01002             goto done;
01003          case AST_MODULE_LOAD_SKIP:
01004             /* 
01005              * Try again later. This result is received when a module is
01006              * deferred because it is not a part of the current pass. 
01007              */
01008             break;
01009          }
01010       }
01011       AST_LIST_TRAVERSE_SAFE_END;
01012    }
01013 
01014 done:
01015    while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
01016       free(order->resource);
01017       free(order);
01018    }
01019 
01020    AST_LIST_UNLOCK(&module_list);
01021 
01022    return res;
01023 }

int load_pbx ( void   ) 

Provided by pbx.c

Definition at line 6290 of file pbx.c.

References ast_cli_register_multiple(), ast_log(), ast_register_application(), ast_verbose(), builtins, LOG_ERROR, option_verbose, pbx_cli, and VERBOSE_PREFIX_1.

Referenced by main().

06291 {
06292    int x;
06293 
06294    /* Initialize the PBX */
06295    if (option_verbose) {
06296       ast_verbose( "Asterisk PBX Core Initializing\n");
06297       ast_verbose( "Registering builtin applications:\n");
06298    }
06299    ast_cli_register_multiple(pbx_cli, sizeof(pbx_cli) / sizeof(struct ast_cli_entry));
06300 
06301    /* Register builtin applications */
06302    for (x=0; x<sizeof(builtins) / sizeof(struct pbx_builtin); x++) {
06303       if (option_verbose)
06304          ast_verbose( VERBOSE_PREFIX_1 "[%s]\n", builtins[x].name);
06305       if (ast_register_application(builtins[x].name, builtins[x].execute, builtins[x].synopsis, builtins[x].description)) {
06306          ast_log(LOG_ERROR, "Unable to register builtin application '%s'\n", builtins[x].name);
06307          return -1;
06308       }
06309    }
06310    return 0;
06311 }

int reload_logger ( int   ) 

Provided by logger.c

Definition at line 361 of file logger.c.

References ast_config_AST_LOG_DIR, ast_copy_string(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_queue_log(), ast_verbose(), errno, EVENT_FLAG_SYSTEM, EVENTLOG, eventlog, f, init_logger_chain(), logchannel::list, LOG_ERROR, LOG_EVENT, logfiles, manager_event(), option_verbose, qlog, and QUEUELOG.

Referenced by ast_log(), handle_logger_rotate(), and logger_reload().

00363 {
00364    char old[PATH_MAX] = "";
00365    char new[PATH_MAX];
00366    int event_rotate = rotate, queue_rotate = rotate;
00367    struct logchannel *f;
00368    FILE *myf;
00369    int x, res = 0;
00370 
00371    AST_LIST_LOCK(&logchannels);
00372 
00373    if (eventlog) 
00374       fclose(eventlog);
00375    else 
00376       event_rotate = 0;
00377    eventlog = NULL;
00378 
00379    if (qlog) 
00380       fclose(qlog);
00381    else 
00382       queue_rotate = 0;
00383    qlog = NULL;
00384 
00385    mkdir((char *)ast_config_AST_LOG_DIR, 0755);
00386 
00387    AST_LIST_TRAVERSE(&logchannels, f, list) {
00388       if (f->disabled) {
00389          f->disabled = 0;  /* Re-enable logging at reload */
00390          manager_event(EVENT_FLAG_SYSTEM, "LogChannel", "Channel: %s\r\nEnabled: Yes\r\n", f->filename);
00391       }
00392       if (f->fileptr && (f->fileptr != stdout) && (f->fileptr != stderr)) {
00393          fclose(f->fileptr);  /* Close file */
00394          f->fileptr = NULL;
00395          if (rotate) {
00396             ast_copy_string(old, f->filename, sizeof(old));
00397    
00398             for (x = 0; ; x++) {
00399                snprintf(new, sizeof(new), "%s.%d", f->filename, x);
00400                myf = fopen((char *)new, "r");
00401                if (myf)
00402                   fclose(myf);
00403                else
00404                   break;
00405             }
00406        
00407             /* do it */
00408             if (rename(old,new))
00409                fprintf(stderr, "Unable to rename file '%s' to '%s'\n", old, new);
00410          }
00411       }
00412    }
00413 
00414    filesize_reload_needed = 0;
00415    
00416    init_logger_chain();
00417 
00418    if (logfiles.event_log) {
00419       snprintf(old, sizeof(old), "%s/%s", (char *)ast_config_AST_LOG_DIR, EVENTLOG);
00420       if (event_rotate) {
00421          for (x=0;;x++) {
00422             snprintf(new, sizeof(new), "%s/%s.%d", (char *)ast_config_AST_LOG_DIR, EVENTLOG,x);
00423             myf = fopen((char *)new, "r");
00424             if (myf)    /* File exists */
00425                fclose(myf);
00426             else
00427                break;
00428          }
00429    
00430          /* do it */
00431          if (rename(old,new))
00432             ast_log(LOG_ERROR, "Unable to rename file '%s' to '%s'\n", old, new);
00433       }
00434 
00435       eventlog = fopen(old, "a");
00436       if (eventlog) {
00437          ast_log(LOG_EVENT, "Restarted Asterisk Event Logger\n");
00438          if (option_verbose)
00439             ast_verbose("Asterisk Event Logger restarted\n");
00440       } else {
00441          ast_log(LOG_ERROR, "Unable to create event log: %s\n", strerror(errno));
00442          res = -1;
00443       }
00444    }
00445 
00446    if (logfiles.queue_log) {
00447       snprintf(old, sizeof(old), "%s/%s", (char *)ast_config_AST_LOG_DIR, QUEUELOG);
00448       if (queue_rotate) {
00449          for (x = 0; ; x++) {
00450             snprintf(new, sizeof(new), "%s/%s.%d", (char *)ast_config_AST_LOG_DIR, QUEUELOG, x);
00451             myf = fopen((char *)new, "r");
00452             if (myf)    /* File exists */
00453                fclose(myf);
00454             else
00455                break;
00456          }
00457    
00458          /* do it */
00459          if (rename(old, new))
00460             ast_log(LOG_ERROR, "Unable to rename file '%s' to '%s'\n", old, new);
00461       }
00462 
00463       qlog = fopen(old, "a");
00464       if (qlog) {
00465          ast_queue_log("NONE", "NONE", "NONE", "CONFIGRELOAD", "%s", "");
00466          ast_log(LOG_EVENT, "Restarted Asterisk Queue Logger\n");
00467          if (option_verbose)
00468             ast_verbose("Asterisk Queue Logger restarted\n");
00469       } else {
00470          ast_log(LOG_ERROR, "Unable to create queue log: %s\n", strerror(errno));
00471          res = -1;
00472       }
00473    }
00474 
00475    AST_LIST_UNLOCK(&logchannels);
00476 
00477    return res;

void threadstorage_init ( void   ) 

Provided by threadstorage.c

Definition at line 240 of file threadstorage.c.

Referenced by main().

00241 {
00242 }


Variable Documentation

char ast_config_AST_AGI_DIR[PATH_MAX]

Definition at line 230 of file asterisk.c.

char ast_config_AST_CONFIG_DIR[PATH_MAX]

Definition at line 222 of file asterisk.c.

char ast_config_AST_CONFIG_FILE[PATH_MAX]

Definition at line 223 of file asterisk.c.

char ast_config_AST_CTL[PATH_MAX]

Definition at line 241 of file asterisk.c.

char ast_config_AST_CTL_GROUP[PATH_MAX]

Definition at line 240 of file asterisk.c.

char ast_config_AST_CTL_OWNER[PATH_MAX]

Definition at line 239 of file asterisk.c.

char ast_config_AST_CTL_PERMISSIONS[PATH_MAX]

Definition at line 238 of file asterisk.c.

char ast_config_AST_DATA_DIR[PATH_MAX]

Definition at line 228 of file asterisk.c.

char ast_config_AST_DB[PATH_MAX]

Definition at line 231 of file asterisk.c.

char ast_config_AST_KEY_DIR[PATH_MAX]

Definition at line 232 of file asterisk.c.

char ast_config_AST_LOG_DIR[PATH_MAX]

Definition at line 229 of file asterisk.c.

char ast_config_AST_MODULE_DIR[PATH_MAX]

Definition at line 224 of file asterisk.c.

char ast_config_AST_MONITOR_DIR[PATH_MAX]

Definition at line 226 of file asterisk.c.

char ast_config_AST_PID[PATH_MAX]

Definition at line 233 of file asterisk.c.

char ast_config_AST_RUN_DIR[PATH_MAX]

Definition at line 235 of file asterisk.c.

char ast_config_AST_RUN_GROUP[PATH_MAX]

Definition at line 237 of file asterisk.c.

Referenced by action_coresettings(), handle_show_settings(), and main().

char ast_config_AST_RUN_USER[PATH_MAX]

Definition at line 236 of file asterisk.c.

Referenced by action_coresettings(), handle_show_settings(), and main().

char ast_config_AST_SOCKET[PATH_MAX]

Definition at line 234 of file asterisk.c.

char ast_config_AST_SPOOL_DIR[PATH_MAX]

Definition at line 225 of file asterisk.c.

char ast_config_AST_SYSTEM_NAME[20]

Definition at line 242 of file asterisk.c.

char ast_config_AST_VAR_DIR[PATH_MAX]

Definition at line 227 of file asterisk.c.


Generated on Thu Mar 25 12:09:45 2010 for Asterisk - the Open Source PBX by  doxygen 1.4.7