Wed Aug 15 01:24:44 2007

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"

Include dependency graph for asterisk.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_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)
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_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 172 of file asterisk.h.

#define DEFAULT_LANGUAGE   "en"

Definition at line 34 of file asterisk.h.

#define DEFAULT_SAMPLE_RATE   8000

Definition at line 36 of file asterisk.h.

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

#define DEFAULT_SAMPLES_PER_MS   ((DEFAULT_SAMPLE_RATE)/1000)

Definition at line 37 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 39 of file asterisk.h.

Referenced by ast_set_priority().

#define setpriority   __PLEASE_USE_ast_set_priority_INSTEAD_OF_setpriority__

Definition at line 38 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

(note, this must be documented a lot more) ast_add_profile allocates a generic 'counter' with a given name, which can be shown with the command 'show profile <name>'

The counter accumulates positive or negative values supplied by ast_add_profile(), dividing them by the 'scale' value passed in the create call, and also counts the number of 'events'. Values can also be taked by the TSC counter on ia32 architectures, in which case you can mark the start of an event calling ast_mark(id, 1) and then the end of the event with ast_mark(id, 0). For non-i386 architectures, these two calls return 0.

support for event profiling

Returns:
Returns the identifier of the counter.

Definition at line 370 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, profile_entry::scale, and profile_entry::value.

00371 {
00372    int l = sizeof(struct profile_data);
00373    int n = 10; /* default entries */
00374 
00375    if (prof_data == NULL) {
00376       prof_data = ast_calloc(1, l + n*sizeof(struct profile_entry));
00377       if (prof_data == NULL)
00378          return -1;
00379       prof_data->entries = 0;
00380       prof_data->max_size = n;
00381    }
00382    if (prof_data->entries >= prof_data->max_size) {
00383       void *p;
00384       n = prof_data->max_size + 20;
00385       p = ast_realloc(prof_data, l + n*sizeof(struct profile_entry));
00386       if (p == NULL)
00387          return -1;
00388       prof_data = p;
00389       prof_data->max_size = n;
00390    }
00391    n = prof_data->entries++;
00392    prof_data->e[n].name = ast_strdup(name);
00393    prof_data->e[n].value = 0;
00394    prof_data->e[n].events = 0;
00395    prof_data->e[n].mark = 0;
00396    prof_data->e[n].scale = scale;
00397    return n;
00398 }

void ast_builtins_init ( void   ) 

initialize the _full_cmd string in * each of the builtins.

Provided by cli.c

Definition at line 1496 of file cli.c.

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

01497 {
01498    struct ast_cli_entry *e;
01499 
01500    for (e = builtins; e->cmda[0] != NULL; e++) {
01501       char buf[80];
01502       ast_join(buf, sizeof(buf), e->cmda);
01503       e->_full_cmd = strdup(buf);
01504       if (!e->_full_cmd)
01505          ast_log(LOG_WARNING, "-- cannot allocate <%s>\n", buf);
01506    }
01507 
01508    ast_cli_register_multiple(cli_cli, sizeof(cli_cli) / sizeof(struct ast_cli_entry));
01509 }

void ast_channels_init ( void   ) 

Provided by channel.c

Definition at line 4570 of file channel.c.

References ast_cli_register_multiple(), and cli_channel.

04571 {
04572    ast_cli_register_multiple(cli_channel, sizeof(cli_channel) / sizeof(struct ast_cli_entry));
04573 }

int64_t ast_mark ( int  ,
int  start1_stop0 
)

Definition at line 432 of file asterisk.c.

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

00433 {
00434    if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
00435       return 0;
00436    if (startstop == 1)
00437       prof_data->e[i].mark = rdtsc();
00438    else {
00439       prof_data->e[i].mark = (rdtsc() - prof_data->e[i].mark);
00440       if (prof_data->e[i].scale > 1)
00441          prof_data->e[i].mark /= prof_data->e[i].scale;
00442       prof_data->e[i].value += prof_data->e[i].mark;
00443       prof_data->e[i].events++;
00444    }
00445    return prof_data->e[i].mark;
00446 }

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

References ast_lastreloadtime, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_trylock(), ast_mutex_unlock(), ast_verbose(), ast_module::declined, ast_module_info::description, ast_module::flags, ast_module::info, option_verbose, ast_module_info::reload, resource_name_match(), ast_module::running, and VERBOSE_PREFIX_3.

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

int64_t ast_profile ( int  ,
int64_t   
)

Definition at line 400 of file asterisk.c.

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

00401 {
00402    if (!prof_data || i < 0 || i > prof_data->entries) /* invalid index */
00403       return 0;
00404    if (prof_data->e[i].scale > 1)
00405       delta /= prof_data->e[i].scale;
00406    prof_data->e[i].value += delta;
00407    prof_data->e[i].events++;
00408    return prof_data->e[i].value;
00409 }

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 700 of file asterisk.c.

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

00701 {
00702    int res = -1;
00703    struct ast_atexit *ae;
00704    ast_unregister_atexit(func);  
00705    AST_LIST_LOCK(&atexits);
00706    if ((ae = ast_calloc(1, sizeof(*ae)))) {
00707       AST_LIST_INSERT_HEAD(&atexits, ae, list);
00708       ae->func = func;
00709       res = 0;
00710    }
00711    AST_LIST_UNLOCK(&atexits);
00712    return res;
00713 }

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 254 of file asterisk.c.

References ast_calloc, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_strdupa, and ast_strip_quoted().

00255 {
00256    struct file_version *new;
00257    char *work;
00258    size_t version_length;
00259 
00260    work = ast_strdupa(version);
00261    work = ast_strip(ast_strip_quoted(work, "$", "$"));
00262    version_length = strlen(work) + 1;
00263    
00264    if (!(new = ast_calloc(1, sizeof(*new) + version_length)))
00265       return;
00266 
00267    new->file = file;
00268    new->version = (char *) new + sizeof(*new);
00269    memcpy(new->version, work, version_length);
00270    AST_LIST_LOCK(&file_versions);
00271    AST_LIST_INSERT_HEAD(&file_versions, new, list);
00272    AST_LIST_UNLOCK(&file_versions);
00273 }

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 1166 of file asterisk.c.

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

01167 {
01168    struct sched_param sched;
01169    memset(&sched, 0, sizeof(sched));
01170 #ifdef __linux__
01171    if (pri) {  
01172       sched.sched_priority = 10;
01173       if (sched_setscheduler(0, SCHED_RR, &sched)) {
01174          ast_log(LOG_WARNING, "Unable to set high priority\n");
01175          return -1;
01176       } else
01177          if (option_verbose)
01178             ast_verbose("Set to realtime thread\n");
01179    } else {
01180       sched.sched_priority = 0;
01181       /* According to the manpage, these parameters can never fail. */
01182       sched_setscheduler(0, SCHED_OTHER, &sched);
01183    }
01184 #else
01185    if (pri) {
01186       if (setpriority(PRIO_PROCESS, 0, -10) == -1) {
01187          ast_log(LOG_WARNING, "Unable to set high priority\n");
01188          return -1;
01189       } else
01190          if (option_verbose)
01191             ast_verbose("Set to high priority\n");
01192    } else {
01193       /* According to the manpage, these parameters can never fail. */
01194       setpriority(PRIO_PROCESS, 0, 0);
01195    }
01196 #endif
01197    return 0;
01198 }

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.

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 715 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, func, and ast_atexit::func.

00716 {
00717    struct ast_atexit *ae;
00718    AST_LIST_LOCK(&atexits);
00719    AST_LIST_TRAVERSE_SAFE_BEGIN(&atexits, ae, list) {
00720       if (ae->func == func) {
00721          AST_LIST_REMOVE_CURRENT(&atexits, list);
00722          break;
00723       }
00724    }
00725    AST_LIST_TRAVERSE_SAFE_END
00726    AST_LIST_UNLOCK(&atexits);
00727 }

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 275 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, and free.

00276 {
00277    struct file_version *find;
00278 
00279    AST_LIST_LOCK(&file_versions);
00280    AST_LIST_TRAVERSE_SAFE_BEGIN(&file_versions, find, list) {
00281       if (!strcasecmp(find->file, file)) {
00282          AST_LIST_REMOVE_CURRENT(&file_versions, list);
00283          break;
00284       }
00285    }
00286    AST_LIST_TRAVERSE_SAFE_END;
00287    AST_LIST_UNLOCK(&file_versions);
00288    if (find)
00289       free(find);
00290 }

int astdb_init ( void   ) 

Provided by db.c

Definition at line 584 of file db.c.

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

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

void close_logger ( void   ) 

Provided by logger.c

Definition at line 620 of file logger.c.

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

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

int dnsmgr_init ( void   ) 

Provided by dnsmgr.c

Definition at line 337 of file dnsmgr.c.

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

00338 {
00339    if (!(sched = sched_context_create())) {
00340       ast_log(LOG_ERROR, "Unable to create schedule context.\n");
00341       return -1;
00342    }
00343    ast_cli_register(&cli_reload);
00344    ast_cli_register(&cli_status);
00345    return do_reload(1);
00346 }

int dnsmgr_reload ( void   ) 

Provided by dnsmgr.c

Definition at line 348 of file dnsmgr.c.

References do_reload().

00349 {
00350    return do_reload(0);
00351 }

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, and refresh_list().

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 1040 of file frame.c.

References ast_cli_register_multiple().

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

int init_logger ( void   ) 

Provided by logger.c

Definition at line 581 of file logger.c.

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

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

int load_modules ( unsigned  int  ) 

Provided by loader.c

Definition at line 725 of file loader.c.

References add_to_load_order(), ast_config_AST_MODULE_DIR, ast_config_destroy(), ast_config_load(), AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_REMOVE_HEAD, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log(), AST_MODULE_CONFIG, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SKIP, AST_MODULE_LOAD_SUCCESS, ast_opt_quiet, ast_true(), ast_variable_browse(), ast_variable_retrieve(), ast_verbose(), embedding, find_resource(), ast_module::flags, free, ast_module::lib, load_resource(), LOG_NOTICE, LOG_WARNING, ast_variable::name, ast_variable::next, option_verbose, load_order_entry::resource, resource_name_match(), ast_module::running, and ast_variable::value.

00726 {
00727    struct ast_config *cfg;
00728    struct ast_module *mod;
00729    struct load_order_entry *order;
00730    struct ast_variable *v;
00731    unsigned int load_count;
00732    struct load_order load_order;
00733    int res = 0;
00734 #if LOADABLE_MODULES
00735    struct dirent *dirent;
00736    DIR *dir;
00737 #endif
00738 
00739    /* all embedded modules have registered themselves by now */
00740    embedding = 0;
00741 
00742    if (option_verbose)
00743       ast_verbose("Asterisk Dynamic Loader Starting:\n");
00744 
00745    AST_LIST_HEAD_INIT_NOLOCK(&load_order);
00746 
00747    AST_LIST_LOCK(&module_list);
00748 
00749    if (!(cfg = ast_config_load(AST_MODULE_CONFIG))) {
00750       ast_log(LOG_WARNING, "No '%s' found, no modules will be loaded.\n", AST_MODULE_CONFIG);
00751       goto done;
00752    }
00753 
00754    /* first, find all the modules we have been explicitly requested to load */
00755    for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00756       if (!strcasecmp(v->name, preload_only ? "preload" : "load"))
00757          add_to_load_order(v->value, &load_order);
00758    }
00759 
00760    /* check if 'autoload' is on */
00761    if (!preload_only && ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) {
00762       /* if so, first add all the embedded modules that are not already running to the load order */
00763       AST_LIST_TRAVERSE(&module_list, mod, entry) {
00764          /* if it's not embedded, skip it */
00765          if (mod->lib)
00766             continue;
00767 
00768          if (mod->flags.running)
00769             continue;
00770 
00771          order = add_to_load_order(mod->resource, &load_order);
00772       }
00773 
00774 #if LOADABLE_MODULES
00775       /* if we are allowed to load dynamic modules, scan the directory for
00776          for all available modules and add them as well */
00777       if ((dir  = opendir(ast_config_AST_MODULE_DIR))) {
00778          while ((dirent = readdir(dir))) {
00779             int ld = strlen(dirent->d_name);
00780 
00781             /* Must end in .so to load it.  */
00782 
00783             if (ld < 4)
00784                continue;
00785 
00786             if (strcasecmp(dirent->d_name + ld - 3, ".so"))
00787                continue;
00788 
00789             /* if there is already a module by this name in the module_list,
00790                skip this file */
00791             if (find_resource(dirent->d_name, 0))
00792                continue;
00793 
00794             add_to_load_order(dirent->d_name, &load_order);
00795          }
00796 
00797          closedir(dir);
00798       } else {
00799          if (!ast_opt_quiet)
00800             ast_log(LOG_WARNING, "Unable to open modules directory '%s'.\n",
00801                ast_config_AST_MODULE_DIR);
00802       }
00803 #endif
00804    }
00805 
00806    /* now scan the config for any modules we are prohibited from loading and
00807       remove them from the load order */
00808    for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) {
00809       if (strcasecmp(v->name, "noload"))
00810          continue;
00811 
00812       AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00813          if (!resource_name_match(order->resource, v->value)) {
00814             AST_LIST_REMOVE_CURRENT(&load_order, entry);
00815             free(order->resource);
00816             free(order);
00817          }
00818       }
00819       AST_LIST_TRAVERSE_SAFE_END;
00820    }
00821 
00822    /* we are done with the config now, all the information we need is in the
00823       load_order list */
00824    ast_config_destroy(cfg);
00825 
00826    load_count = 0;
00827    AST_LIST_TRAVERSE(&load_order, order, entry)
00828       load_count++;
00829 
00830    if (load_count)
00831       ast_log(LOG_NOTICE, "%d modules will be loaded.\n", load_count);
00832 
00833    /* first, load only modules that provide global symbols */
00834    AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00835       switch (load_resource(order->resource, 1)) {
00836       case AST_MODULE_LOAD_SUCCESS:
00837       case AST_MODULE_LOAD_DECLINE:
00838          AST_LIST_REMOVE_CURRENT(&load_order, entry);
00839          free(order->resource);
00840          free(order);
00841          break;
00842       case AST_MODULE_LOAD_FAILURE:
00843          res = -1;
00844          goto done;
00845       case AST_MODULE_LOAD_SKIP:
00846          /* try again later */
00847          break;
00848       }
00849    }
00850    AST_LIST_TRAVERSE_SAFE_END;
00851 
00852    /* now load everything else */
00853    AST_LIST_TRAVERSE_SAFE_BEGIN(&load_order, order, entry) {
00854       switch (load_resource(order->resource, 0)) {
00855       case AST_MODULE_LOAD_SUCCESS:
00856       case AST_MODULE_LOAD_DECLINE:
00857          AST_LIST_REMOVE_CURRENT(&load_order, entry);
00858          free(order->resource);
00859          free(order);
00860          break;
00861       case AST_MODULE_LOAD_FAILURE:
00862          res = -1;
00863          goto done;
00864       case AST_MODULE_LOAD_SKIP:
00865          /* should not happen */
00866          break;
00867       }
00868    }
00869    AST_LIST_TRAVERSE_SAFE_END;
00870 
00871 done:
00872    while ((order = AST_LIST_REMOVE_HEAD(&load_order, entry))) {
00873       free(order->resource);
00874       free(order);
00875    }
00876 
00877    AST_LIST_UNLOCK(&module_list);
00878 
00879    return res;
00880 }

int load_pbx ( void   ) 

Provided by pbx.c

Definition at line 6035 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.

06036 {
06037    int x;
06038 
06039    /* Initialize the PBX */
06040    if (option_verbose) {
06041       ast_verbose( "Asterisk PBX Core Initializing\n");
06042       ast_verbose( "Registering builtin applications:\n");
06043    }
06044    ast_cli_register_multiple(pbx_cli, sizeof(pbx_cli) / sizeof(struct ast_cli_entry));
06045 
06046    /* Register builtin applications */
06047    for (x=0; x<sizeof(builtins) / sizeof(struct pbx_builtin); x++) {
06048       if (option_verbose)
06049          ast_verbose( VERBOSE_PREFIX_1 "[%s]\n", builtins[x].name);
06050       if (ast_register_application(builtins[x].name, builtins[x].execute, builtins[x].synopsis, builtins[x].description)) {
06051          ast_log(LOG_ERROR, "Unable to register builtin application '%s'\n", builtins[x].name);
06052          return -1;
06053       }
06054    }
06055    return 0;
06056 }

int reload_logger ( int   ) 

Provided by logger.c

Definition at line 368 of file logger.c.

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

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;
00484 }

void threadstorage_init ( void   ) 

Provided by threadstorage.c

Definition at line 222 of file threadstorage.c.

00223 {
00224 }


Variable Documentation

char ast_config_AST_AGI_DIR[PATH_MAX]

Definition at line 211 of file asterisk.c.

char ast_config_AST_CONFIG_DIR[PATH_MAX]

Definition at line 203 of file asterisk.c.

char ast_config_AST_CONFIG_FILE[PATH_MAX]

Definition at line 204 of file asterisk.c.

char ast_config_AST_CTL[PATH_MAX]

Definition at line 222 of file asterisk.c.

char ast_config_AST_CTL_GROUP[PATH_MAX]

Definition at line 221 of file asterisk.c.

char ast_config_AST_CTL_OWNER[PATH_MAX]

Definition at line 220 of file asterisk.c.

char ast_config_AST_CTL_PERMISSIONS[PATH_MAX]

Definition at line 219 of file asterisk.c.

char ast_config_AST_DATA_DIR[PATH_MAX]

Definition at line 209 of file asterisk.c.

char ast_config_AST_DB[PATH_MAX]

Definition at line 212 of file asterisk.c.

char ast_config_AST_KEY_DIR[PATH_MAX]

Definition at line 213 of file asterisk.c.

char ast_config_AST_LOG_DIR[PATH_MAX]

Definition at line 210 of file asterisk.c.

char ast_config_AST_MODULE_DIR[PATH_MAX]

Definition at line 205 of file asterisk.c.

char ast_config_AST_MONITOR_DIR[PATH_MAX]

Definition at line 207 of file asterisk.c.

char ast_config_AST_PID[PATH_MAX]

Definition at line 214 of file asterisk.c.

char ast_config_AST_RUN_DIR[PATH_MAX]

Definition at line 216 of file asterisk.c.

char ast_config_AST_SOCKET[PATH_MAX]

Definition at line 215 of file asterisk.c.

char ast_config_AST_SPOOL_DIR[PATH_MAX]

Definition at line 206 of file asterisk.c.

char ast_config_AST_SYSTEM_NAME[20]

Definition at line 223 of file asterisk.c.

char ast_config_AST_VAR_DIR[PATH_MAX]

Definition at line 208 of file asterisk.c.


Generated on Wed Aug 15 01:24:45 2007 for Asterisk - the Open Source PBX by  doxygen 1.5.3