Skip to content
Snippets Groups Projects
extconf.c 181 KiB
Newer Older
  • Learn to ignore specific revisions
  • 		array[argc] = scan;
    		for (; *scan; scan++) {
    			if (*scan == '(')
    				paren++;
    			else if (*scan == ')') {
    				if (paren)
    					paren--;
    			} else if (*scan == '"' && delim != '"') {
    				quote = quote ? 0 : 1;
    				/* Remove quote character from argument */
    				memmove(scan, scan + 1, strlen(scan));
    				scan--;
    			} else if (*scan == '\\') {
    				/* Literal character, don't parse */
    				memmove(scan, scan + 1, strlen(scan));
    			} else if ((*scan == delim) && !paren && !quote) {
    				*scan++ = '\0';
    				break;
    			}
    		}
    	}
    
    	if (*scan)
    		array[argc++] = scan;
    
    	return argc;
    }
    
    static void pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
    {
    	struct ast_var_t *newvariable;
    	struct varshead *headp;
    	const char *nametail = name;
    
    	/* XXX may need locking on the channel ? */
    	if (name[strlen(name)-1] == ')') {
    		char *function = ast_strdupa(name);
    
    		ast_func_write(chan, function, value);
    		return;
    	}
    
    	headp = &globals;
    
    	/* For comparison purposes, we have to strip leading underscores */
    	if (*nametail == '_') {
    		nametail++;
    		if (*nametail == '_')
    			nametail++;
    	}
    
    	AST_LIST_TRAVERSE (headp, newvariable, entries) {
    		if (strcasecmp(ast_var_name(newvariable), nametail) == 0) {
    			/* there is already such a variable, delete it */
    			AST_LIST_REMOVE(headp, newvariable, entries);
    			ast_var_delete(newvariable);
    			break;
    		}
    	}
    
    	if (value) {
    		if ((option_verbose > 1) && (headp == &globals))
    			ast_verbose(VERBOSE_PREFIX_2 "Setting global variable '%s' to '%s'\n", name, value);
    		newvariable = ast_var_assign(name, value);
    		AST_LIST_INSERT_HEAD(headp, newvariable, entries);
    	}
    
    }
    
    static int pbx_builtin_setvar(struct ast_channel *chan, void *data)
    {
    	char *name, *value, *mydata;
    	int argc;
    	char *argv[24];		/* this will only support a maximum of 24 variables being set in a single operation */
    	int global = 0;
    	int x;
    
    	if (ast_strlen_zero(data)) {
    		ast_log(LOG_WARNING, "Set requires at least one variable name/value pair.\n");
    		return 0;
    	}
    
    	mydata = ast_strdupa(data);
    	argc = ast_app_separate_args(mydata, '|', argv, sizeof(argv) / sizeof(argv[0]));
    
    	/* check for a trailing flags argument */
    	if ((argc > 1) && !strchr(argv[argc-1], '=')) {
    		argc--;
    		if (strchr(argv[argc], 'g'))
    			global = 1;
    	}
    
    	for (x = 0; x < argc; x++) {
    		name = argv[x];
    		if ((value = strchr(name, '='))) {
    			*value++ = '\0';
    			pbx_builtin_setvar_helper((global) ? NULL : chan, name, value);
    		} else
    			ast_log(LOG_WARNING, "Ignoring entry '%s' with no = (and not last 'options' entry)\n", name);
    	}
    
    	return(0);
    }
    
    int localized_pbx_builtin_setvar(struct ast_channel *chan, void *data);
    
    int localized_pbx_builtin_setvar(struct ast_channel *chan, void *data)
    {
    	return pbx_builtin_setvar(chan, data);
    }
    
    
    /*! \brief Helper for get_range.
     * return the index of the matching entry, starting from 1.
     * If names is not supplied, try numeric values.
     */
    
    static int lookup_name(const char *s, char *const names[], int max)
    {
    	int i;
    
    	if (names) {
    		for (i = 0; names[i]; i++) {
    			if (!strcasecmp(s, names[i]))
    				return i+1;
    		}
    	} else if (sscanf(s, "%d", &i) == 1 && i >= 1 && i <= max) {
    		return i;
    	}
    	return 0; /* error return */
    }
    
    /*! \brief helper function to return a range up to max (7, 12, 31 respectively).
     * names, if supplied, is an array of names that should be mapped to numbers.
     */
    static unsigned get_range(char *src, int max, char *const names[], const char *msg)
    {
    	int s, e; /* start and ending position */
    	unsigned int mask = 0;
    
    	/* Check for whole range */
    	if (ast_strlen_zero(src) || !strcmp(src, "*")) {
    		s = 0;
    		e = max - 1;
    	} else {
    		/* Get start and ending position */
    		char *c = strchr(src, '-');
    		if (c)
    			*c++ = '\0';
    		/* Find the start */
    		s = lookup_name(src, names, max);
    		if (!s) {
    			ast_log(LOG_WARNING, "Invalid %s '%s', assuming none\n", msg, src);
    			return 0;
    		}
    		s--;
    		if (c) { /* find end of range */
    			e = lookup_name(c, names, max);
    			if (!e) {
    				ast_log(LOG_WARNING, "Invalid end %s '%s', assuming none\n", msg, c);
    				return 0;
    			}
    			e--;
    		} else
    			e = s;
    	}
    	/* Fill the mask. Remember that ranges are cyclic */
    	mask = 1 << e;	/* initialize with last element */
    	while (s != e) {
    		if (s >= max) {
    			s = 0;
    			mask |= (1 << s);
    		} else {
    			mask |= (1 << s);
    			s++;
    		}
    	}
    	return mask;
    }
    
    /*! \brief store a bitmask of valid times, one bit each 2 minute */
    static void get_timerange(struct ast_timing *i, char *times)
    {
    	char *e;
    	int x;
    	int s1, s2;
    	int e1, e2;
    	/*	int cth, ctm; */
    
    	/* start disabling all times, fill the fields with 0's, as they may contain garbage */
    	memset(i->minmask, 0, sizeof(i->minmask));
    
    	/* 2-minutes per bit, since the mask has only 32 bits :( */
    	/* Star is all times */
    	if (ast_strlen_zero(times) || !strcmp(times, "*")) {
    		for (x=0; x<24; x++)
    			i->minmask[x] = 0x3fffffff; /* 30 bits */
    		return;
    	}
    	/* Otherwise expect a range */
    	e = strchr(times, '-');
    	if (!e) {
    		ast_log(LOG_WARNING, "Time range is not valid. Assuming no restrictions based on time.\n");
    		return;
    	}
    	*e++ = '\0';
    	/* XXX why skip non digits ? */
    	while (*e && !isdigit(*e))
    		e++;
    	if (!*e) {
    		ast_log(LOG_WARNING, "Invalid time range.  Assuming no restrictions based on time.\n");
    		return;
    	}
    	if (sscanf(times, "%d:%d", &s1, &s2) != 2) {
    		ast_log(LOG_WARNING, "%s isn't a time.  Assuming no restrictions based on time.\n", times);
    		return;
    	}
    	if (sscanf(e, "%d:%d", &e1, &e2) != 2) {
    		ast_log(LOG_WARNING, "%s isn't a time.  Assuming no restrictions based on time.\n", e);
    		return;
    	}
    	/* XXX this needs to be optimized */
    #if 1
    	s1 = s1 * 30 + s2/2;
    	if ((s1 < 0) || (s1 >= 24*30)) {
    		ast_log(LOG_WARNING, "%s isn't a valid start time. Assuming no time.\n", times);
    		return;
    	}
    	e1 = e1 * 30 + e2/2;
    	if ((e1 < 0) || (e1 >= 24*30)) {
    		ast_log(LOG_WARNING, "%s isn't a valid end time. Assuming no time.\n", e);
    		return;
    	}
    	/* Go through the time and enable each appropriate bit */
    	for (x=s1;x != e1;x = (x + 1) % (24 * 30)) {
    		i->minmask[x/30] |= (1 << (x % 30));
    	}
    	/* Do the last one */
    	i->minmask[x/30] |= (1 << (x % 30));
    #else
    	for (cth=0; cth<24; cth++) {
    		/* Initialize masks to blank */
    		i->minmask[cth] = 0;
    		for (ctm=0; ctm<30; ctm++) {
    			if (
    			/* First hour with more than one hour */
    			      (((cth == s1) && (ctm >= s2)) &&
    			       ((cth < e1)))
    			/* Only one hour */
    			||    (((cth == s1) && (ctm >= s2)) &&
    			       ((cth == e1) && (ctm <= e2)))
    			/* In between first and last hours (more than 2 hours) */
    			||    ((cth > s1) &&
    			       (cth < e1))
    			/* Last hour with more than one hour */
    			||    ((cth > s1) &&
    			       ((cth == e1) && (ctm <= e2)))
    			)
    				i->minmask[cth] |= (1 << (ctm / 2));
    		}
    	}
    #endif
    	/* All done */
    	return;
    }
    
    static void null_datad(void *foo)
    {
    }
    
    /*! \brief Find realtime engine for realtime family */
    static struct ast_config_engine *find_engine(const char *family, char *database, int dbsiz, char *table, int tabsiz) 
    {
    	struct ast_config_engine *eng, *ret = NULL;
    	struct ast_config_map *map;
    
    
    	for (map = config_maps; map; map = map->next) {
    		if (!strcasecmp(family, map->name)) {
    			if (database)
    				ast_copy_string(database, map->database, dbsiz);
    			if (table)
    				ast_copy_string(table, map->table ? map->table : family, tabsiz);
    			break;
    		}
    	}
    
    	/* Check if the required driver (engine) exist */
    	if (map) {
    		for (eng = config_engine_list; !ret && eng; eng = eng->next) {
    			if (!strcasecmp(eng->name, map->driver))
    				ret = eng;
    		}
    	}
    
    	
    	/* if we found a mapping, but the engine is not available, then issue a warning */
    	if (map && !ret)
    		ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver);
    
    	return ret;
    }
    
    struct ast_category *ast_config_get_current_category(const struct ast_config *cfg);
    
    struct ast_category *ast_config_get_current_category(const struct ast_config *cfg)
    {
    	return cfg->current;
    }
    
    
    static struct ast_category *ast_category_new(const char *name, const char *in_file, int lineno);
    
    static struct ast_category *ast_category_new(const char *name, const char *in_file, int lineno)
    
    {
    	struct ast_category *category;
    
    	if ((category = ast_calloc(1, sizeof(*category))))
    		ast_copy_string(category->name, name, sizeof(category->name));
    
    	category->file = strdup(in_file);
    	category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
     	return category;
    
    }
    
    struct ast_category *localized_category_get(const struct ast_config *config, const char *category_name);
    
    struct ast_category *localized_category_get(const struct ast_config *config, const char *category_name)
    {
    	return category_get(config, category_name, 0);
    }
    
    static void move_variables(struct ast_category *old, struct ast_category *new)
    {
    	struct ast_variable *var = old->root;
    	old->root = NULL;
    #if 1
    	/* we can just move the entire list in a single op */
    	ast_variable_append(new, var);
    #else
    	while (var) {
    		struct ast_variable *next = var->next;
    		var->next = NULL;
    		ast_variable_append(new, var);
    		var = next;
    	}
    #endif
    }
    
    static void inherit_category(struct ast_category *new, const struct ast_category *base)
    {
    	struct ast_variable *var;
    
    	for (var = base->root; var; var = var->next)
    		ast_variable_append(new, variable_clone(var));
    }
    
    static void ast_category_append(struct ast_config *config, struct ast_category *category);
    
    static void ast_category_append(struct ast_config *config, struct ast_category *category)
    {
    	if (config->last)
    		config->last->next = category;
    	else
    		config->root = category;
    	config->last = category;
    	config->current = category;
    }
    
    static void ast_category_destroy(struct ast_category *cat);
    
    static void ast_category_destroy(struct ast_category *cat)
    {
    	ast_variables_destroy(cat->root);
    
    	free(cat);
    }
    
    static struct ast_config_engine text_file_engine = {
    	.name = "text",
    	.load_func = config_text_file_load,
    };
    
    
    
    static struct ast_config *ast_config_internal_load(const char *filename, struct ast_config *cfg, int withcomments, const char *suggested_incl_file);
    
    static struct ast_config *ast_config_internal_load(const char *filename, struct ast_config *cfg, int withcomments, const char *suggested_incl_file)
    
    {
    	char db[256];
    	char table[256];
    	struct ast_config_engine *loader = &text_file_engine;
    	struct ast_config *result; 
    
    	if (cfg->include_level == cfg->max_include_level) {
    		ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level);
    		return NULL;
    	}
    
    	cfg->include_level++;
    	/*  silence is golden!
    		ast_log(LOG_WARNING, "internal loading file %s level=%d\n", filename, cfg->include_level);
    	*/
    
    	if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) {
    		struct ast_config_engine *eng;
    
    		eng = find_engine(filename, db, sizeof(db), table, sizeof(table));
    
    
    		if (eng && eng->load_func) {
    			loader = eng;
    		} else {
    			eng = find_engine("global", db, sizeof(db), table, sizeof(table));
    			if (eng && eng->load_func)
    				loader = eng;
    		}
    	}
    
    
    	result = loader->load_func(db, table, filename, cfg, withcomments, suggested_incl_file);
    
    	/* silence is golden 
    	   ast_log(LOG_WARNING, "finished internal loading file %s level=%d\n", filename, cfg->include_level);
    	*/
    
    	if (result)
    		result->include_level--;
    
    	return result;
    }
    
    
    
    static int process_text_line(struct ast_config *cfg, struct ast_category **cat, char *buf, int lineno, const char *configfile, int withcomments, const char *suggested_include_file)
    
    {
    	char *c;
    	char *cur = buf;
    	struct ast_variable *v;
    	char cmd[512], exec_file[512];
    	int object, do_exec, do_include;
    
    	/* Actually parse the entry */
    	if (cur[0] == '[') {
    		struct ast_category *newcat = NULL;
    		char *catname;
    
    		/* A category header */
    		c = strchr(cur, ']');
    		if (!c) {
    			ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile);
    			return -1;
    		}
    		*c++ = '\0';
    		cur++;
     		if (*c++ != '(')
     			c = NULL;
    		catname = cur;
    
    		if (!(*cat = newcat = ast_category_new(catname, ast_strlen_zero(suggested_include_file)?configfile:suggested_include_file, lineno))) {
    
    		/* add comments */
    		if (withcomments && comment_buffer && comment_buffer[0] ) {
    			newcat->precomments = ALLOC_COMMENT(comment_buffer);
    		}
    		if (withcomments && lline_buffer && lline_buffer[0] ) {
    			newcat->sameline = ALLOC_COMMENT(lline_buffer);
    		}
    		if( withcomments )
    			CB_RESET();
    		
     		/* If there are options or categories to inherit from, process them now */
     		if (c) {
     			if (!(cur = strchr(c, ')'))) {
     				ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile);
     				return -1;
     			}
     			*cur = '\0';
     			while ((cur = strsep(&c, ","))) {
    				if (!strcasecmp(cur, "!")) {
    					(*cat)->ignored = 1;
    				} else if (!strcasecmp(cur, "+")) {
    					*cat = category_get(cfg, catname, 1);
    					if (!*cat) {
    						ast_config_destroy(cfg);
    						if (newcat)
    							ast_category_destroy(newcat);
    						ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile);
    						return -1;
    					}
    					if (newcat) {
    						move_variables(newcat, *cat);
    						ast_category_destroy(newcat);
    						newcat = NULL;
    					}
    				} else {
    					struct ast_category *base;
     				
    					base = category_get(cfg, cur, 1);
    					if (!base) {
    						ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile);
    						return -1;
    					}
    					inherit_category(*cat, base);
    				}
     			}
     		}
    		if (newcat)
    			ast_category_append(cfg, *cat);
    	} else if (cur[0] == '#') {
    		/* A directive */
    		cur++;
    		c = cur;
    		while(*c && (*c > 32)) c++;
    		if (*c) {
    			*c = '\0';
    			/* Find real argument */
    			c = ast_skip_blanks(c + 1);
    			if (!*c)
    				c = NULL;
    		} else 
    			c = NULL;
    		do_include = !strcasecmp(cur, "include");
    		if(!do_include)
    			do_exec = !strcasecmp(cur, "exec");
    		else
    			do_exec = 0;
    		if (do_exec && !ast_opt_exec_includes) {
    			ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n");
    			do_exec = 0;
    		}
    		if (do_include || do_exec) {
    			if (c) {
    
    				char *cur2;
    				char real_inclusion_name[256];
    				struct ast_config_include *inclu;
                    
    
    				/* Strip off leading and trailing "'s and <>'s */
    				while((*c == '<') || (*c == '>') || (*c == '\"')) c++;
    				/* Get rid of leading mess */
    				cur = c;
    
    				while (!ast_strlen_zero(cur)) {
    					c = cur + strlen(cur) - 1;
    					if ((*c == '>') || (*c == '<') || (*c == '\"'))
    						*c = '\0';
    					else
    						break;
    				}
    				/* #exec </path/to/executable>
    				   We create a tmp file, then we #include it, then we delete it. */
    				if (do_exec) { 
    					snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d.%ld", (int)time(NULL), (long)pthread_self());
    					snprintf(cmd, sizeof(cmd), "%s > %s 2>&1", cur, exec_file);
    					ast_safe_system(cmd);
    					cur = exec_file;
    				} else
    					exec_file[0] = '\0';
    				/* A #include */
    				/* ast_log(LOG_WARNING, "Reading in included file %s withcomments=%d\n", cur, withcomments); */
    				
    
    				/* record this inclusion */
    				inclu = ast_include_new(cfg, configfile, cur, do_exec, cur2, lineno, real_inclusion_name, sizeof(real_inclusion_name));
    				
    				do_include = ast_config_internal_load(cur, cfg, withcomments, real_inclusion_name) ? 1 : 0;
    
    				if(!ast_strlen_zero(exec_file))
    					unlink(exec_file);
    				if(!do_include)
    					return 0;
    				/* ast_log(LOG_WARNING, "Done reading in included file %s withcomments=%d\n", cur, withcomments); */
    				
    			} else {
    				ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n", 
    						do_exec ? "exec" : "include",
    						do_exec ? "/path/to/executable" : "filename",
    						lineno,
    						configfile);
    			}
    		}
    		else 
    			ast_log(LOG_WARNING, "Unknown directive '%s' at line %d of %s\n", cur, lineno, configfile);
    	} else {
    		/* Just a line (variable = value) */
    		if (!*cat) {
    			ast_log(LOG_WARNING,
    				"parse error: No category context for line %d of %s\n", lineno, configfile);
    			return -1;
    		}
    		c = strchr(cur, '=');
    		if (c) {
    			*c = 0;
    			c++;
    			/* Ignore > in => */
    			if (*c== '>') {
    				object = 1;
    				c++;
    			} else
    				object = 0;
    
    			if ((v = ast_variable_new(ast_strip(cur), ast_strip(c), configfile))) {
    
    				v->lineno = lineno;
    				v->object = object;
    				/* Put and reset comments */
    				v->blanklines = 0;
    				ast_variable_append(*cat, v);
    				/* add comments */
    				if (withcomments && comment_buffer && comment_buffer[0] ) {
    					v->precomments = ALLOC_COMMENT(comment_buffer);
    				}
    				if (withcomments && lline_buffer && lline_buffer[0] ) {
    					v->sameline = ALLOC_COMMENT(lline_buffer);
    				}
    				if( withcomments )
    					CB_RESET();
    				
    			} else {
    				return -1;
    			}
    		} else {
    			ast_log(LOG_WARNING, "EXTENSIONS.CONF: No '=' (equal sign) in line %d of %s\n", lineno, configfile);
    		}
    	}
    	return 0;
    }
    
    static int use_local_dir = 1;
    
    void localized_use_local_dir(void);
    void localized_use_conf_dir(void);
    
    void localized_use_local_dir(void)
    {
    	use_local_dir = 1;
    }
    
    void localized_use_conf_dir(void)
    {
    	use_local_dir = 0;
    }
    
    
    
    static struct ast_config *config_text_file_load(const char *database, const char *table, const char *filename, struct ast_config *cfg, int withcomments, const char *suggested_include_file)
    
    {
    	char fn[256];
    	char buf[8192];
    	char *new_buf, *comment_p, *process_buf;
    	FILE *f;
    	int lineno=0;
    	int comment = 0, nest[MAX_NESTED_COMMENTS];
    	struct ast_category *cat = NULL;
    	int count = 0;
    	struct stat statbuf;
    	
    	cat = ast_config_get_current_category(cfg);
    
    	if (filename[0] == '/') {
    		ast_copy_string(fn, filename, sizeof(fn));
    	} else {
    		if (use_local_dir)
    			snprintf(fn, sizeof(fn), "./%s", filename);
    		else
    
    			snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, filename);
    
    	}
    
    	if (withcomments && cfg && cfg->include_level < 2 ) {
    		CB_INIT();
    	}
    	
    #ifdef AST_INCLUDE_GLOB
    	{
    		int glob_ret;
    		glob_t globbuf;
    
    		globbuf.gl_offs = 0;	/* initialize it to silence gcc */
    #ifdef SOLARIS
    		glob_ret = glob(fn, GLOB_NOCHECK, NULL, &globbuf);
    #else
    		glob_ret = glob(fn, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf);
    #endif
    		if (glob_ret == GLOB_NOSPACE)
    			ast_log(LOG_WARNING,
    				"Glob Expansion of pattern '%s' failed: Not enough memory\n", fn);
    		else if (glob_ret  == GLOB_ABORTED)
    			ast_log(LOG_WARNING,
    				"Glob Expansion of pattern '%s' failed: Read error\n", fn);
    		else  {
    			/* loop over expanded files */
    			int i;
    			for (i=0; i<globbuf.gl_pathc; i++) {
    				ast_copy_string(fn, globbuf.gl_pathv[i], sizeof(fn));
    #endif
    	do {
    		if (stat(fn, &statbuf))
    			continue;
    
    		if (!S_ISREG(statbuf.st_mode)) {
    			ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn);
    			continue;
    		}
    		if (option_verbose > 1) {
    			ast_verbose(VERBOSE_PREFIX_2 "Parsing '%s': ", fn);
    			fflush(stdout);
    		}
    		if (!(f = fopen(fn, "r"))) {
    			if (option_debug)
    				ast_log(LOG_DEBUG, "No file to parse: %s\n", fn);
    			if (option_verbose > 1)
    				ast_verbose( "Not found (%s)\n", strerror(errno));
    			continue;
    		}
    		count++;
    		if (option_debug)
    			ast_log(LOG_DEBUG, "Parsing %s\n", fn);
    		if (option_verbose > 1)
    			ast_verbose("Found\n");
    		while(!feof(f)) {
    			lineno++;
    			if (fgets(buf, sizeof(buf), f)) {
    				if ( withcomments ) {    
    					CB_ADD(lline_buffer);       /* add the current lline buffer to the comment buffer */
    					lline_buffer[0] = 0;        /* erase the lline buffer */
    				}
    				
    				new_buf = buf;
    				if (comment) 
    					process_buf = NULL;
    				else
    					process_buf = buf;
    				
    				while ((comment_p = strchr(new_buf, COMMENT_META))) {
    					if ((comment_p > new_buf) && (*(comment_p-1) == '\\')) {
    						/* Yuck, gotta memmove */
    						memmove(comment_p - 1, comment_p, strlen(comment_p) + 1);
    						new_buf = comment_p;
    					} else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) {
    						/* Meta-Comment start detected ";--" */
    						if (comment < MAX_NESTED_COMMENTS) {
    							*comment_p = '\0';
    							new_buf = comment_p + 3;
    							comment++;
    							nest[comment-1] = lineno;
    						} else {
    							ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS);
    						}
    					} else if ((comment_p >= new_buf + 2) &&
    						   (*(comment_p - 1) == COMMENT_TAG) &&
    						   (*(comment_p - 2) == COMMENT_TAG)) {
    						/* Meta-Comment end detected */
    						comment--;
    						new_buf = comment_p + 1;
    						if (!comment) {
    							/* Back to non-comment now */
    							if (process_buf) {
    								/* Actually have to move what's left over the top, then continue */
    								char *oldptr;
    								oldptr = process_buf + strlen(process_buf);
    								if ( withcomments ) {
    									CB_ADD(";");
    									CB_ADD_LEN(oldptr+1,new_buf-oldptr-1);
    								}
    								
    								memmove(oldptr, new_buf, strlen(new_buf) + 1);
    								new_buf = oldptr;
    							} else
    								process_buf = new_buf;
    						}
    					} else {
    						if (!comment) {
    							/* If ; is found, and we are not nested in a comment, 
    							   we immediately stop all comment processing */
    							if ( withcomments ) {
    								LLB_ADD(comment_p);
    							}
    							*comment_p = '\0'; 
    							new_buf = comment_p;
    						} else
    							new_buf = comment_p + 1;
    					}
    				}
    				if( withcomments && comment && !process_buf )
    				{
    					CB_ADD(buf);  /* the whole line is a comment, store it */
    				}
    				
    				if (process_buf) {
    					char *buf = ast_strip(process_buf);
    					if (!ast_strlen_zero(buf)) {
    
    						if (process_text_line(cfg, &cat, buf, lineno, filename, withcomments, suggested_include_file)) {
    
    							cfg = NULL;
    							break;
    						}
    					}
    				}
    			}
    		}
    		fclose(f);		
    	} while(0);
    	if (comment) {
    		ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment]);
    	}
    #ifdef AST_INCLUDE_GLOB
    					if (!cfg)
    						break;
    				}
    				globfree(&globbuf);
    			}
    		}
    #endif
    	if (cfg && cfg->include_level == 1 && withcomments && comment_buffer) {
    		if (comment_buffer) { 
    			free(comment_buffer);
    			free(lline_buffer);
    			comment_buffer=0; 
    			lline_buffer=0; 
    			comment_buffer_size=0; 
    			lline_buffer_size=0;
    		}
    	}
    	if (count == 0)
    		return NULL;
    
    	return cfg;
    }
    
    
    static struct ast_config *ast_config_new(void) ;
    
    static struct ast_config *ast_config_new(void) 
    {
    	struct ast_config *config;
    
    	if ((config = ast_calloc(1, sizeof(*config))))
    		config->max_include_level = MAX_INCLUDE_LEVEL;
    	return config;
    }
    
    struct ast_config *localized_config_load(const char *filename);
    
    struct ast_config *localized_config_load(const char *filename)
    {
    	struct ast_config *cfg;
    	struct ast_config *result;
    
    	cfg = ast_config_new();
    	if (!cfg)
    		return NULL;
    
    
    	result = ast_config_internal_load(filename, cfg, 0, "");
    
    	if (!result)
    		ast_config_destroy(cfg);
    
    	return result;
    }
    
    struct ast_config *localized_config_load_with_comments(const char *filename);
    
    struct ast_config *localized_config_load_with_comments(const char *filename)
    {
    	struct ast_config *cfg;
    	struct ast_config *result;
    
    	cfg = ast_config_new();
    	if (!cfg)
    		return NULL;
    
    
    	result = ast_config_internal_load(filename, cfg, 1, "");
    
    	if (!result)
    		ast_config_destroy(cfg);
    
    	return result;
    }
    
    static struct ast_category *next_available_category(struct ast_category *cat)
    {
    	for (; cat && cat->ignored; cat = cat->next);
    
    	return cat;
    }
    
    static char *ast_category_browse(struct ast_config *config, const char *prev)
    {	
    	struct ast_category *cat = NULL;
    
    	if (prev && config->last_browse && (config->last_browse->name == prev))
    		cat = config->last_browse->next;
    	else if (!prev && config->root)
    		cat = config->root;
    	else if (prev) {
    		for (cat = config->root; cat; cat = cat->next) {
    			if (cat->name == prev) {
    				cat = cat->next;
    				break;
    			}
    		}
    		if (!cat) {
    			for (cat = config->root; cat; cat = cat->next) {
    				if (!strcasecmp(cat->name, prev)) {
    					cat = cat->next;
    					break;
    				}
    			}
    		}
    	}
    	
    	if (cat)
    		cat = next_available_category(cat);
    
    	config->last_browse = cat;
    	return (cat) ? cat->name : NULL;
    }
    
    
    
    void ast_config_set_current_category(struct ast_config *cfg, const struct ast_category *cat);
    
    void ast_config_set_current_category(struct ast_config *cfg, const struct ast_category *cat)
    {
    	/* cast below is just to silence compiler warning about dropping "const" */
    	cfg->current = (struct ast_category *) cat;
    }
    
    
    /* NOTE: categories and variables each have a file and lineno attribute. On a save operation, these are used to determine
       which file and line number to write out to. Thus, an entire hierarchy of config files (via #include statements) can be
       recreated. BUT, care must be taken to make sure that every cat and var has the proper file name stored, or you may
       be shocked and mystified as to why things are not showing up in the files! 
       
       Also, All #include/#exec statements are recorded in the "includes" LL in the ast_config structure. The file name
       and line number are stored for each include, plus the name of the file included, so that these statements may be
       included in the output files on a file_save operation. 
       
       The lineno's are really just for relative placement in the file. There is no attempt to make sure that blank lines
       are included to keep the lineno's the same between input and output. The lineno fields are used mainly to determine
       the position of the #include and #exec directives. So, blank lines tend to disappear from a read/rewrite operation,
       and a header gets added.
       
       vars and category heads are output in the order they are stored in the config file. So, if the software
       shuffles these at all, then the placement of #include directives might get a little mixed up, because the
       file/lineno data probably won't get changed.
       
    */
    
    static void gen_header(FILE *f1, const char *configfile, const char *fn, const char *generator)
    {
    	char date[256]="";
    	time_t t;
    	time(&t);
    	ast_copy_string(date, ctime(&t), sizeof(date));
    	
    	fprintf(f1, ";!\n");
    	fprintf(f1, ";! Automatically generated configuration file\n");
    	if (strcmp(configfile, fn))
    		fprintf(f1, ";! Filename: %s (%s)\n", configfile, fn);
    	else
    		fprintf(f1, ";! Filename: %s\n", configfile);
    	fprintf(f1, ";! Generator: %s\n", generator);
    	fprintf(f1, ";! Creation Date: %s", date);
    	fprintf(f1, ";!\n");
    }
    
    static void set_fn(char *fn, int fn_size, const char *file, const char *configfile)
    {
    	if (!file || file[0] == 0) {
    		if (configfile[0] == '/')
    			ast_copy_string(fn, configfile, fn_size);
    		else
    			snprintf(fn, fn_size, "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
    	} else if (file[0] == '/') 
    		ast_copy_string(fn, file, fn_size);
    	else
    		snprintf(fn, fn_size, "%s/%s", ast_config_AST_CONFIG_DIR, file);
    }
    
    
    int localized_config_text_file_save(const char *configfile, const struct ast_config *cfg, const char *generator);
    
    int localized_config_text_file_save(const char *configfile, const struct ast_config *cfg, const char *generator)
    {
    	FILE *f;
    	char fn[256];
    	struct ast_variable *var;
    	struct ast_category *cat;
    	struct ast_comment *cmt;
    
    	
    	/* reset all the output flags, in case this isn't our first time saving this data */
    	
    	for (incl=cfg->includes; incl; incl = incl->next)
    		incl->output = 0;
    	
    	/* go thru all the inclusions and make sure all the files involved (configfile plus all its inclusions)
    	   are all truncated to zero bytes and have that nice header*/
    	
    	for (incl=cfg->includes; incl; incl = incl->next)
    	{
    		if (!incl->exec) { /* leave the execs alone -- we'll write out the #exec directives, but won't zero out the include files or exec files*/
    			FILE *f1;
    			
    			set_fn(fn, sizeof(fn), incl->included_file, configfile); /* normally, fn is just set to incl->included_file, prepended with config dir if relative */
    			f1 = fopen(fn,"w");
    			if (f1) {
    				gen_header(f1, configfile, fn, generator);
    				fclose(f1); /* this should zero out the file */
    			} else {