void
dump_ctxt (lex_ctxt * c)
{
int i;
named_nasl_var *v;
nasl_func *f;
printf ("--------<CTXT>--------\n");
if (c->fct_ctxt)
printf ("Is a function context\n");
if (c->up_ctxt == NULL)
printf ("Is the top level context\n");
if (c->ret_val)
{
printf ("Return value\n");
nasl_dump_tree (c->ret_val);
}
printf ("Variables:\n");
for (i = 0; i < VAR_NAME_HASH; i++)
for (v = c->ctx_vars.hash_elt[i]; v != NULL; v = v->next_var)
printf ("%s\t", v->var_name);
putchar ('\n');
printf ("Functions:\n");
for (i = 0; i < FUNC_NAME_HASH; i++)
for (f = c->functions[i]; f != NULL; f = f->next_func)
printf ("%s\t", f->func_name);
putchar ('\n');
printf ("----------------------\n");
}
static void
free_tree (tree_cell * c)
{
int i;
nasl_array *a;
if (c == NULL || c == FAKE_CELL)
return;
#if 0
nasl_dump_tree (c);
#endif
for (i = 0; i < 4; i++)
if (c->link[i] != NULL)
deref_cell (c->link[i]);
if (c->x.str_val != NULL)
switch (c->type)
{
case CONST_STR:
case CONST_DATA:
#ifdef SCRATCH_FREED_MEMORY
if (c->size > 0)
memset (c->x.str_val, 0xFF, c->size);
#endif
efree (&c->x.str_val);
break;
case CONST_REGEX:
case COMP_RE_MATCH:
case COMP_RE_NOMATCH:
if (c->x.ref_val != NULL)
{
regfree (c->x.ref_val);
efree (&c->x.ref_val);
}
break;
case DYN_ARRAY:
a = c->x.ref_val;
if (a != NULL)
{
free_array (a);
efree (&c->x.ref_val);
}
break;
case NODE_FUN_DEF:
case NODE_FUN_CALL:
case NODE_VAR:
case NODE_DECL:
case NODE_ARG:
case NODE_ARRAY_EL:
case NODE_FOREACH:
efree (&c->x.str_val);
break;
}
#ifdef SCRATCH_FREED_MEMORY
memset (c, 0xFF, sizeof (*c));
#endif
efree (&c);
}
static int
cvt_bool(lex_ctxt* lexic, tree_cell* c)
{
int flag;
#if 0
nasl_dump_tree(c);
#endif
flag = cell2bool(lexic, c);
/* free(c); free_tree(c); */
return flag;
}
void
ref_cell (tree_cell * c)
{
if (c == NULL || c == FAKE_CELL)
return;
c->ref_count++;
if (c->ref_count < 0)
{
nasl_perror (NULL, "ref_cell: ref count is negative!\n");
nasl_dump_tree (c);
abort ();
}
}
tree_cell*
nasl_exec(lex_ctxt* lexic, tree_cell* st)
{
tree_cell *ret = NULL, *ret2 = NULL, *tc1 = NULL, *tc2 = NULL, *tc3 = NULL, *idx = NULL, *args;
int flag, x, y, z;
char *s1 = NULL, *s2 = NULL, *s3 = NULL, *p = NULL;
char *p1, *p2;
int len1, len2;
nasl_func *pf = NULL;
int i, n;
unsigned long sz;
#if 0
nasl_dump_tree(st); /* See rt.value, rt.type, rt.length */
#endif
/* return */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* break or continue */
if (lexic->break_flag || lexic->cont_flag)
return FAKE_CELL;
if (st == FAKE_CELL)
return FAKE_CELL;
if (st == NULL)
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "nasl_exec: st == NULL\n");
#endif
return NULL;
}
if (nasl_trace_fp != NULL)
nasl_short_dump(nasl_trace_fp, st);
switch(st->type)
{
case NODE_IF_ELSE:
ret = nasl_exec(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
if (cvt_bool(lexic, ret))
ret2 = nasl_exec(lexic, st->link[1]);
else
if (st->link[2] != NULL) /* else branch */
ret2 = nasl_exec(lexic, st->link[2]);
else /* No else */
ret2 = FAKE_CELL;
deref_cell(ret);
return ret2;
case NODE_INSTR_L: /* Block. [0] = first instr, [1] = tail */
ret = nasl_exec(lexic, st->link[0]);
#if NASL_DEBUG > 1
if (ret == NULL)
nasl_perror(lexic, "Instruction failed. Going on in block\n");
#endif
if (st->link[1] == NULL || lexic->break_flag || lexic->cont_flag)
return ret;
deref_cell(ret);
ret = nasl_exec(lexic, st->link[1]);
return ret;
case NODE_FOR:
/* [0] = start expr, [1] = cond, [2] = end_expr, [3] = block */
ret2 = nasl_exec(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (ret2 == NULL)
return NULL;
#endif
deref_cell(ret2);
for (;;)
{
/* Break the loop if 'return' */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* condition */
if ((ret = nasl_exec(lexic, st->link[1])) == NULL)
return NULL; /* We can return here, as NULL is false */
flag = cvt_bool(lexic, ret);
deref_cell(ret);
if (! flag)
break;
/* block */
ret = nasl_exec(lexic, st->link[3]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
return FAKE_CELL;
}
lexic->cont_flag = 0; /* No need to test if set */
/* end expression */
ret = nasl_exec(lexic, st->link[2]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
}
return FAKE_CELL;
case NODE_WHILE:
/* [0] = cond, [1] = block */
for (;;)
{
/* return? */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* Condition */
if ((ret = nasl_exec(lexic, st->link[0])) == NULL)
return NULL; /* NULL is false */
flag = cvt_bool(lexic, ret);
deref_cell(ret);
if (! flag)
break;
/* Block */
ret = nasl_exec(lexic, st->link[1]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
return FAKE_CELL;
}
lexic->cont_flag = 0;
}
return FAKE_CELL;
case NODE_REPEAT_UNTIL:
/* [0] = block, [1] = cond */
for (;;)
{
/* return? */
if (lexic->ret_val != NULL)
{
ref_cell(lexic->ret_val);
return lexic->ret_val;
}
/* Block */
ret = nasl_exec(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
deref_cell(ret);
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
return FAKE_CELL;
}
lexic->cont_flag = 0;
/* Condition */
ret = nasl_exec(lexic, st->link[1]);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
return NULL;
#endif
flag = cvt_bool(lexic, ret);
deref_cell(ret);
if (flag)
break;
}
return FAKE_CELL;
case NODE_FOREACH:
/* str_val = index name, [0] = array, [1] = block */
{
nasl_iterator ai;
tree_cell *v, *a, *val;
v = get_variable_by_name(lexic, st->x.str_val);
if (v == NULL)
return NULL; /* We cannot go on if we have no variable to iterate */
a = nasl_exec(lexic, st->link[0]);
ai = nasl_array_iterator(a);
while ((val = nasl_iterate_array(&ai)) != NULL)
{
tc1 = nasl_affect(v, val);
ret = nasl_exec(lexic, st->link[1]);
deref_cell(val);
deref_cell(tc1);
#ifdef STOP_AT_FIRST_ERROR
if (ret == NULL)
break;
#endif
deref_cell(ret);
/* return */
if (lexic->ret_val != NULL)
break;
/* break */
if (lexic->break_flag)
{
lexic->break_flag = 0;
break;
}
lexic->cont_flag = 0;
}
deref_cell(a);
deref_cell(v);
}
return FAKE_CELL;
case NODE_FUN_DEF:
/* x.str_val = function name, [0] = argdecl, [1] = block */
ret = decl_nasl_func(lexic, st);
return ret;
case NODE_FUN_CALL:
pf = get_func_ref_by_name(lexic, st->x.str_val);
if (pf == NULL)
{
nasl_perror(lexic, "Undefined function '%s'\n", st->x.str_val);
return NULL;
}
args = st->link[0];
#if 0
printf("****************\n");
nasl_dump_tree(args);
printf("****************\n");
#endif
ret = nasl_func_call(lexic, pf, args);
return ret;
case NODE_REPEATED:
n = cell2intW(lexic, st->link[1]);
if (n <= 0)
return NULL;
#ifdef STOP_AT_FIRST_ERROR
for (tc1 = NULL, i = 1; i <= n; i ++)
{
deref_cell(tc1);
if ((tc1 = nasl_exec(lexic, st->link[0])) == NULL)
return NULL;
}
return tc1;
#else
for (i = 1; i <= n; i ++)
{
tc1 = nasl_exec(lexic, st->link[0]);
deref_cell(tc1);
}
return FAKE_CELL;
#endif
/*
* I wonder...
* Will nasl_exec be really called with NODE_EXEC or NODE_ARG?
*/
case NODE_DECL: /* Used in function declarations */
/* [0] = next arg in list */
/* TBD? */
return st; /* ? */
case NODE_ARG: /* Used function calls */
/* val = name can be NULL, [0] = val, [1] = next arg */
ret = nasl_exec(lexic, st->link[0]); /* Is this wise? */
return ret;
case NODE_RETURN:
/* [0] = ret val */
ret = nasl_return(lexic, st->link[0]);
return ret;
case NODE_BREAK:
lexic->break_flag = 1;
return FAKE_CELL;
case NODE_CONTINUE:
lexic->cont_flag = 1;
return FAKE_CELL;
case NODE_ARRAY_EL: /* val = array name, [0] = index */
idx = cell2atom(lexic, st->link[0]);
ret = get_array_elem(lexic, st->x.str_val, idx);
deref_cell(idx);
return ret;
case NODE_AFF:
/* [0] = lvalue, [1] = rvalue */
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
ret = nasl_affect(tc1, tc2);
deref_cell(tc1); /* Must free VAR_REF */
deref_cell(ret);
return tc2; /* So that "a = b = e;" works */
case NODE_PLUS_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_PLUS, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2; /* So that "a = b += e;" works */
case NODE_MINUS_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_MINUS, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2; /* So that "a = b -= e;" works */
case NODE_MULT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_MULT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_DIV_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_DIV, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_MODULO_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_MODULO, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_L_SHIFT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_L_SHIFT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_R_SHIFT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_R_SHIFT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_R_USHIFT_EQ:
tc1 = nasl_exec(lexic, st->link[0]);
tc2 = nasl_exec(lexic, st->link[1]);
tc3 = alloc_expr_cell(0, EXPR_R_USHIFT, tc1, tc2);
ret2 = nasl_exec(lexic, tc3);
ret = nasl_affect(tc1, ret2);
deref_cell(tc3); /* Frees tc1 and tc2 */
deref_cell(ret);
return ret2;
case NODE_VAR:
/* val = variable name */
ret = get_variable_by_name(lexic, st->x.str_val);
return ret;
case NODE_LOCAL: /* [0] = argdecl */
ret = decl_local_variables(lexic, st->link[0]);
return ret;
case NODE_GLOBAL: /* [0] = argdecl */
ret = decl_global_variables(lexic, st->link[0]);
return ret;
case EXPR_AND:
x = cell2bool(lexic, st->link[0]);
if(! x)
return bool2cell(0);
y = cell2bool(lexic, st->link[1]);
return bool2cell(y);
case EXPR_OR:
x = cell2bool(lexic, st->link[0]);
if(x)
return bool2cell(x);
y = cell2bool(lexic, st->link[1]);
return bool2cell(y);
case EXPR_NOT:
x = cell2bool(lexic, st->link[0]);
return bool2cell(! x);
case EXPR_INCR:
case EXPR_DECR:
x = (st->type == EXPR_INCR) ? 1 : -1;
if (st->link[0] == NULL)
{
y = 1; /* pre */
tc1 = st->link[1];
}
else
{
y = 0; /* post */
tc1 = st->link[0];
}
tc2 = nasl_exec(lexic, tc1);
if (tc2 == NULL)
return NULL;
ret = nasl_incr_variable(lexic, tc2, y, x);
deref_cell(tc2);
return ret;
if (st->link[0] == NULL)
ret = nasl_incr_variable(lexic, st->link[1], 1, 1);
else
ret = nasl_incr_variable(lexic, st->link[1], 0, 1);
break;
case EXPR_PLUS:
s1 = s2 = NULL;
tc1 = cell2atom(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (tc1 == NULL || tc1 == FAKE_CELL)
return NULL;
#endif
tc2 = cell2atom(lexic, st->link[1]);
if (tc2 == NULL || tc2 == FAKE_CELL)
{
#ifdef STOP_AT_FIRST_ERROR
deref_cell(tc1);
return NULL;
#else
return tc1;
#endif
}
if (tc1 == NULL || tc1 == FAKE_CELL)
return tc2;
/*
* Anything added to a string is converted to a string
* Otherwise anything added to an intger is converted into an integer
*/
if (tc1->type == CONST_DATA || tc2->type == CONST_DATA)
flag = CONST_DATA;
else if (tc1->type == CONST_STR || tc2->type == CONST_STR)
flag = CONST_STR;
else if (tc1->type == CONST_INT || tc2->type == CONST_INT)
flag = CONST_INT;
else
flag = NODE_EMPTY;
#if NASL_DEBUG > 0
if ((flag == CONST_DATA || flag == CONST_STR) &&
(tc1->type == CONST_INT || tc2->type == CONST_INT))
nasl_perror(lexic, "Horrible type conversion (int -> str) for operator + %s\n", get_line_nb(st));
#endif
switch (flag)
{
case CONST_INT:
x = tc1->x.i_val;
y = cell2int(lexic, tc2);
ret = int2cell(x + y);
break;
case CONST_STR:
case CONST_DATA:
s1 = s2 = NULL;
if (tc1->type == CONST_STR || tc1->type == CONST_DATA)
len1 = tc1->size;
else
{
s1 = cell2str(lexic, tc1);
len1 = (s1 == NULL ? 0 : strlen(s1));
}
if (tc2->type == CONST_STR || tc2->type == CONST_DATA)
len2 = tc2->size;
else
{
s2 = cell2str(lexic, tc2);
len2 = (s2 == NULL ? 0 : strlen(s2));
}
sz = len1 + len2;
s3 = emalloc(sz);
if (len1 > 0)
memcpy(s3, s1 != NULL ? s1 : tc1->x.str_val, len1);
if (len2 > 0)
memcpy(s3 + len1, s2 != NULL ? s2 : tc2->x.str_val, len2);
efree(&s1); efree(&s2);
ret = alloc_tree_cell(0, s3);
ret->type = flag;
ret->size = sz;
break;
default:
ret = NULL;
break;
}
deref_cell(tc1);
deref_cell(tc2);
return ret;
case EXPR_MINUS: /* Infamous duplicated code */
s1 = s2 = NULL;
tc1 = cell2atom(lexic, st->link[0]);
#ifdef STOP_AT_FIRST_ERROR
if (tc1 == NULL || tc1 == FAKE_CELL)
return NULL;
#endif
tc2 = cell2atom(lexic, st->link[1]);
if (tc2 == NULL || tc2 == FAKE_CELL)
{
#ifdef STOP_AT_FIRST_ERROR
deref_cell(tc1);
return NULL;
#else
return tc1;
#endif
}
if (tc1 == NULL || tc1 == FAKE_CELL)
{
if (tc2->type == CONST_INT)
{
y = cell2int(lexic, tc2);
ret = int2cell(- y);
}
else
ret = NULL;
deref_cell(tc2);
return ret;
}
/*
* Anything substracted from a string is converted to a string
* Otherwise anything substracted from integer is converted into an
* integer
*/
if (tc1->type == CONST_DATA || tc2->type == CONST_DATA)
flag = CONST_DATA;
else if (tc1->type == CONST_STR || tc2->type == CONST_STR)
flag = CONST_STR;
else if (tc1->type == CONST_INT || tc2->type == CONST_INT)
flag = CONST_INT;
else
flag = NODE_EMPTY;
#if NASL_DEBUG > 0
if ((flag == CONST_DATA || flag == CONST_STR) &&
(tc1->type == CONST_INT || tc2->type == CONST_INT))
nasl_perror(lexic, "Horrible type conversion (int -> str) for operator - %s\n", get_line_nb(st));
#endif
switch (flag)
{
case CONST_INT:
x = cell2int(lexic, tc1);
y = cell2int(lexic, tc2);
ret = int2cell(x - y);
break;
case CONST_STR:
case CONST_DATA:
if (tc1->type == CONST_STR || tc1->type == CONST_DATA)
{
p1 = tc1->x.str_val;
len1 = tc1->size;
}
else
{
p1 = s1 = cell2str(lexic, tc1);
len1 = (s1 == NULL ? 0 : strlen(s1));
}
if (tc2->type == CONST_STR || tc2->type == CONST_DATA)
{
p2 = tc2->x.str_val;
len2 = tc2->size;
}
else
{
p2 = s2 = cell2str(lexic, tc2);
len2 = (s2 == NULL ? 0 : strlen(s2));
}
if (len2 == 0 || len1 < len2 ||
(p = (char*)nasl_memmem(p1, len1, p2, len2)) == NULL)
{
s3 = emalloc(len1);
memcpy(s3, p1, len1);
ret = alloc_tree_cell(0, s3);
ret->type = flag;
ret->size = len1;
}
else
{
sz = len1 - len2;
if (sz <= 0)
{
sz = 0;
s3 = estrdup("");
}
else
{
s3 = emalloc(sz);
if (p - p1 > 0)
memcpy(s3, p1, p - p1);
if (sz > p - p1)
memcpy(s3 + (p - p1), p + len2, sz - (p - p1));
}
ret = alloc_tree_cell(0, s3);
ret->size = sz;
ret->type = flag;
}
efree(&s1); efree(&s2);
break;
default:
ret = NULL;
break;
}
deref_cell(tc1);
deref_cell(tc2);
return ret;
case EXPR_MULT:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x * y);
case EXPR_DIV:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
if( y != 0 )
return int2cell(x / y);
else
return int2cell(0);
case EXPR_EXPO:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(expo(x, y));
case EXPR_MODULO:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
if( y != 0)
return int2cell(x % y);
else
return int2cell(0);
case EXPR_BIT_AND:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x & y);
case EXPR_BIT_OR:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x | y);
case EXPR_BIT_XOR:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x ^ y);
case EXPR_BIT_NOT:
x = cell2intW(lexic, st->link[0]);
return int2cell(~ x);
case EXPR_U_MINUS:
x = cell2intW(lexic, st->link[0]);
return int2cell(- x);
/* TBD: Handle shift for strings and arrays */
case EXPR_L_SHIFT:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
return int2cell(x << y);
case EXPR_R_SHIFT: /* arithmetic right shift */
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
#if NASL_DEBUG > 0
if (y < 0)
nasl_perror(lexic, "Warning: Negative count in right shift!\n");
#endif
z = x >> y;
#ifndef __GNUC__
if (x < 0 && z >= 0) /* Fix it */
{
#if NASL_DEBUG > 1
nasl_perror(lexic, "Warning: arithmetic right shift is buggy! Fixing...\n");
#endif
z |= (~0) << (sizeof(x) * 8 - y);
}
#endif
return int2cell(z);
case EXPR_R_USHIFT:
x = cell2intW(lexic, st->link[0]);
y = cell2intW(lexic, st->link[1]);
#if NASL_DEBUG > 0
if (y < 0)
nasl_perror(lexic, "Warning: Negative count in right shift!\n");
#endif
z = (unsigned)x >> (unsigned)y;
#ifndef __GNUC__
if (x < 0 && z <= 0) /* Fix it! */
{
#if NASL_DEBUG > 1
nasl_perror(lexic, "Warning: Logical right shift is buggy! Fixing...\n");
#endif
z &= ~((~0) << (sizeof(x) * 8 - y));
}
#endif
return int2cell(z);
case COMP_MATCH:
case COMP_NOMATCH:
tc1 = cell2atom(lexic, st->link[0]);
tc2 = cell2atom(lexic, st->link[1]);
s1 = s2 = NULL;
if (tc1 == NULL || tc1 == FAKE_CELL)
{
p1 = "";
len1 = 0;
}
else if (tc1->type == CONST_STR || tc1->type == CONST_DATA)
{
p1 = tc1->x.str_val;
len1 = tc1->size;
}
else
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "Horrible type conversion (%s -> str) for operator >< or >!< %s\n", nasl_type_name(tc1->type), get_line_nb(st));
#endif
p1 = s1 = cell2str(lexic, tc1);
len1 = strlen(s1);
}
if (tc2 == NULL || tc2 == FAKE_CELL)
{
p2 = "";
len2 = 0;
}
else if (tc2->type == CONST_STR || tc2->type == CONST_DATA)
{
p2 = tc2->x.str_val;
len2 = tc2->size;
}
else
{
#if NASL_DEBUG > 0
nasl_perror(lexic, "Horrible type conversion (%s -> str) for operator >< or >!< %s\n", nasl_type_name(tc2->type), get_line_nb(st));
#endif
p2 = s2 = cell2str(lexic, tc2);
len2 = strlen(s2);
}
if(len1 <= len2)
flag = ((void*)nasl_memmem(p2, len2, p1, len1) != NULL);
else
flag = 0;
efree(&s1); efree(&s2);
deref_cell(tc1);
deref_cell(tc2);
if (st->type == COMP_MATCH)
return bool2cell(flag);
else
return bool2cell(! flag);
case COMP_RE_MATCH:
case COMP_RE_NOMATCH:
if (st->x.ref_val == NULL)
{
nasl_perror(lexic, "nasl_exec: bad regex at or near line %d\n",
st->line_nb);
return NULL;
}
s1 = cell2str(lexic, st->link[0]);
if (s1 == NULL)
return 0;
flag = nasl_regexec(st->x.ref_val, s1, 0, NULL, 0);
free(s1);
if (st->type == COMP_RE_MATCH)
return bool2cell(flag != REG_NOMATCH);
else
return bool2cell(flag == REG_NOMATCH);
case COMP_LT:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) < 0);
case COMP_LE:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) <= 0);
case COMP_EQ:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) == 0);
case COMP_NE:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) != 0);
case COMP_GT:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) > 0);
case COMP_GE:
return bool2cell(cell_cmp(lexic, st->link[0], st->link[1]) >= 0);
case REF_ARRAY:
case DYN_ARRAY:
case CONST_INT:
case CONST_STR:
case CONST_DATA:
ref_cell(st); /* nasl_exec returns a cell that should be deref-ed */
return st;
case REF_VAR:
ret = nasl_read_var_ref(lexic, st);
return ret;
default:
nasl_perror(lexic, "nasl_exec: unhandled node type %d\n", st->type);
abort();
return NULL;
}
deref_cell(ret);
deref_cell(ret2);
return NULL;
}
int
execute_nasl_script(struct arglist * script_infos, const char* name, const char * cache_dir, int mode)
{
naslctxt ctx;
nasl_func *pf;
int err = 0;
tree_cell *ret;
lex_ctxt *lexic;
char old_dir[MAXPATHLEN+1];
char *newdir;
char *old;
tree_cell tc;
struct arglist* prefs = arg_get_value(script_infos, "preferences");
char *str;
int to;
char * basename;
#ifdef ENABLE_PLUGIN_SERVER
char * cached_script = NULL;
unsigned int cached_script_len = 0;
#endif
srand48(getpid() + getppid() + (long)time(NULL));
old_dir[sizeof(old_dir) - 1] = '\0';
getcwd(old_dir, sizeof(old_dir) - 1);
#if NASL_DEBUG > 2
nasl_trace_fp = stderr;
#endif
if((old = arg_get_value(script_infos, "script_name")) == NULL)
arg_add_value(script_infos, "script_name", ARG_STRING, strlen(name), estrdup(name));
else
{
efree(&old);
arg_set_value(script_infos, "script_name", strlen(name), estrdup(name));
}
newdir = strrchr(name, '/');
if(newdir != NULL)
{
char dir[MAXPATHLEN+1];
char *s;
dir[sizeof(dir) - 1] = '\0';
strncpy(dir, name, sizeof(dir) - 1);
s = strrchr(dir, '/');
s[0] = '\0';
chdir(dir);
basename = newdir + 1;
}
else basename = (char*)name;
bzero(&ctx, sizeof(ctx));
if ( mode & NASL_ALWAYS_SIGNED )
ctx.always_authenticated = 1;
#ifdef ENABLE_PLUGIN_SERVER
if ( nasl_index_fetch(basename, &cached_script, &cached_script_len) >= 0 )
{
if ( nasl_load_parsed_tree_buf(&ctx, cached_script, cached_script_len, basename) < 0 )
{
printf("Could not load plugin\n");
efree(&cached_script);
chdir(old_dir);
return -1;
}
efree(&cached_script);
}
else
#endif
{
if (nasl_load_or_parse(&ctx, name, basename, cache_dir) < 0 )
{
chdir(old_dir);
return -1;
}
}
#if NASL_DEBUG > 4
nasl_dump_tree(ctx.tree);
#endif
lexic = init_empty_lex_ctxt();
lexic->script_infos = script_infos;
if ( mode & NASL_ALWAYS_SIGNED )
lexic->authenticated = 1;
else
lexic->authenticated = ctx.authenticated;
str = arg_get_value(prefs, "checks_read_timeout");
if( str != NULL )
to = atoi(str);
else
to = 5;
if(to <= 0)to = 5;
lexic->recv_timeout = to;
init_nasl_library(lexic);
if (mode & NASL_LINT)
{
if (nasl_lint(lexic, ctx.tree) == NULL)
err --;
}
else
if (! (mode & NASL_EXEC_PARSE_ONLY))
{
char *p;
bzero(&tc, sizeof(tc));
tc.type = CONST_INT;
tc.x.i_val = (mode & NASL_COMMAND_LINE) != 0;
add_named_var_to_ctxt(lexic, "COMMAND_LINE", &tc);
bzero(&tc, sizeof(tc));
tc.type = CONST_INT;
tc.x.i_val = (mode & NASL_EXEC_DESCR) != 0;
add_named_var_to_ctxt(lexic, "description", &tc);
tc.type = CONST_DATA;
p = strrchr(name, '/');
if (p == NULL) p = (char*)name; else p ++;
tc.x.str_val = p;
tc.size = strlen(p);
add_named_var_to_ctxt(lexic, "SCRIPT_NAME", &tc);
truc = (lex_ctxt*)ctx.tree;
if ((ret = nasl_exec(lexic, ctx.tree)) == NULL)
err = -1;
else
deref_cell(ret);
if ((pf = get_func_ref_by_name(lexic, "on_exit")) != NULL)
nasl_func_call(lexic, pf, NULL);
}
#if NASL_DEBUG > 2
{
struct rusage ru;
if (getrusage(RUSAGE_SELF, &ru) < 0)
perror("getrusage");
else
{
nasl_perror(lexic,
"rusage: utime=%d.%03d stime=%d.%03d minflt=%d majflt=%d nswap=%d\n",
ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 1000,
ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 1000,
ru.ru_minflt, ru.ru_majflt, ru.ru_nswap);
}
}
#endif
#if NASL_DEBUG > 3
nasl_dump_tree(ctx.tree);
#endif
chdir(old_dir);
if ( mode & NASL_EXEC_DONT_CLEANUP ) return err;
nasl_clean_ctx(&ctx);
free_lex_ctxt(lexic);
return err;
}
int
execute_nasl_script(struct arglist * script_infos, const char* name, int mode)
{
naslctxt ctx;
nasl_func *pf;
int err = 0;
tree_cell *ret;
lex_ctxt *lexic;
char old_dir[MAXPATHLEN+1];
char *newdir;
char *old;
tree_cell description;
struct arglist* prefs = arg_get_value(script_infos, "preferences");
char *str;
int to;
srand48(getpid() + getppid() + (long)time(NULL));
old_dir[sizeof(old_dir) - 1] = '\0';
getcwd(old_dir, sizeof(old_dir) - 1);
#if NASL_DEBUG > 2
nasl_trace_fp = stderr;
#endif
if((old = arg_get_value(script_infos, "script_name")) == NULL)
arg_add_value(script_infos, "script_name", ARG_STRING, strlen(name), estrdup(name));
else
{
efree(&old);
arg_set_value(script_infos, "script_name", strlen(name), estrdup(name));
}
newdir = strrchr(name, '/');
if(newdir != NULL)
{
char dir[MAXPATHLEN+1];
char *s;
dir[sizeof(dir) - 1] = '\0';
strncpy(dir, name, sizeof(dir) - 1);
s = strrchr(dir, '/');
s[0] = '\0';
chdir(dir);
}
if (init_nasl_ctx(&ctx, name) < 0)
{
chdir(old_dir);
return -1;
}
if (naslparse(&ctx))
{
nasl_perror(NULL, "\nParse error at or near line %d\n", ctx.line_nb);
nasl_clean_ctx(&ctx);
chdir(old_dir);
return -1;
}
#if NASL_DEBUG > 4
nasl_dump_tree(ctx.tree);
#endif
lexic = init_empty_lex_ctxt();
lexic->script_infos = script_infos;
str = arg_get_value(prefs, "checks_read_timeout");
if( str != NULL )
to = atoi(str);
else
to = 5;
if(to <= 0)to = 5;
lexic->recv_timeout = to;
init_nasl_library(lexic);
if (! (mode & NASL_EXEC_PARSE_ONLY))
{
bzero(&description, sizeof(description));
description.type = CONST_INT;
description.x.i_val = (mode & NASL_EXEC_DESCR) != 0;
add_named_var_to_ctxt(lexic, "description", &description);
truc = (lex_ctxt*)ctx.tree;
if ((ret = nasl_exec(lexic, ctx.tree)) == NULL)
err = -1;
else
deref_cell(ret);
if ((pf = get_func_ref_by_name(lexic, "on_exit")) != NULL)
nasl_func_call(lexic, pf, NULL);
}
#if NASL_DEBUG > 2
{
struct rusage ru;
if (getrusage(RUSAGE_SELF, &ru) < 0)
perror("getrusage");
else
{
nasl_perror(lexic,
"rusage: utime=%d.%02d stime=%d.%02d minflt=%d majflt=%d\n",
ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 10000,
ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 10000,
ru.ru_minflt, ru.ru_majflt);
}
}
#endif
#if NASL_DEBUG > 3
nasl_dump_tree(ctx.tree);
#endif
nasl_clean_ctx(&ctx);
free_lex_ctxt(lexic);
chdir(old_dir);
return err;
}
tree_cell*
nasl_func_call(lex_ctxt* lexic, const nasl_func* f, tree_cell* arg_list)
{
#if 0
return FAKE_CELL;
#else
int nb_u = 0, nb_n = 0, nb_a = 0;
tree_cell *pc = NULL, *pc2 = NULL, *retc = NULL;
lex_ctxt *lexic2 = NULL;
char *trace_buf = NULL;
int trace_buf_len = 0, tn;
#define TRACE_BUF_SZ 255
#if 0
nasl_dump_tree(arg_list);
#endif
/* 1. Create a new context */
lexic2 = init_empty_lex_ctxt();
lexic2->script_infos = lexic->script_infos;
lexic2->authenticated = lexic->authenticated;
lexic2->recv_timeout = lexic->recv_timeout;
lexic2->fct_ctxt = 1;
if (nasl_trace_fp != NULL)
{
trace_buf = emalloc(TRACE_BUF_SZ);
tn =
snprintf(trace_buf, TRACE_BUF_SZ, "Call %s(", f->func_name);
if (tn > 0) trace_buf_len += tn;
}
if (! (f->flags & FUNC_FLAG_COMPAT))
{
for (pc = arg_list; pc != NULL; pc = pc->link[1])
if (pc->x.str_val == NULL)
nb_u ++;
else
{
size_t num = f->nb_named_args;
if (lfind(&pc->x.str_val, f->args_names, &num, sizeof(char*), stringcompare) != NULL)
nb_n ++;
}
if (nb_n + nb_u > f->nb_unnamed_args + f->nb_named_args)
nasl_perror(lexic,
"Too many args for function '%s' [%dN+%dU > %dN+%dU]\n",
f->func_name, nb_n, nb_u, f->nb_unnamed_args, f->nb_named_args);
/*
* I should look exactly how unnamed arguments works...
* Or maybe I should remove this feature?
*/
for (nb_u = 0, pc = arg_list; pc != NULL; pc = pc->link[1])
{
#if 0
pc2 = pc->link[0];
ref_cell(pc2);
do
{
pc22 = nasl_exec(lexic, pc2);
deref_cell(pc2);
pc2 = pc22;
}
while (! nasl_is_leaf(pc2));
#else
pc2 = cell2atom(lexic, pc->link[0]);
#endif
if (pc->x.str_val == NULL)
{
/* 2. Add unnamed (numbered) variables for unnamed args */
if (add_numbered_var_to_ctxt(lexic2, nb_u, pc2) == NULL)
goto error;
nb_u ++;
if (nasl_trace_fp != NULL && trace_buf_len < TRACE_BUF_SZ)
{
tn =
snprintf(trace_buf + trace_buf_len,
TRACE_BUF_SZ - trace_buf_len,
"%s%d: %s",
nb_a > 0 ? ", " : "", nb_u,
dump_cell_val(pc2));
if (tn > 0) trace_buf_len += tn;
}
nb_a ++;
}
else
{
/* 3. and add named variables for named args */
if (add_named_var_to_ctxt(lexic2, pc->x.str_val, pc2) == NULL)
goto error;
if (nasl_trace_fp != NULL && trace_buf_len < TRACE_BUF_SZ)
{
tn =
snprintf(trace_buf + trace_buf_len,
TRACE_BUF_SZ - trace_buf_len,
"%s%s: %s",
nb_a > 0 ? ", " : "", pc->x.str_val,
dump_cell_val(pc2));
if (tn > 0) trace_buf_len += tn;
}
nb_a ++;
}
deref_cell(pc2);
}
if (nasl_trace_fp != NULL)
{
if (trace_buf_len < TRACE_BUF_SZ)
nasl_trace(lexic, "NASL> %s)\n", trace_buf);
else
nasl_trace(lexic, "NASL> %s ...)\n", trace_buf);
trace_buf_len = 0;
efree(&trace_buf);
}
/* 4. Chain new context to old (lexic) */
lexic2->up_ctxt = lexic;
/* 5. Execute */
if (f->flags & FUNC_FLAG_INTERNAL)
{
tree_cell* (*pf2)(lex_ctxt*) = f->block;
retc = pf2(lexic2);
}
else
{
retc = nasl_exec(lexic2, f->block);
deref_cell(retc);
retc = FAKE_CELL;
}
if ((retc == NULL || retc == FAKE_CELL) &&
(lexic2->ret_val != NULL && lexic2->ret_val != FAKE_CELL))
{
#if 0
nasl_perror(lexic, "nasl_func_call: nasl_exec(%s) returns NULL or FAKE value, but context disagrees. Fixing...\n", f->func_name);
nasl_dump_tree(retc);
#endif
retc = lexic2->ret_val;
ref_cell(retc);
}
if(nasl_trace_enabled())nasl_trace(lexic, "NASL> Return %s: %s\n", f->func_name,
dump_cell_val(retc));
#if 1
if (! nasl_is_leaf(retc))
{
nasl_perror(lexic, "nasl_func_call: return value from %s is not atomic!\n", f->func_name);
nasl_dump_tree(retc);
}
#endif
free_lex_ctxt(lexic2); lexic2 = NULL;
return retc;
}
error:
free_lex_ctxt(lexic2);
return NULL;
#endif
}
