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"

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.
ast_variable *	ast_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)
ast_config_reg *	get_ast_cust_config_keyword (char *name)
ast_config_reg *	get_ast_cust_config (char *name)
void	ast_config_destroy_all (void)
ast_config_reg *	get_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)
ast_config *	ast_load (char *configfile)
	Load a config file.
char *	ast_category_browse (struct ast_config *config, char *prev)
	Goes through categories.
ast_config *	ast_new_config (void)
ast_category *	ast_new_category (char *name)
ast_variable *	ast_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
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. References ast_category::name, ast_category::next, and ast_config::root. { struct ast_category *cat; if (!prev) { if (config->root) return config->root->name; else return NULL; } cat = config->root; while(cat) { if (cat->name == prev) { if (cat->next) return cat->next->name; else return NULL; } cat = cat->next; } cat = config->root; while(cat) { if (!strcasecmp(cat->name, prev)) { if (cat->next) return cat->next->name; else return NULL; } cat = cat->next; } return NULL; }

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. References ast_category::name, ast_category::next, and ast_category::root. { struct ast_category *category = NULL; category = config->root; while(category) { if (!strcasecmp(category->name,category_name)) return 1; category = category->next; } return 0; }

int ast_config_deregister (  struct ast_config_reg *  del  )

Definition at line 892 of file config.c. References ast_mutex_lock, ast_mutex_unlock, and ast_config_reg::next. Referenced by ast_config_destroy_all(), and ast_cust_config_deregister(). { struct ast_config_reg *ptr=NULL,*last=NULL; ast_mutex_lock(&ast_cust_config_lock); for (ptr=ast_cust_config_list;ptr;ptr=ptr->next) { if (ptr == del) { if (last && ptr->next) { last->next = ptr->next; } else if (last && ! ptr->next) { last->next = NULL; } else if (!last && ptr->next) { ast_cust_config_list = ptr->next; } else if (!last && !ptr->next) { ast_cust_config_list = NULL; } } last = ptr; } ast_mutex_unlock(&ast_cust_config_lock); return 0; }

void ast_config_destroy_all (  void   )

Definition at line 860 of file config.c. References ast_config_deregister(), ast_mutex_lock, ast_mutex_unlock, key(), and ast_config_reg::next. { struct ast_config_reg *key; ast_mutex_lock(&ast_cust_config_lock); for (key=ast_cust_config_list;key;key=key->next) { ast_config_deregister(key); } ast_cust_config_list = NULL; ast_mutex_unlock(&ast_cust_config_lock); }

int ast_config_register (  struct ast_config_reg *  new  )

Definition at line 876 of file config.c. References ast_log(), ast_mutex_lock, ast_mutex_unlock, LOG_NOTICE, ast_config_reg::name, and ast_config_reg::next. Referenced by ast_cust_config_register(). { struct ast_config_reg *ptr; ast_mutex_lock(&ast_cust_config_lock); new->keycount = 0; if (!ast_cust_config_list) { ast_cust_config_list = new; } else { for(ptr=ast_cust_config_list;ptr->next;ptr=ptr->next); ptr->next = new; } ast_mutex_unlock(&ast_cust_config_lock); ast_log(LOG_NOTICE,"Registered Config Engine %s\n",new->name); return 1; }

int ast_cust_config_active (  void   )

Definition at line 914 of file config.c. { return (ast_cust_config >0) ? 1 : 0; }

int ast_cust_config_deregister (  struct ast_config_reg *  new  )

Definition at line 1024 of file config.c. References ast_config_deregister(), and read_ast_cust_config(). { ast_config_deregister(new); read_ast_cust_config(); return 1; }

int ast_cust_config_register (  struct ast_config_reg *  new  )

Definition at line 1018 of file config.c. References ast_config_register(), and read_ast_cust_config(). { ast_config_register(new); read_ast_cust_config(); return 1; }

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. References free, ast_variable::name, ast_variable::next, ast_category::next, ast_variable::precomments, ast_config::root, ast_category::root, ast_variable::sameline, and ast_variable::value. Referenced by ast_enum_init(), ast_load_resource(), ast_rtp_reload(), init_manager(), load_modules(), and read_ast_cust_config(). { struct ast_category *cat, *catn; struct ast_variable *v, *vn; if (!ast) return; cat = ast->root; while(cat) { v = cat->root; while(v) { vn = v; free(v->name); free(v->value); #ifdef PRESERVE_COMMENTS free_comments(v->precomments); free_comments(v->sameline); #endif v = v->next; free(vn); } catn = cat; #ifdef PRESERVE_COMMENTS free_comments(cat->precomments); free_comments(cat->sameline); #endif cat = cat->next; free(catn); } #ifdef PRESERVE_COMMENTS free_comments(ast->trailingcomments); #endif free(ast); }

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. { if (!s) return 0; /* Determine if this is a false value */ if (!strcasecmp(s, "no") || !strcasecmp(s, "false") || !strcasecmp(s, "n") || !strcasecmp(s, "f") || !strcasecmp(s, "0") || !strcasecmp(s, "off")) return -1; return 0; }

struct ast_config* ast_load (  char *  configfile  )

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. Referenced by ast_enum_init(), ast_load_resource(), ast_rtp_reload(), init_manager(), load_modules(), and read_ast_cust_config(). { struct ast_category *tmpc=NULL; struct ast_variable *last = NULL; #ifdef PRESERVE_COMMENTS struct ast_comment_struct acs = { NULL, NULL }; #endif return __ast_load(configfile, NULL, &tmpc, &last, 0 #ifdef PRESERVE_COMMENTS ,&acs #endif ); }

AST_MUTEX_DEFINE_STATIC (  ast_cust_config_lock   )

struct ast_category* ast_new_category (  char *  name  )

Definition at line 979 of file config.c. References malloc. { struct ast_category *category; category = malloc(sizeof(struct ast_category)); if (category) { memset(category,0,sizeof(struct ast_category)); strncpy(category->name,name,sizeof(category->name) - 1); } return category; }

struct ast_config* ast_new_config (  void   )

Definition at line 969 of file config.c. References malloc. { struct ast_config *config; config = malloc(sizeof(struct ast_config)); memset(config,0,sizeof(struct ast_config)); return config; }

struct ast_variable* ast_new_variable (  char *  name, char *  value )

Definition at line 991 of file config.c. References free, malloc, and ast_variable::value. { struct ast_variable *variable; variable = malloc(sizeof(struct ast_variable)); if (variable) { memset(variable,0,sizeof(struct ast_variable)); variable->object=0; variable->name = malloc(strlen(name)+1); if (variable->name) { strcpy(variable->name,name); variable->value = malloc(strlen(value)+1); if (variable->value) { strcpy(variable->value,value); } else { free(variable->name); variable->name = NULL; } } } if (!variable->value) { free(variable); variable = NULL; } return variable; }

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

Definition at line 653 of file config.c. References AST_CONFIG_DIR, ast_verbose(), ast_variable::blanklines, ast_comment::cmt, ast_category::name, ast_variable::name, ast_variable::next, ast_category::next, ast_variable::object, option_debug, option_verbose, ast_variable::precomments, ast_config::root, ast_category::root, ast_variable::sameline, ast_variable::value, and VERBOSE_PREFIX_2. { FILE *f; char fn[256]; char date[256]=""; time_t t; struct ast_variable *var; struct ast_category *cat; int blanklines = 0; if (configfile[0] == '/') { strncpy(fn, configfile, sizeof(fn)-1); } else { snprintf(fn, sizeof(fn), "%s/%s", AST_CONFIG_DIR, configfile); } time(&t); strncpy(date, ctime(&t), sizeof(date) - 1); if ((f = fopen(fn, "w"))) { if ((option_verbose > 1) && !option_debug) ast_verbose( VERBOSE_PREFIX_2 "Saving '%s': ", fn); fprintf(f, ";!\n"); fprintf(f, ";! Automatically generated configuration file\n"); fprintf(f, ";! Filename: %s (%s)\n", configfile, fn); fprintf(f, ";! Generator: %s\n", generator); fprintf(f, ";! Creation Date: %s", date); fprintf(f, ";!\n"); cat = cfg->root; while(cat) { #ifdef PRESERVE_COMMENTS /* Dump any precomments */ dump_comments(f, cat->precomments); #endif /* Dump section with any appropriate comment */ #ifdef PRESERVE_COMMENTS if (cat->sameline) fprintf(f, "[%s] ; %s\n", cat->name, cat->sameline->cmt); else #endif fprintf(f, "[%s]\n", cat->name); var = cat->root; while(var) { #ifdef PRESERVE_COMMENTS dump_comments(f, var->precomments); #endif if (var->sameline) fprintf(f, "%s %s %s ; %s\n", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt); else fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value); if (var->blanklines) { blanklines = var->blanklines; while (blanklines) { fprintf(f, "\n"); blanklines--; } } var = var->next; } #if 0 /* Put an empty line */ fprintf(f, "\n"); #endif cat = cat->next; } #ifdef PRESERVE_COMMENTS dump_comments(f, cfg->trailingcomments); #endif } else { if (option_debug) printf("Unable to open for writing: %s\n", fn); else if (option_verbose > 1) printf( "Unable to write (%s)", strerror(errno)); return -1; } fclose(f); return 0; }

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. Referenced by ast_load_resource(), ast_rtp_reload(), init_manager(), and load_modules(). { if (!s) return 0; /* Determine if this is a true value */ if (!strcasecmp(s, "yes") || !strcasecmp(s, "true") || !strcasecmp(s, "y") || !strcasecmp(s, "t") || !strcasecmp(s, "1") || !strcasecmp(s, "on")) return -1; return 0; }

struct ast_variable* ast_variable_browse (  struct ast_config *  config, char *  category )

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. References ast_category::name, ast_category::next, ast_config::root, and ast_category::root. Referenced by ast_enum_init(), ast_variable_retrieve(), load_modules(), and read_ast_cust_config(). { struct ast_category *cat; cat = config->root; while(cat) { if (cat->name == category) return cat->root; cat = cat->next; } cat = config->root; while(cat) { if (!strcasecmp(cat->name, category)) return cat->root; cat = cat->next; } return NULL; }

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. References ast_variable_browse(), ast_variable::name, ast_variable::next, ast_category::next, ast_category::root, and ast_variable::value. Referenced by ast_load_resource(), ast_rtp_reload(), init_manager(), and load_modules(). { struct ast_variable *v; if (category) { v = ast_variable_browse(config, category); while (v) { if (value == v->name) return v->value; v=v->next; } v = ast_variable_browse(config, category); while (v) { if (!strcasecmp(value, v->name)) return v->value; v=v->next; } } else { struct ast_category *cat; cat = config->root; while(cat) { v = cat->root; while (v) { if (!strcasecmp(value, v->name)) return v->value; v=v->next; } cat = cat->next; } } return NULL; }

struct ast_config_reg* get_ast_cust_config (  char *  name  )

Definition at line 848 of file config.c. References ast_mutex_lock, ast_mutex_unlock, ast_config_reg::name, and ast_config_reg::next. Referenced by read_ast_cust_config(). { struct ast_config_reg *ptr=NULL; ast_mutex_lock(&ast_cust_config_lock); for (ptr=ast_cust_config_list;ptr;ptr=ptr->next) { if (!strcmp(name,ptr->name)) break; } ast_mutex_unlock(&ast_cust_config_lock); return ptr; }

struct ast_config_reg* get_ast_cust_config_keyword (  char *  name  )

Definition at line 833 of file config.c. References ast_mutex_lock, ast_mutex_unlock, ast_config_reg::keycount, ast_config_reg::keywords, and ast_config_reg::next. Referenced by read_ast_cust_config(). { struct ast_config_reg *reg,*ret=NULL; int x=0; ast_mutex_lock(&ast_cust_config_lock); for (reg=ast_cust_config_list;reg && !ret;reg=reg->next) { for (x=0;x<reg->keycount && !ret ;x++) { if (!strcmp(reg->keywords[x],name)) ret=reg; } } ast_mutex_unlock(&ast_cust_config_lock); return ret; }

struct ast_config_reg* get_config_registrations (  void   )

Definition at line 871 of file config.c. { return ast_cust_config_list; }

int read_ast_cust_config (  void   )

Definition at line 1072 of file config.c. References ast_destroy(), ast_load(), ast_log(), ast_variable_browse(), CONFIG_KEYWORD_ARRAYLEN, get_ast_cust_config(), get_ast_cust_config_keyword(), ast_config_reg::keycount, ast_config_reg::keywords, LOG_NOTICE, LOG_WARNING, ast_variable::name, ast_variable::next, and ast_variable::value. Referenced by ast_cust_config_deregister(), ast_cust_config_register(), ast_module_reload(), and main(). { char *cfg = config_conf_file; struct ast_config *config; struct ast_variable *v; struct ast_config_reg *ptr; struct ast_config_reg *test = NULL; clear_cust_keywords(); config = ast_load(cfg); if (config) { for (v = ast_variable_browse(config,"settings");v;v=v->next) { ptr = get_ast_cust_config(v->value); if (ptr) { if (ptr->keycount >= CONFIG_KEYWORD_ARRAYLEN) { ast_log(LOG_WARNING,"Max Number of Bindings exceeded for %s->%s %d/%d\n",v->name,v->value,ptr->keycount,CONFIG_KEYWORD_ARRAYLEN); } else { if (strcmp(v->name,config_conf_file) && strcmp(v->name,"asterisk.conf")) { if (!(test = get_ast_cust_config_keyword(v->name))) { ast_log(LOG_NOTICE,"Binding: %s to %s\n",v->name,v->value); strncpy(ptr->keywords[ptr->keycount],v->name,sizeof(ptr->keywords[ptr->keycount]) - 1); ptr->keywords[ptr->keycount][sizeof(ptr->keywords[ptr->keycount])-1] = '\0'; ptr->keycount++; } } else { ast_log(LOG_WARNING,"Cannot bind %s, Permission Denied\n",v->name); } } } } ast_destroy(config); } return 0; }

int register_config_cli (  void   )

Definition at line 1067 of file config.c. References ast_cli_register(). Referenced by main(). { return ast_cli_register(&config_command_struct); }

---

Variable Documentation

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

Definition at line 32 of file config.c.

---