config.c File Reference

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <asterisk/config.h>
#include <asterisk/config_pvt.h>
#include <asterisk/cli.h>
#include <asterisk/lock.h>
#include <asterisk/options.h>
#include <asterisk/logger.h>
#include <asterisk/utils.h>
#include "asterisk.h"
#include "astconf.h"

Include dependency graph for config.c:

Go to the source code of this file.

Functions

 AST_MUTEX_DEFINE_STATIC (ast_cust_config_lock)
void ast_destroy (struct ast_config *ast)
 Removes a config.
int ast_true (char *s)
 Make sure something is true.
int ast_false (char *s)
 Make sure something is false.
struct ast_variableast_variable_browse (struct ast_config *config, char *category)
 Goes through variables.
char * ast_variable_retrieve (struct ast_config *config, char *category, char *value)
 Gets a variable.
int ast_category_exist (struct ast_config *config, char *category_name)
 Check for category duplicates.
int ast_save (char *configfile, struct ast_config *cfg, char *generator)
struct ast_config_regget_ast_cust_config_keyword (char *name)
struct ast_config_regget_ast_cust_config (char *name)
void ast_config_destroy_all (void)
struct ast_config_regget_config_registrations (void)
int ast_config_register (struct ast_config_reg *new)
int ast_config_deregister (struct ast_config_reg *del)
int ast_cust_config_active (void)
struct ast_configast_load (char *configfile)
 Load a config file.
char * ast_category_browse (struct ast_config *config, char *prev)
 Goes through categories.
struct ast_configast_new_config (void)
struct ast_categoryast_new_category (char *name)
struct ast_variableast_new_variable (char *name, char *value)
int ast_cust_config_register (struct ast_config_reg *new)
int ast_cust_config_deregister (struct ast_config_reg *new)
int register_config_cli ()
int read_ast_cust_config (void)

Variables

struct ast_config *(* global_load_func )(char *, struct ast_config *, struct ast_category **, struct ast_variable **, int)


Function Documentation

char* ast_category_browse ( struct ast_config config,
char *  prev 
)

Goes through categories.

Parameters:
config Which config file you wish to "browse"
prev A pointer to a previous category. This funtion is kind of non-intuitive in it's use. To begin, one passes NULL as the second arguement. It will return a pointer to the string of the first category in the file. From here on after, one must then pass the previous usage's return value as the second pointer, and it will return a pointer to the category name afterwards. Note: If you manually strcpy a string into a character array and pass it thinking it will return your category, it will not; the comparisons are not done doing strcmp, they are done by checking whether the value of the string POINTER is the same. Returns a category on success, or NULL on failure/no-more-categories

Definition at line 936 of file config.c.

00937 {  
00938    struct ast_category *cat;
00939    if (!prev) {
00940       if (config->root)
00941          return config->root->name;
00942       else
00943          return NULL;
00944    }
00945    cat = config->root;
00946    while(cat) {
00947       if (cat->name == prev) {
00948          if (cat->next)
00949             return cat->next->name;
00950          else
00951             return NULL;
00952       }
00953       cat = cat->next;
00954    }
00955    cat = config->root;
00956    while(cat) {
00957       if (!strcasecmp(cat->name, prev)) {
00958          if (cat->next)
00959             return cat->next->name;
00960          else
00961             return NULL;
00962       }
00963       cat = cat->next;
00964    }
00965    return NULL;
00966 }

int ast_category_exist ( struct ast_config config,
char *  category_name 
)

Check for category duplicates.

Parameters:
config which config to use
category_name name of the category you're looking for This will search through the categories within a given config file and search for a match. The passed category_name can be a regular string (as opposed to a pointer of an existent string, lol) Browse config structure and check for category duplicity Return non-zero if found

Definition at line 399 of file config.c.

00400 {
00401    struct ast_category *category = NULL;
00402 
00403    category = config->root;
00404 
00405    while(category) {
00406       if (!strcasecmp(category->name,category_name)) 
00407          return 1;
00408       category = category->next;
00409    } 
00410 
00411    return 0;
00412 }

int ast_config_deregister ( struct ast_config_reg del  ) 

Definition at line 892 of file config.c.

00893 {
00894    struct ast_config_reg *ptr=NULL,*last=NULL;
00895    ast_mutex_lock(&ast_cust_config_lock);
00896    for (ptr=ast_cust_config_list;ptr;ptr=ptr->next) {
00897       if (ptr == del) {
00898          if (last && ptr->next) {
00899             last->next = ptr->next;
00900          } else if (last && ! ptr->next) {
00901             last->next = NULL;
00902          } else if (!last && ptr->next) {
00903             ast_cust_config_list = ptr->next;
00904          } else if (!last && !ptr->next) {
00905             ast_cust_config_list = NULL;
00906          }
00907       }
00908       last = ptr;
00909    }
00910    ast_mutex_unlock(&ast_cust_config_lock);
00911    return 0;
00912 }

void ast_config_destroy_all ( void   ) 

Definition at line 860 of file config.c.

00861 {
00862    struct ast_config_reg *key;
00863    ast_mutex_lock(&ast_cust_config_lock);
00864    for (key=ast_cust_config_list;key;key=key->next) {
00865       ast_config_deregister(key);
00866    }
00867    ast_cust_config_list = NULL;
00868    ast_mutex_unlock(&ast_cust_config_lock);
00869 }

int ast_config_register ( struct ast_config_reg new  ) 

Definition at line 876 of file config.c.

00877 {
00878    struct ast_config_reg *ptr;
00879    ast_mutex_lock(&ast_cust_config_lock);
00880    new->keycount = 0;
00881    if (!ast_cust_config_list) {
00882       ast_cust_config_list = new;
00883    } else {
00884       for(ptr=ast_cust_config_list;ptr->next;ptr=ptr->next);
00885          ptr->next = new;
00886    }
00887    ast_mutex_unlock(&ast_cust_config_lock);
00888    ast_log(LOG_NOTICE,"Registered Config Engine %s\n",new->name);
00889    return 1;
00890 }

int ast_cust_config_active ( void   ) 

Definition at line 914 of file config.c.

00914                                  {
00915    return (ast_cust_config >0) ? 1 : 0;
00916 }

int ast_cust_config_deregister ( struct ast_config_reg new  ) 

Definition at line 1024 of file config.c.

01025 {
01026    ast_config_deregister(new);
01027    read_ast_cust_config();
01028    return 1;
01029 }

int ast_cust_config_register ( struct ast_config_reg new  ) 

Definition at line 1018 of file config.c.

01019 {
01020    ast_config_register(new);
01021    read_ast_cust_config();
01022    return 1;
01023 }

void ast_destroy ( struct ast_config config  ) 

Removes a config.

Parameters:
config config data structure associated with the config. Free memory associated with a given config Returns nothing

Definition at line 67 of file config.c.

00068 {
00069    struct ast_category *cat, *catn;
00070    struct ast_variable *v, *vn;
00071 
00072    if (!ast)
00073       return;
00074 
00075    cat = ast->root;
00076    while(cat) {
00077       v = cat->root;
00078       while(v) {
00079          vn = v;
00080          free(v->name);
00081          free(v->value);
00082 #ifdef PRESERVE_COMMENTS
00083          free_comments(v->precomments);
00084          free_comments(v->sameline);
00085 #endif         
00086          v = v->next;
00087          free(vn);
00088       }
00089       catn = cat;
00090 #ifdef PRESERVE_COMMENTS
00091       free_comments(cat->precomments);
00092       free_comments(cat->sameline);
00093 #endif      
00094       cat = cat->next;
00095       free(catn);
00096    }
00097 #ifdef PRESERVE_COMMENTS
00098    free_comments(ast->trailingcomments);
00099 #endif   
00100    free(ast);
00101 }

int ast_false ( char *  val  ) 

Make sure something is false.

Determine falseness of a boolean value. This function checks to see whether a string passed to it is an indication of a negatirve value. It checks to see if the string is "no", "false", "n", "f", and "0". Returns 0 if the value of s is a NULL pointer, 0 on "truth", and -1 on falsehood.

Definition at line 118 of file config.c.

00119 {
00120    if (!s)
00121       return 0;
00122    /* Determine if this is a false value */
00123    if (!strcasecmp(s, "no") ||
00124        !strcasecmp(s, "false") ||
00125       !strcasecmp(s, "n") ||
00126       !strcasecmp(s, "f") ||
00127       !strcasecmp(s, "0") ||
00128       !strcasecmp(s, "off"))
00129          return -1;
00130    return 0;
00131 }

struct ast_config* ast_load ( char *  configfile  )  [read]

Load a config file.

Parameters:
configfile path of file to open. If no preceding '/' character, path is considered relative to AST_CONFIG_DIR Create a config structure from a given configuration file. Returns NULL on error, or an ast_config data structure on success

Definition at line 918 of file config.c.

00919 {
00920    struct ast_category *tmpc=NULL;
00921    struct ast_variable *last = NULL;
00922 
00923 
00924 #ifdef PRESERVE_COMMENTS
00925    struct ast_comment_struct acs = { NULL, NULL };
00926 #endif   
00927 
00928 
00929    return __ast_load(configfile, NULL, &tmpc, &last, 0 
00930 #ifdef PRESERVE_COMMENTS
00931    ,&acs
00932 #endif
00933    );
00934 }

AST_MUTEX_DEFINE_STATIC ( ast_cust_config_lock   ) 

struct ast_category* ast_new_category ( char *  name  )  [read]

Definition at line 979 of file config.c.

00980 {
00981    struct ast_category *category;
00982    category = malloc(sizeof(struct ast_category));
00983    if (category) {
00984       memset(category,0,sizeof(struct ast_category));
00985       strncpy(category->name,name,sizeof(category->name) - 1);
00986    }
00987    return category;
00988 }

struct ast_config* ast_new_config ( void   )  [read]

Definition at line 969 of file config.c.

00970 {
00971    struct ast_config *config;
00972    config = malloc(sizeof(struct ast_config));
00973    memset(config,0,sizeof(struct ast_config));
00974    return config;
00975 }

struct ast_variable* ast_new_variable ( char *  name,
char *  value 
) [read]

Definition at line 991 of file config.c.

00992 {
00993    struct ast_variable *variable;
00994    variable = malloc(sizeof(struct ast_variable));
00995    if (variable) {
00996       memset(variable,0,sizeof(struct ast_variable));
00997       variable->object=0;
00998       variable->name = malloc(strlen(name)+1);
00999       if (variable->name) {
01000          strcpy(variable->name,name);
01001          variable->value = malloc(strlen(value)+1);
01002          if (variable->value) {
01003             strcpy(variable->value,value);
01004          } else {
01005             free(variable->name);
01006             variable->name = NULL;
01007          }
01008       }
01009    }
01010    if (!variable->value) {
01011       free(variable);
01012       variable = NULL;
01013    }
01014       
01015    return variable;
01016 }

int ast_save ( char *  configfile,
struct ast_config cfg,
char *  generator 
)

Definition at line 653 of file config.c.

00654 {
00655    FILE *f;
00656    char fn[256];
00657    char date[256]="";
00658    time_t t;
00659    struct ast_variable *var;
00660    struct ast_category *cat;
00661    int blanklines = 0;
00662    if (configfile[0] == '/') {
00663       strncpy(fn, configfile, sizeof(fn)-1);
00664    } else {
00665       snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
00666    }
00667    time(&t);
00668    strncpy(date, ctime(&t), sizeof(date) - 1);
00669    if ((f = fopen(fn, "w"))) {
00670       if ((option_verbose > 1) && !option_debug)
00671          ast_verbose(  VERBOSE_PREFIX_2 "Saving '%s': ", fn);
00672       fprintf(f, ";!\n");
00673       fprintf(f, ";! Automatically generated configuration file\n");
00674       fprintf(f, ";! Filename: %s (%s)\n", configfile, fn);
00675       fprintf(f, ";! Generator: %s\n", generator);
00676       fprintf(f, ";! Creation Date: %s", date);
00677       fprintf(f, ";!\n");
00678       cat = cfg->root;
00679       while(cat) {
00680 #ifdef PRESERVE_COMMENTS
00681          /* Dump any precomments */
00682          dump_comments(f, cat->precomments);
00683 #endif
00684          /* Dump section with any appropriate comment */
00685 #ifdef PRESERVE_COMMENTS
00686          if (cat->sameline) 
00687             fprintf(f, "[%s]  ; %s\n", cat->name, cat->sameline->cmt);
00688          else
00689 #endif
00690             fprintf(f, "[%s]\n", cat->name);
00691          var = cat->root;
00692          while(var) {
00693 #ifdef PRESERVE_COMMENTS
00694             dump_comments(f, var->precomments);
00695 #endif            
00696             if (var->sameline) 
00697                fprintf(f, "%s %s %s  ; %s\n", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt);
00698             else  
00699                fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value);
00700             if (var->blanklines) {
00701                blanklines = var->blanklines;
00702                while (blanklines) {
00703                   fprintf(f, "\n");
00704                   blanklines--;
00705                }
00706             }
00707                
00708             var = var->next;
00709          }
00710 #if 0
00711          /* Put an empty line */
00712          fprintf(f, "\n");
00713 #endif
00714          cat = cat->next;
00715       }
00716 #ifdef PRESERVE_COMMENTS
00717       dump_comments(f, cfg->trailingcomments);
00718 #endif      
00719    } else {
00720       if (option_debug)
00721          printf("Unable to open for writing: %s\n", fn);
00722       else if (option_verbose > 1)
00723          printf( "Unable to write (%s)", strerror(errno));
00724       return -1;
00725    }
00726    fclose(f);
00727    return 0;
00728 }

int ast_true ( char *  val  ) 

Make sure something is true.

Determine affermativeness of a boolean value. This function checks to see whether a string passed to it is an indication of an affirmitave value. It checks to see if the string is "yes", "true", "y", "t", and "1". Returns 0 if the value of s is a NULL pointer, 0 on "truth", and -1 on falsehood.

Definition at line 103 of file config.c.

00104 {
00105    if (!s)
00106       return 0;
00107    /* Determine if this is a true value */
00108    if (!strcasecmp(s, "yes") ||
00109        !strcasecmp(s, "true") ||
00110       !strcasecmp(s, "y") ||
00111       !strcasecmp(s, "t") ||
00112       !strcasecmp(s, "1") ||
00113       !strcasecmp(s, "on"))
00114          return -1;
00115    return 0;
00116 }

struct ast_variable* ast_variable_browse ( struct ast_config config,
char *  category 
) [read]

Goes through variables.

Somewhat similar in intent as the ast_category_browse. The category MUST be an actual pointer to an actual category (such as one obtained by using ast_category_browse()). List variables of config file Returns ast_variable list on success, or NULL on failure

Definition at line 133 of file config.c.

00134 {
00135    struct ast_category *cat;
00136    cat = config->root;
00137    while(cat) {
00138       if (cat->name == category)
00139          return cat->root;
00140       cat = cat->next;
00141    }
00142    cat = config->root;
00143    while(cat) {
00144       if (!strcasecmp(cat->name, category))
00145          return cat->root;
00146       cat = cat->next;
00147    }
00148    return NULL;
00149 }

char* ast_variable_retrieve ( struct ast_config config,
char *  category,
char *  value 
)

Gets a variable.

Parameters:
config which (opened) config to use
category category under which the variable lies (must be a pointer to the category, such as one given by ast_category_browse)
value which variable you wish to get the data for Goes through a given config file in the given category and searches for the given variable Returns the variable value on success, or NULL if unable to find it. Retrieve a specific variable

Definition at line 151 of file config.c.

00152 {
00153    struct ast_variable *v;
00154    if (category) {
00155       v = ast_variable_browse(config, category);
00156       while (v) {
00157          if (value == v->name)
00158             return v->value;
00159          v=v->next;
00160       }
00161       v = ast_variable_browse(config, category);
00162       while (v) {
00163          if (!strcasecmp(value, v->name))
00164             return v->value;
00165          v=v->next;
00166       }
00167    } else {
00168       struct ast_category *cat;
00169       cat = config->root;
00170       while(cat) {
00171          v = cat->root;
00172          while (v) {
00173             if (!strcasecmp(value, v->name))
00174                return v->value;
00175             v=v->next;
00176          }
00177          cat = cat->next;
00178       }
00179    }
00180    return NULL;
00181 }

struct ast_config_reg* get_ast_cust_config ( char *  name  )  [read]

Definition at line 848 of file config.c.

00849 {
00850    struct ast_config_reg *ptr=NULL;
00851    ast_mutex_lock(&ast_cust_config_lock);
00852    for (ptr=ast_cust_config_list;ptr;ptr=ptr->next) {
00853       if (!strcmp(name,ptr->name))
00854          break;
00855    }
00856    ast_mutex_unlock(&ast_cust_config_lock);
00857    return ptr;
00858 }

struct ast_config_reg* get_ast_cust_config_keyword ( char *  name  )  [read]

Definition at line 833 of file config.c.

00834 {
00835    struct ast_config_reg *reg,*ret=NULL;
00836    int x=0;
00837    ast_mutex_lock(&ast_cust_config_lock);
00838    for (reg=ast_cust_config_list;reg && !ret;reg=reg->next) {
00839       for (x=0;x<reg->keycount && !ret ;x++) {
00840          if (!strcmp(reg->keywords[x],name))
00841             ret=reg;
00842       }
00843    }
00844    ast_mutex_unlock(&ast_cust_config_lock);
00845    return ret;
00846 }

struct ast_config_reg* get_config_registrations ( void   )  [read]

Definition at line 871 of file config.c.

00872 {
00873    return ast_cust_config_list;
00874 }

int read_ast_cust_config ( void   ) 

Definition at line 1072 of file config.c.

01073 {
01074    char *cfg = config_conf_file;
01075    struct ast_config *config;
01076    struct ast_variable *v;
01077    struct ast_config_reg *ptr;
01078    struct ast_config_reg *test = NULL;
01079 
01080    clear_cust_keywords();
01081    config = ast_load(cfg);
01082    if (config) {
01083       for (v = ast_variable_browse(config,"settings");v;v=v->next) {
01084          
01085          ptr = get_ast_cust_config(v->value);
01086          if (ptr) {
01087             if (ptr->keycount >= CONFIG_KEYWORD_ARRAYLEN) {
01088                ast_log(LOG_WARNING,"Max Number of Bindings exceeded for %s->%s %d/%d\n",v->name,v->value,ptr->keycount,CONFIG_KEYWORD_ARRAYLEN);
01089             } else {
01090                if (strcmp(v->name,config_conf_file) && strcmp(v->name,"asterisk.conf")) {
01091                   if (!(test = get_ast_cust_config_keyword(v->name))) {
01092                      ast_log(LOG_NOTICE,"Binding: %s to %s\n",v->name,v->value);
01093                      strncpy(ptr->keywords[ptr->keycount],v->name,sizeof(ptr->keywords[ptr->keycount]) - 1);
01094                      ptr->keywords[ptr->keycount][sizeof(ptr->keywords[ptr->keycount])-1] = '\0';
01095                      ptr->keycount++;
01096                   }
01097                } else {
01098                   ast_log(LOG_WARNING,"Cannot bind %s, Permission Denied\n",v->name);
01099                }
01100             }
01101          }
01102       }
01103       
01104       ast_destroy(config);
01105    }
01106 
01107    return 0;
01108 }

int register_config_cli ( void   ) 

Definition at line 1067 of file config.c.

01068 {
01069    return ast_cli_register(&config_command_struct);
01070 }


Variable Documentation

struct ast_config*(* global_load_func)(char *, struct ast_config *, struct ast_category **, struct ast_variable **, int)


Generated on Wed Oct 28 17:00:52 2009 for Asterisk by  doxygen 1.5.6