Wed Mar 4 19:58:23 2009

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)
int64_t ast_mark (int, int start1_stop0)
int ast_module_reload (const char *name)
 Reload asterisk modules.
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 173 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 483 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().

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

void ast_autoservice_init ( void   ) 

Provided by astobj2.c Provided by autoservice.c

Definition at line 316 of file autoservice.c.

References as_cond, and ast_cond_init().

Referenced by main().

00317 {
00318    ast_cond_init(&as_cond, NULL);
00319 }

void ast_builtins_init ( void   ) 

initialize the _full_cmd string in * each of the builtins.

Provided by cli.c

Definition at line 1505 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().

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

void ast_channels_init ( void   ) 

Provided by channel.c

Definition at line 4568 of file channel.c.

References ast_cli_register_multiple(), and cli_channel.

Referenced by main().

04569 {
04570    ast_cli_register_multiple(cli_channel, sizeof(cli_channel) / sizeof(struct ast_cli_entry));
04571 }

int64_t ast_mark ( int  ,
int  start1_stop0 
)

Definition at line 548 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().

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

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 545 of file loader.c.

References 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, ast_module_info::reload, reloadlock, ast_module::resource, resource_name_match(), ast_module::running, and VERBOSE_PREFIX_3.

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

00546 {
00547    struct ast_module *cur;
00548    int res = 0; /* return value. 0 = not found, others, see below */
00549    int i;
00550 
00551    if (ast_mutex_trylock(&reloadlock)) {
00552       ast_verbose("The previous reload command didn't finish yet\n");
00553       return -1;  /* reload already in progress */
00554    }
00555    ast_lastreloadtime = time(NULL);
00556 
00557    /* Call "predefined" reload here first */
00558    for (i = 0; reload_classes[i].name; i++) {
00559       if (!name || !strcasecmp(name, reload_classes[i].name)) {
00560          reload_classes[i].reload_fn();   /* XXX should check error ? */
00561          res = 2; /* found and reloaded */
00562       }
00563    }
00564 
00565    if (name && res) {
00566       ast_mutex_unlock(&reloadlock);
00567       return res;
00568    }
00569 
00570    AST_LIST_LOCK(&module_list);
00571    AST_LIST_TRAVERSE(&module_list, cur, entry) {
00572       const struct ast_module_info *info = cur->info;
00573 
00574       if (name && resource_name_match(name, cur->resource))
00575          continue;
00576 
00577       if (!cur->flags.running || cur->flags.declined) {
00578          if (!name)
00579             continue;
00580          ast_log(LOG_NOTICE, "The module '%s' was not properly initialized.  "
00581             "Before reloading the module, you must run \"module load %s\" "
00582             "and fix whatever is preventing the module from being initialized.\n",
00583             name, name);
00584          res = 2; /* Don't report that the module was not found */
00585          break;
00586       }
00587 
00588       if (!info->reload) { /* cannot be reloaded */
00589          if (res < 1)   /* store result if possible */
00590             res = 1; /* 1 = no reload() method */
00591          continue;
00592       }
00593 
00594       res = 2;
00595       if (option_verbose > 2)
00596          ast_verbose(VERBOSE_PREFIX_3 "Reloading module '%s' (%s)\n", cur->resource, info->description);
00597       info->reload();
00598    }
00599    AST_LIST_UNLOCK(&module_list);
00600 
00601    ast_mutex_unlock(&reloadlock);
00602 
00603    return res;
00604 }

int64_t ast_profile ( int  ,
int64_t   
)

Definition at line 513 of file asterisk.c.

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

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

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 816 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().

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

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 272 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.

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

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 1322 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().

01323 {
01324    struct sched_param sched;
01325    memset(&sched, 0, sizeof(sched));
01326 #ifdef __linux__
01327    if (pri) {  
01328       sched.sched_priority = 10;
01329       if (sched_setscheduler(0, SCHED_RR, &sched)) {
01330          ast_log(LOG_WARNING, "Unable to set high priority\n");
01331          return -1;
01332       } else
01333          if (option_verbose)
01334             ast_verbose("Set to realtime thread\n");
01335    } else {
01336       sched.sched_priority = 0;
01337       /* According to the manpage, these parameters can never fail. */
01338       sched_setscheduler(0, SCHED_OTHER, &sched);
01339    }
01340 #else
01341    if (pri) {
01342       if (setpriority(PRIO_PROCESS, 0, -10) == -1) {
01343          ast_log(LOG_WARNING, "Unable to set high priority\n");
01344          return -1;
01345       } else
01346          if (option_verbose)
01347             ast_verbose("Set to high priority\n");
01348    } else {
01349       /* According to the manpage, these parameters can never fail. */
01350       setpriority(PRIO_PROCESS, 0, 0);
01351    }
01352 #endif
01353    return 0;
01354 }

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 834 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().

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

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 293 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.

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

int astdb_init ( void   ) 

Provided by db.c

Definition at line 585 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().

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

int astobj2_init ( void   ) 

Definition at line 764 of file astobj2.c.

References ARRAY_LEN, and ast_cli_register_multiple().

Referenced by main().

00765 {
00766 #ifdef AO2_DEBUG
00767    ast_cli_register_multiple(cli_astobj2, ARRAY_LEN(cli_astobj2));
00768 #endif
00769 
00770    return 0;
00771 }

void close_logger ( void   ) 

Provided by logger.c

Definition at line 627 of file logger.c.

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

Referenced by quit_handler().

00629 {
00630    struct logchannel *f;
00631 
00632    AST_LIST_LOCK(&logchannels);
00633 
00634    if (eventlog) {
00635       fclose(eventlog);
00636       eventlog = NULL;
00637    }
00638 
00639    if (qlog) {
00640       fclose(qlog);
00641       qlog = NULL;
00642    }
00643 
00644    AST_LIST_TRAVERSE(&logchannels, f, list) {
00645       if (f->fileptr && (f->fileptr != stdout) && (f->fileptr != stderr)) {
00646          fclose(f->fileptr);
00647          f->fileptr = NULL;
00648       }
00649    }
00650 
00651    closelog(); /* syslog */
00652 
00653    AST_LIST_UNLOCK(&logchannels);
00654 
00655    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 1037 of file frame.c.

References ast_cli_register_multiple(), and my_clis.

Referenced by main().

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

int init_logger ( void   ) 

Provided by logger.c

Definition at line 588 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().

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

int load_modules ( unsigned  int  ) 

Provided by loader.c

Definition at line 758 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().

00759 {
00760    struct ast_config *cfg;
00761    struct ast_module *mod;
00762    struct load_order_entry *order;
00763    struct ast_variable *v;
00764    unsigned int load_count;
00765    struct load_order load_order;
00766    int res = 0;
00767 
00768    int translate_status;
00769    char newname[18]; /* although this would normally be 80, max length in translate_module_name is 18 */
00770 #ifdef LOADABLE_MODULES
00771    struct dirent *dirent;
00772    DIR *dir;
00773 #endif
00774 
00775    /* all embedded modules have registered themselves by now */
00776    embedding = 0;
00777 
00778    if (option_verbose)
00779       ast_verbose("Asterisk Dynamic Loader Starting:\n");
00780 
00781    AST_LIST_HEAD_INIT_NOLOCK(&load_order);
00782 
00783    AST_LIST_LOCK(&module_list);
00784 
00785    if (!(cfg = ast_config_load(AST_MODULE_CONFIG))) {
00786       ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
00787       goto done;
00788    }
00789 
00790    /* first, find all the modules we have been explicitly requested to load */
00791    for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00792       if (!strcasecmp(v->name, preload_only ? "preload" : "load")) {
00793          translate_status = translate_module_name(v->value, newname);
00794             if (!translate_status)
00795                ast_log(LOG_WARNING, "Use of old module name %s is deprecated, please use %s instead.\n", v->value, newname);
00796          add_to_load_order(translate_status ? v->value : newname, &load_order);
00797       }
00798    }
00799 
00800    /* check if 'autoload' is on */
00801    if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
00802       /* if so, first add all the embedded modules that are not already running to the load order */
00803       AST_LIST_TRAVERSE(&module_list, mod, entry) {
00804          /* if it's not embedded, skip it */
00805          if (mod->lib)
00806             continue;
00807 
00808          if (mod->flags.running)
00809             continue;
00810 
00811          order = add_to_load_order(mod->resource, &load_order);
00812       }
00813 
00814 #ifdef LOADABLE_MODULES
00815       /* if we are allowed to load dynamic modules, scan the directory for
00816          for all available modules and add them as well */
00817       if ((dir  = opendir(ast_config_AST_MODULE_DIR))) {
00818          while ((dirent = readdir(dir))) {
00819             int ld = strlen(dirent->d_name);
00820 
00821             /* Must end in .so to load it.  */
00822 
00823             if (ld < 4)
00824                continue;
00825 
00826             if (strcasecmp(dirent->d_name + ld - 3, ".so"))
00827                continue;
00828 
00829             /* if there is already a module by this name in the module_list,
00830                skip this file */
00831             if (find_resource(dirent->d_name, 0))
00832                continue;
00833 
00834             add_to_load_order(dirent->d_name, &load_order);
00835          }
00836 
00837          closedir(dir);
00838       } else {
00839          if (!ast_opt_quiet)
00840             ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
00841                ast_config_AST_MODULE_DIR);
00842       }
00843 #endif
00844    }
00845 
00846    /* now scan the config for any modules we are prohibited from loading and
00847       remove them from the load order */
00848    for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00849       if (strcasecmp(v->name, "noload"))
00850          continue;
00851 
00852       AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00853          translate_status = translate_module_name(v->value, newname);
00854          if (!resource_name_match(order->resource, translate_status ? v->value : newname)) {
00855                if (!translate_status)
00856                   ast_log(LOG_WARNING, "Use of old module name %s is deprecated, please use %s instead.\n", v->value, newname);
00857             AST_LIST_REMOVE_CURRENT(&load_order, entry);
00858             free(order->resource);
00859             free(order);
00860          }
00861       }
00862       AST_LIST_TRAVERSE_SAFE_END;
00863    }
00864 
00865    /* we are done with the config now, all the information we need is in the
00866       load_order list */
00867    ast_config_destroy(cfg);
00868 
00869    load_count = 0;
00870    AST_LIST_TRAVERSE(&load_order, order, entry)
00871       load_count++;
00872 
00873    if (load_count)
00874       ast_log(LOG_NOTICE, "%d modules will be loaded.\n", load_count);
00875 
00876    /* first, load only modules that provide global symbols */
00877    AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00878       switch (load_resource(order->resource, 1)) {
00879       case AST_MODULE_LOAD_SUCCESS:
00880       case AST_MODULE_LOAD_DECLINE:
00881          AST_LIST_REMOVE_CURRENT(&load_order, entry);
00882          free(order->resource);
00883          free(order);
00884          break;
00885       case AST_MODULE_LOAD_FAILURE:
00886          res = -1;
00887          goto done;
00888       case AST_MODULE_LOAD_SKIP:
00889          /* try again later */
00890          break;
00891       }
00892    }
00893    AST_LIST_TRAVERSE_SAFE_END;
00894 
00895    /* now load everything else */
00896    AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00897       switch (load_resource(order->resource, 0)) {
00898       case AST_MODULE_LOAD_SUCCESS:
00899       case AST_MODULE_LOAD_DECLINE:
00900          AST_LIST_REMOVE_CURRENT(&load_order, entry);
00901          free(order->resource);
00902          free(order);
00903          break;
00904       case AST_MODULE_LOAD_FAILURE:
00905          res = -1;
00906          goto done;
00907       case AST_MODULE_LOAD_SKIP:
00908          /* should not happen */
00909          break;
00910       }
00911    }
00912    AST_LIST_TRAVERSE_SAFE_END;
00913 
00914 done:
00915    while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
00916       free(order->resource);
00917       free(order);
00918    }
00919 
00920    AST_LIST_UNLOCK(&module_list);
00921 
00922    return res;
00923 }

int load_pbx ( void   ) 

Provided by pbx.c

Definition at line 6221 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().

06222 {
06223    int x;
06224 
06225    /* Initialize the PBX */
06226    if (option_verbose) {
06227       ast_verbose( "Asterisk PBX Core Initializing\n");
06228       ast_verbose( "Registering builtin applications:\n");
06229    }
06230    ast_cli_register_multiple(pbx_cli, sizeof(pbx_cli) / sizeof(struct ast_cli_entry));
06231 
06232    /* Register builtin applications */
06233    for (x=0; x<sizeof(builtins) / sizeof(struct pbx_builtin); x++) {
06234       if (option_verbose)
06235          ast_verbose( VERBOSE_PREFIX_1 "[%s]\n", builtins[x].name);
06236       if (ast_register_application(builtins[x].name, builtins[x].execute, builtins[x].synopsis, builtins[x].description)) {
06237          ast_log(LOG_ERROR, "Unable to register builtin application '%s'\n", builtins[x].name);
06238          return -1;
06239       }
06240    }
06241    return 0;
06242 }

int reload_logger ( int   ) 

Provided by logger.c

Definition at line 367 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().

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

char ast_config_AST_CONFIG_DIR[PATH_MAX]

Definition at line 221 of file asterisk.c.

char ast_config_AST_CONFIG_FILE[PATH_MAX]

Definition at line 222 of file asterisk.c.

char ast_config_AST_CTL[PATH_MAX]

Definition at line 240 of file asterisk.c.

char ast_config_AST_CTL_GROUP[PATH_MAX]

Definition at line 239 of file asterisk.c.

char ast_config_AST_CTL_OWNER[PATH_MAX]

Definition at line 238 of file asterisk.c.

char ast_config_AST_CTL_PERMISSIONS[PATH_MAX]

Definition at line 237 of file asterisk.c.

char ast_config_AST_DATA_DIR[PATH_MAX]

Definition at line 227 of file asterisk.c.

char ast_config_AST_DB[PATH_MAX]

Definition at line 230 of file asterisk.c.

char ast_config_AST_KEY_DIR[PATH_MAX]

Definition at line 231 of file asterisk.c.

char ast_config_AST_LOG_DIR[PATH_MAX]

Definition at line 228 of file asterisk.c.

char ast_config_AST_MODULE_DIR[PATH_MAX]

Definition at line 223 of file asterisk.c.

char ast_config_AST_MONITOR_DIR[PATH_MAX]

Definition at line 225 of file asterisk.c.

char ast_config_AST_PID[PATH_MAX]

Definition at line 232 of file asterisk.c.

char ast_config_AST_RUN_DIR[PATH_MAX]

Definition at line 234 of file asterisk.c.

char ast_config_AST_RUN_GROUP[PATH_MAX]

Definition at line 236 of file asterisk.c.

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

char ast_config_AST_RUN_USER[PATH_MAX]

Definition at line 235 of file asterisk.c.

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

char ast_config_AST_SOCKET[PATH_MAX]

Definition at line 233 of file asterisk.c.

char ast_config_AST_SPOOL_DIR[PATH_MAX]

Definition at line 224 of file asterisk.c.

char ast_config_AST_SYSTEM_NAME[20]

Definition at line 241 of file asterisk.c.

char ast_config_AST_VAR_DIR[PATH_MAX]

Definition at line 226 of file asterisk.c.


Generated on Wed Mar 4 19:58:23 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7