check_expr.c File Reference

#include "asterisk.h"
#include "asterisk/ast_expr.h"
#include "asterisk/inline_api.h"
#include "asterisk/lock.h"

Include dependency graph for check_expr.c:

Go to the source code of this file.

Data Structures
struct	varz

Macros
#define	AST_API_MODULE   1
#define	AST_API_MODULE   1
#define	ASTMM_LIBC   ASTMM_IGNORE

Functions
int	__ast_bt_get_addresses (struct ast_bt *bt)
struct ast_vector_string *	__ast_bt_get_symbols (void **addresses, size_t num_frames)
int	ast_add_profile (const char *x, uint64_t scale)
	support for event profiling More...
struct ast_custom_function *	ast_custom_function_find (const char *name)
void	ast_log (int level, const char *file, int line, const char *function, const char *fmt,...)
	Used for sending a log message This is the standard logger function. Probably the only way you will invoke it would be something like this: ast_log(AST_LOG_WHATEVER, "Problem with the %s Captain. We should get some more. Will %d be enough?\n", "flux capacitor", 10); where WHATEVER is one of ERROR, DEBUG, EVENT, NOTICE, or WARNING depending on which log you wish to output to. These are implemented as macros, that will provide the function with the needed arguments. More...
void	ast_mark_lock_acquired (void *)
	Mark the last lock as acquired. More...
void	ast_remove_lock_info (void *lock_addr, struct ast_bt *bt)
	remove lock info for the current thread More...
void	ast_restore_lock_info (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, struct ast_bt *bt)
	Store lock info for the current thread. More...
void	ast_suspend_lock_info (void *lock_addr)
int	check_eval (char *buffer, char *error_report)
unsigned int	check_expr (char *buffer, char *error_report)
char *	find_var (const char *varname)
int	main (int argc, char **argv)
void	parse_file (const char *fname)
void	set_var (const char *varname, const char *varval)

Variables
static int	global_expr_count =0
static int	global_expr_max_size =0
static int	global_expr_tot_size =0
static int	global_lineno = 1
static int	global_OK_count =0
struct varz *	global_varlist
static int	global_warn_count =0

Macro Definition Documentation

AST_API_MODULE [1/2]

#define AST_API_MODULE   1

Definition at line 31 of file check_expr.c.

AST_API_MODULE [2/2]

#define AST_API_MODULE   1

Definition at line 31 of file check_expr.c.

ASTMM_LIBC

#define ASTMM_LIBC   ASTMM_IGNORE

Definition at line 23 of file check_expr.c.

Function Documentation

__ast_bt_get_addresses()

int __ast_bt_get_addresses

(

struct ast_bt *

bt

)

Definition at line 75 of file check_expr.c.

References __ast_bt_get_symbols().

Referenced by ast_remove_lock_info().

{
   /* Suck it, you stupid utils directory! */
   return 0;
}

__ast_bt_get_symbols()

struct ast_vector_string* __ast_bt_get_symbols	(	void **	addresses,
		size_t	num_frames
	)

Definition at line 81 of file check_expr.c.

References NULL.

Referenced by __ast_bt_get_addresses().

{
   return NULL;
}

ast_add_profile()

int ast_add_profile	(	const char *	x,
		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 'core show profile <name>'

The counter accumulates positive or negative values supplied by

See also

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 139 of file check_expr.c.

{ return 0;}

ast_custom_function_find()

struct ast_custom_function* ast_custom_function_find

(

const char *

name

)

Definition at line 237 of file check_expr.c.

Referenced by check_expr().

{
   return 0;
}

ast_log()

void ast_log	(	int	level,
		const char *	file,
		int	line,
		const char *	function,
		const char *	fmt,
			...
	)

Used for sending a log message This is the standard logger function. Probably the only way you will invoke it would be something like this: ast_log(AST_LOG_WHATEVER, "Problem with the %s Captain. We should get some more. Will %d be enough?\n", "flux capacitor", 10); where WHATEVER is one of ERROR, DEBUG, EVENT, NOTICE, or WARNING depending on which log you wish to output to. These are implemented as macros, that will provide the function with the needed arguments.

Parameters

level	Type of log event
file	Will be provided by the AST_LOG_* macro
line	Will be provided by the AST_LOG_* macro
function	Will be provided by the AST_LOG_* macro
fmt	This is what is important. The format is the same as your favorite breed of printf. You know how that works, right? :-)

Definition at line 121 of file check_expr.c.

References check_eval(), check_expr(), find_var(), parse_file(), set_var(), varz::varname, and varz::varval.

{
   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);
}

ast_mark_lock_acquired()

void ast_mark_lock_acquired

(

void *

foo

)

Mark the last lock as acquired.

Definition at line 94 of file check_expr.c.

Referenced by ast_restore_lock_info().

{
    /* not a lot to do in a standalone w/o threading! */
}

ast_remove_lock_info()

void ast_remove_lock_info	(	void *	lock_addr,
		struct ast_bt *	bt
	)

remove lock info for the current thread

this gets called by ast_mutex_unlock so that information on the lock can be removed from the current thread's lock info struct.

Definition at line 68 of file check_expr.c.

References __ast_bt_get_addresses().

Referenced by ast_store_lock_info().

{
    /* not a lot to do in a standalone w/o threading! */
}

ast_restore_lock_info()

void ast_restore_lock_info

(

void *

lock_addr

)

Definition at line 90 of file check_expr.c.

References ast_mark_lock_acquired().

{
}

ast_store_lock_info()

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
	)

Store lock info for the current thread.

This function gets called in ast_mutex_lock() and ast_mutex_trylock() so that information about this lock can be stored in this thread's lock info struct. The lock is marked as pending as the thread is waiting on the lock. ast_mark_lock_acquired() will mark it as held by this thread.

Definition at line 61 of file check_expr.c.

References ast_remove_lock_info().

{
    /* not a lot to do in a standalone w/o threading! */
}

ast_suspend_lock_info()

void ast_suspend_lock_info

(

void *

lock_addr

)

Definition at line 87 of file check_expr.c.

{
}

check_eval()

int check_eval	(	char *	buffer,
		char *	error_report
	)

Definition at line 242 of file check_expr.c.

References ast_expr(), find_var(), global_lineno, NULL, parse_file(), result, and varz::varname.

Referenced by ast_log(), check_expr(), and parse_file().

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

check_expr()

unsigned int check_expr	(	char *	buffer,
		char *	error_report
	)

Definition at line 165 of file check_expr.c.

References ast_custom_function_find(), check_eval(), global_lineno, global_warn_count, and name.

Referenced by ast_log(), and parse_file().

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

find_var()

char * find_var

(

const char *

varname

)

Definition at line 141 of file check_expr.c.

References varz::next, set_var(), varz::varname, and varz::varval.

Referenced by ast_log(), and check_eval().

{
   struct varz *t;
   for (t= global_varlist; t; t = t->next) {
      if (!strcmp(t->varname, varname)) {
         return t->varval;
      }
   }
   return 0;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 406 of file check_expr.c.

References parse_file(), and set_var().

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

parse_file()

void parse_file

(

const char *

fname

)

Definition at line 315 of file check_expr.c.

References check_eval(), check_expr(), global_expr_count, global_expr_max_size, global_expr_tot_size, global_lineno, global_OK_count, global_warn_count, and retval.

Referenced by ast_log(), check_eval(), and main().

{
   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);
}

set_var()

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

Definition at line 154 of file check_expr.c.

References calloc, global_varlist, varz::next, varz::varname, and varz::varval.

Referenced by ast_log(), find_var(), and main().

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

Variable Documentation

global_expr_count

int global_expr_count =0

static

Definition at line 102 of file check_expr.c.

Referenced by parse_file().

global_expr_max_size

int global_expr_max_size =0

static

Definition at line 103 of file check_expr.c.

Referenced by parse_file().

global_expr_tot_size

int global_expr_tot_size =0

static

Definition at line 104 of file check_expr.c.

Referenced by parse_file().

global_lineno

int global_lineno = 1

static

Definition at line 101 of file check_expr.c.

Referenced by check_eval(), check_expr(), and parse_file().

global_OK_count

int global_OK_count =0

static

Definition at line 106 of file check_expr.c.

Referenced by parse_file().

global_varlist

struct varz* global_varlist

Definition at line 115 of file check_expr.c.

Referenced by set_var().

global_warn_count

int global_warn_count =0

static

Definition at line 105 of file check_expr.c.

Referenced by check_expr(), and parse_file().