asterisk/utils/check_expr.c

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2005, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

#include "asterisk.h"
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")

#include "asterisk/ast_expr.h"

#define AST_API_MODULE 1
#include "asterisk/inline_api.h"

#define AST_API_MODULE 1
#include "asterisk/lock.h"

#include "asterisk/strings.h"

/* I included this from utils.c, so as not to have everything in that .c
   file included */
/*!
 * core handler for dynamic strings.
 * This is not meant to be called directly, but rather through the
 * various wrapper macros
 *	ast_str_set(...)
 *	ast_str_append(...)
 *	ast_str_set_va(...)
 *	ast_str_append_va(...)
 */
int __attribute__((format(printf, 4, 0))) __ast_str_helper(struct ast_str **buf, size_t max_len,
	int append, const char *fmt, va_list ap)
{
	int res, need;
	int offset = (append && (*buf)->len) ? (*buf)->used : 0;

	if (max_len < 0)
		max_len = (*buf)->len;	/* don't exceed the allocated space */
	/*
	 * Ask vsnprintf how much space we need. Remember that vsnprintf
	 * does not count the final '\0' so we must add 1.
	 */
	res = vsnprintf((*buf)->str + offset, (*buf)->len - offset, fmt, ap);

	need = res + offset + 1;
	/*
	 * If there is not enough space and we are below the max length,
	 * reallocate the buffer and return a message telling to retry.
	 */
	if (need > (*buf)->len && (max_len == 0 || (*buf)->len < max_len) ) {
		if (max_len && max_len < need)	/* truncate as needed */
			need = max_len;
		else if (max_len == 0)	/* if unbounded, give more room for next time */
			need += 16 + need/4;
		if (ast_str_make_space(buf, need)) {
			return AST_DYNSTR_BUILD_FAILED;
		}
		(*buf)->str[offset] = '\0';	/* Truncate the partial write. */

		/* va_end() and va_start() must be done before calling
		 * vsnprintf() again. */
		return AST_DYNSTR_BUILD_RETRY;
	}
	/* update space used, keep in mind the truncation */
	(*buf)->used = (res + offset > (*buf)->len) ? (*buf)->len : res + offset;

	return res;
}
#ifndef DEBUG_THREADS
enum ast_lock_type {
	        AST_MUTEX,
	        AST_RDLOCK,
	        AST_WRLOCK,
};
#endif
#if !defined(LOW_MEMORY)
#ifdef HAVE_BKTR
void ast_store_lock_info(enum ast_lock_type type, const char *filename,
		        int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt);
void ast_store_lock_info(enum ast_lock_type type, const char *filename,
		        int line_num, const char *func, const char *lock_name, void *lock_addr, struct ast_bt *bt)
{
    /* not a lot to do in a standalone w/o threading! */
}

void ast_remove_lock_info(void *lock_addr, struct ast_bt *bt);
void ast_remove_lock_info(void *lock_addr, struct ast_bt *bt)
{
    /* not a lot to do in a standalone w/o threading! */
}

int ast_bt_get_addresses(struct ast_bt *bt);
int ast_bt_get_addresses(struct ast_bt *bt)
{
	/* Suck it, you stupid utils directory! */
	return 0;
}
#else
void ast_store_lock_info(enum ast_lock_type type, const char *filename,
		        int line_num, const char *func, const char *lock_name, void *lock_addr);
void ast_store_lock_info(enum ast_lock_type type, const char *filename,
		        int line_num, const char *func, const char *lock_name, void *lock_addr)
{
    /* not a lot to do in a standalone w/o threading! */
}

void ast_remove_lock_info(void *lock_addr);
void ast_remove_lock_info(void *lock_addr)
{
    /* not a lot to do in a standalone w/o threading! */
}
#endif /* HAVE_BKTR */

void ast_mark_lock_acquired(void *);
void ast_mark_lock_acquired(void *foo)
{
    /* not a lot to do in a standalone w/o threading! */
}
#endif

static int global_lineno = 1;
static int global_expr_count=0;
static int global_expr_max_size=0;
static int global_expr_tot_size=0;
static int global_warn_count=0;
static int global_OK_count=0;

struct varz
{
	char varname[100]; /* a really ultra-simple, space-wasting linked list of var=val data */
	char varval[1000]; /* if any varname is bigger than 100 chars, or val greater than 1000, then **CRASH** */
	struct varz *next;
};

struct varz *global_varlist;

/* Our own version of ast_log, since the expr parser uses it. */

void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...) __attribute__((format(printf,5,6)));

void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
{
	va_list vars;
	va_start(vars,fmt);
	
	printf("LOG: lev:%d file:%s  line:%d func: %s  ",
		   level, file, line, function);
	vprintf(fmt, vars);
	fflush(stdout);
	va_end(vars);
}
//void ast_register_file_version(const char *file, const char *version);
//void ast_unregister_file_version(const char *file);

char *find_var(const char *varname);
void set_var(const char *varname, const char *varval);
unsigned int check_expr(char* buffer, char* error_report);
int check_eval(char *buffer, char *error_report);
void parse_file(const char *fname);

void ast_register_file_version(const char *file, const char *version);  
void ast_register_file_version(const char *file, const char *version) { }
#if !defined(LOW_MEMORY)
int ast_add_profile(const char *x, uint64_t scale) { return 0;} 
#endif
int ast_atomic_fetchadd_int_slow(volatile int *p, int v)
{
        int ret;
        ret = *p;
        *p += v;
        return ret;
}

void ast_unregister_file_version(const char *file);
void ast_unregister_file_version(const char *file)
{
}

char *find_var(const char *varname) /* the list should be pretty short, if there's any list at all */
{
	struct varz *t;
	for (t= global_varlist; t; t = t->next) {
		if (!strcmp(t->varname, varname)) {
			return t->varval;
		}
	}
	return 0;
}

void set_var(const char *varname, const char *varval);

void set_var(const char *varname, const char *varval)
{
	struct varz *t = (struct varz*)calloc(1,sizeof(struct varz));
	if (!t)
		return;
	strcpy(t->varname, varname);
	strcpy(t->varval, varval);
	t->next = global_varlist;
	global_varlist = t;
}

unsigned int check_expr(char* buffer, char* error_report)
{
	char* cp;
	unsigned int warn_found = 0;

	error_report[0] = 0;
	
	for (cp = buffer; *cp; ++cp)
	{
		switch (*cp)
		{
			case '"':
				/* skip to the other end */
				while (*(++cp) && *cp != '"') ;

				if (*cp == 0)
				{
					fprintf(stderr,
						"Trouble? Unterminated double quote found at line %d\n",
						global_lineno);
				}
				break;
				
			case '>':
			case '<':
			case '!':
				if (   (*(cp + 1) == '=')
					&& ( ( (cp > buffer) && (*(cp - 1) != ' ') ) || (*(cp + 2) != ' ') ) )
				{
					char msg[200];
					snprintf(msg,
						sizeof(msg),
						"WARNING: line %d: '%c%c' operator not separated by spaces. This may lead to confusion. You may wish to use double quotes to quote the grouping it is in. Please check!\n",
						global_lineno, *cp, *(cp + 1));
					strcat(error_report, msg);
					++global_warn_count;
					++warn_found;
				}
				break;
				
			case '|':
			case '&':
			case '=':
			case '+':
			case '-':
			case '*':
			case '/':
			case '%':
			case '?':
			case ':':
				if ( ( (cp > buffer) && (*(cp - 1) != ' ') ) || (*(cp + 1) != ' ') )
				{
					char msg[200];
					snprintf(msg,
						sizeof(msg),
						"WARNING: line %d: '%c' operator not separated by spaces. This may lead to confusion. You may wish to use double quotes to quote the grouping it is in. Please check!\n",
						global_lineno, *cp );
					strcat(error_report, msg);
					++global_warn_count;
					++warn_found;
				}
				break;
		}
	}

	return warn_found;
}

int check_eval(char *buffer, char *error_report);

struct ast_custom_function *ast_custom_function_find(const char *name);

struct ast_custom_function *ast_custom_function_find(const char *name)
{
	return 0;
}

int check_eval(char *buffer, char *error_report)
{
	char *cp, *ep;
	char s[4096];
	char evalbuf[80000];
	int result;

	error_report[0] = 0;
	ep = evalbuf;

	for (cp=buffer;*cp;cp++) {
		if (*cp == '$' && *(cp+1) == '{') {
			int brack_lev = 1;
			char *xp= cp+2;
			
			while (*xp) {
				if (*xp == '{')
					brack_lev++;
				else if (*xp == '}')
					brack_lev--;
				
				if (brack_lev == 0)
					break;
				xp++;
			}
			if (*xp == '}') {
				char varname[200];
				char *val;
				
				strncpy(varname,cp+2, xp-cp-2);
				varname[xp-cp-2] = 0;
				cp = xp;
				val = find_var(varname);
				if (val) {
					char *z = val;
					while (*z)
						*ep++ = *z++;
				}
				else {
					*ep++ = '5';  /* why not */
					*ep++ = '5';
					*ep++ = '5';
				}
			}
			else {
				printf("Unterminated variable reference at line %d\n", global_lineno);
				*ep++ = *cp;
			}
		}
		else if (*cp == '\\') {
			/* braindead simple elim of backslash */
			cp++;
			*ep++ = *cp;
		}
		else
			*ep++ = *cp;
	}
	*ep++ = 0;

	/* now, run the test */
	result = ast_expr(evalbuf, s, sizeof(s),NULL);
	if (result) {
		sprintf(error_report,"line %d, evaluation of $[ %s ] result: %s\n", global_lineno, evalbuf, s);
		return 1;
	} else {
		sprintf(error_report,"line %d, evaluation of $[ %s ] result: ****SYNTAX ERROR****\n", global_lineno, evalbuf);
		return 1;
	}
}


void parse_file(const char *fname);

void parse_file(const char *fname)
{
	FILE *f = fopen(fname,"r");
	FILE *l = fopen("expr2_log","w");
	int c1;
	char last_char= 0;
	char buffer[30000]; /* I sure hope no expr gets this big! */
	
	if (!f) {
		fprintf(stderr,"Couldn't open %s for reading... need an extensions.conf file to parse!\n",fname);
		exit(20);
	}
	if (!l) {
		fprintf(stderr,"Couldn't open 'expr2_log' file for writing... please fix and re-run!\n");
		exit(21);
	}
	
	global_lineno = 1;
	
	while ((c1 = fgetc(f)) != EOF) {
		if (c1 == '\n')
			global_lineno++;
		else if (c1 == '[') {
			if (last_char == '$') {
				/* bingo, an expr */
				int bracklev = 1;
				int bufcount = 0;
				int retval;
				char error_report[30000];
				
				while ((c1 = fgetc(f)) != EOF) {
					if (c1 == '[')
						bracklev++;
					else if (c1 == ']')
						bracklev--;
					if (c1 == '\n') {
						fprintf(l, "ERROR-- A newline in an expression? Weird! ...at line %d\n", global_lineno);
						fclose(f);
						fclose(l);
						printf("--- ERROR --- A newline in the middle of an expression at line %d!\n", global_lineno);
					}
					
					if (bracklev == 0)
						break;
					buffer[bufcount++] = c1;
				}
				if (c1 == EOF) {
					fprintf(l, "ERROR-- End of File Reached in the middle of an Expr at line %d\n", global_lineno);
					fclose(f);
					fclose(l);
					printf("--- ERROR --- EOF reached in middle of an expression at line %d!\n", global_lineno);
					exit(22);
				}
				
				buffer[bufcount] = 0;
				/* update stats */
				global_expr_tot_size += bufcount;
				global_expr_count++;
				if (bufcount > global_expr_max_size)
					global_expr_max_size = bufcount;
				
				retval = check_expr(buffer, error_report); /* check_expr should bump the warning counter */
				if (retval != 0) {
					/* print error report */
					printf("Warning(s) at line %d, expression: $[%s]; see expr2_log file for details\n", 
						   global_lineno, buffer);
					fprintf(l, "%s", error_report);
				}
				else {
					printf("OK -- $[%s] at line %d\n", buffer, global_lineno);
					global_OK_count++;
				}
				error_report[0] = 0;
				retval = check_eval(buffer, error_report);
				fprintf(l, "%s", error_report);
			}
		}
		last_char = c1;
	}
	printf("Summary:\n  Expressions detected: %d\n  Expressions OK:  %d\n  Total # Warnings:   %d\n  Longest Expr:   %d chars\n  Ave expr len:  %d chars\n",
		   global_expr_count,
		   global_OK_count,
		   global_warn_count,
		   global_expr_max_size,
		   (global_expr_count) ? global_expr_tot_size/global_expr_count : 0);
	
	fclose(f);
	fclose(l);
}


int main(int argc,char **argv)
{
	int argc1;
	char *eq;
	
	if (argc < 2) {
		printf("check_expr -- a program to look thru extensions.conf files for $[...] expressions,\n");
		printf("              and run them thru the parser, looking for problems\n");
		printf("Hey-- give me a path to an extensions.conf file!\n");
		printf(" You can also follow the file path with a series of variable decls,\n");
		printf("     of the form, varname=value, each separated from the next by spaces.\n");
		printf("     (this might allow you to avoid division by zero messages, check that math\n");
		printf("      is being done correctly, etc.)\n");
		printf(" Note that messages about operators not being surrounded by spaces is merely to alert\n");
		printf("  you to possible problems where you might be expecting those operators as part of a string.\n");
        printf("  (to include operators in a string, wrap with double quotes!)\n");
		
		exit(19);
	}
	global_varlist = 0;
	for (argc1=2;argc1 < argc; argc1++) {
		if ((eq = strchr(argv[argc1],'='))) {
			*eq = 0;
			set_var(argv[argc1],eq+1);
		}
	}

	/* parse command args for x=y and set varz */
	
	parse_file(argv[1]);
	return 0;
}