exec.h File Reference

#include "nasl_lex_ctxt.h"

Include dependency graph for exec.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
tree_cell *	nasl_exec (lex_ctxt *, tree_cell *)
	Execute a parse tree. More...
long int	cell_cmp (lex_ctxt *, tree_cell *, tree_cell *)
tree_cell *	cell2atom (lex_ctxt *, tree_cell *)

Function Documentation

cell2atom()

tree_cell* cell2atom	(	lex_ctxt *	lexic,
		tree_cell *	c1
	)

Returns

A 'referenced' cell.

Definition at line 194 of file exec.c.

{
  tree_cell *c2 = NULL, *ret = NULL;
  if (c1 == NULL || c1 == FAKE_CELL)
    return c1;
 
  switch (c1->type)
    {
    case CONST_INT:
    case CONST_STR:
    case CONST_DATA:
    case REF_ARRAY:
    case DYN_ARRAY:
      ref_cell (c1);
      return c1;
    default:
      c2 = nasl_exec (lexic, c1);
      ret = cell2atom (lexic, c2);
      deref_cell (c2);
      return ret;
    }
}

cell_cmp()

long int cell_cmp	(	lex_ctxt *	,
		tree_cell *	,
		tree_cell *
	)

Definition at line 218 of file exec.c.

{
  int flag, typ, typ1, typ2;
  long int x1, x2;
  char *s1, *s2;
  int len_s1, len_s2, len_min;
 
  if (c1 == NULL || c1 == FAKE_CELL)
    nasl_perror (lexic, "cell_cmp: c1 == NULL !\n");
  if (c2 == NULL || c2 == FAKE_CELL)
    nasl_perror (lexic, "cell_cmp: c2 == NULL !\n");
 
  /* We first convert the cell to atomic types. */
  c1 = cell2atom (lexic, c1);
  c2 = cell2atom (lexic, c2);
 
  /*
   * Comparing anything to something else which is entirely different
   * may lead to unpredictable results.
   * Here are the rules:
   * 1. No problem with same types, although we do not compare arrays yet
   * 2. No problem with CONST_DATA / CONST_STR
   * 3. When an integer is compared to a string, the integer is converted
   * 4. When NULL is compared to an integer, it is converted to 0
   * 5. When NULL is compared to a string, it is converted to ""
   * 6. NULL is "smaller" than anything else (i.e. an array)
   * Anything else is an error
   */
  typ1 = cell_type (c1);
  typ2 = cell_type (c2);
 
  if (typ1 == 0 && typ2 == 0) /* Two NULL */
    {
      deref_cell (c1);
      deref_cell (c2);
      return 0;
    }
 
  if (typ1 == typ2) /* Same type, no problem */
    typ = typ1;
  else if ((typ1 == CONST_DATA || typ1 == CONST_STR)
           && (typ2 == CONST_DATA || typ2 == CONST_STR))
    typ = CONST_DATA; /* Same type in fact (string) */
  /* We convert an integer into a string before compare */
  else if ((typ1 == CONST_INT && (typ2 == CONST_DATA || typ2 == CONST_STR))
           || (typ2 == CONST_INT && (typ1 == CONST_DATA || typ1 == CONST_STR)))
    typ = CONST_DATA;
  else if (typ1 == 0) /* 1st argument is null */
    if (typ2 == CONST_INT || typ2 == CONST_DATA || typ2 == CONST_STR)
      typ = typ2; /* We convert it to 0 or "" */
    else
      {
        deref_cell (c1);
        deref_cell (c2);
        return -1; /* NULL is smaller than anything else */
      }
  else if (typ2 == 0) /* 2nd argument is null */
    if (typ1 == CONST_INT || typ1 == CONST_DATA || typ1 == CONST_STR)
      typ = typ1; /* We convert it to 0 or "" */
    else
      {
        deref_cell (c1);
        deref_cell (c2);
        return 1; /* Anything else is greater than NULL  */
      }
  else
    {
      gchar *n1, *n2;
 
      n1 = cell2str (lexic, c1);
      n2 = cell2str (lexic, c2);
      nasl_perror (lexic,
                   "cell_cmp: comparing '%s' of type %s and '%s' of "
                   "type %s does not make sense\n",
                   n1, nasl_type_name (typ1), n2, nasl_type_name (typ2));
      g_free (n1);
      g_free (n2);
      deref_cell (c1);
      deref_cell (c2);
      return 0;
    }
 
  switch (typ)
    {
    case CONST_INT:
      x1 = cell2int (lexic, c1);
      x2 = cell2int (lexic, c2);
      deref_cell (c1);
      deref_cell (c2);
      return x1 - x2;
 
    case CONST_STR:
    case CONST_DATA:
      s1 = cell2str (lexic, c1);
      if (typ1 == CONST_STR || typ1 == CONST_DATA)
        len_s1 = c1->size;
      else if (s1 == NULL)
        len_s1 = 0;
      else
        len_s1 = strlen (s1);
 
      s2 = cell2str (lexic, c2);
      if (typ2 == CONST_STR || typ2 == CONST_DATA)
        len_s2 = c2->size;
      else if (s2 == NULL)
        len_s2 = 0;
      else
        len_s2 = strlen (s2);
 
      len_min = len_s1 < len_s2 ? len_s1 : len_s2;
      flag = 0;
 
      if (len_min > 0)
        flag = memcmp (s1, s2, len_min);
      if (flag == 0)
        flag = len_s1 - len_s2;
 
      g_free (s1);
      g_free (s2);
      deref_cell (c1);
      deref_cell (c2);
      return flag;
 
    case REF_ARRAY:
    case DYN_ARRAY:
      g_message ("cell_cmp: cannot compare arrays yet");
      deref_cell (c1);
      deref_cell (c2);
      return 0;
 
    default:
      g_message ("cell_cmp: don't known how to compare %s and %s",
                 nasl_type_name (typ1), nasl_type_name (typ2));
      deref_cell (c1);
      deref_cell (c2);
      return 0;
    }
}

References cell2atom(), cell2int(), cell2str(), cell_type(), CONST_DATA, CONST_INT, CONST_STR, deref_cell(), DYN_ARRAY, FAKE_CELL, nasl_perror(), nasl_type_name(), REF_ARRAY, and TC::size.

Referenced by nasl_exec(), and var_cmp().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_exec()

tree_cell* nasl_exec	(	lex_ctxt *	,
		tree_cell *
	)

Execute a parse tree.

Todo:

There is a lot of duplicated code in following cases, could be refactored.

Definition at line 770 of file exec.c.

{
  tree_cell *ret = NULL, *ret2 = NULL, *tc1 = NULL, *tc2 = NULL, *tc3 = NULL,
            *idx = NULL, *args;
  int flag, z;
  char *s1 = NULL, *s2 = NULL, *s3 = NULL, *p = NULL;
  char *p1, *p2;
  int len1, len2;
  nasl_func *pf = NULL;
  long int x, y, n;
  int i, lint_mode = 0;
 
  if (st)
    if (st->line_nb != 0)
      lexic->line_nb = st->line_nb;
  /* 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)
    {
      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 (cell2bool (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 (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 = cell2bool (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 = cell2bool (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 = cell2bool (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 (lexic, 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;
          }
        free_array (ai.a);
        g_free (ai.a);
        deref_cell (a);
        deref_cell (v);
      }
      return FAKE_CELL;
 
    case NODE_FUN_DEF:
      /* x.str_val = function name, [0] = argdecl, [1] = block */
      /* 3rd arg is only for lint. Hier is always 0 */
      ret = decl_nasl_func (lexic, st, lint_mode);
      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];
      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;
 
    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;
      switch (flag)
        {
          long sz;
        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 = g_malloc0 (sz + 1);
          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);
          g_free (s1);
          g_free (s2);
          ret = alloc_typed_cell (flag);
          ret->x.str_val = s3;
          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 subtracted from a string is converted to a string
       * Otherwise anything subtracted 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;
      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 p1 is null, last condition p=memem() will not be evaluated
           * and p remains NULL */
          if (len2 == 0 || len1 < len2
              || (p1 != NULL && (p = memmem (p1, len1, p2, len2)) == NULL))
            {
              s3 = g_malloc0 (len1 + 1);
              if (p1 != NULL)
                memcpy (s3, p1, len1);
              ret = alloc_typed_cell (flag);
              ret->x.str_val = s3;
              ret->size = len1;
            }
          else
            {
              long sz = len1 - len2;
              if (sz <= 0)
                {
                  sz = 0;
                  s3 = g_strdup ("");
                }
              else
                {
                  s3 = g_malloc0 (sz + 1);
                  if (p - p1 > 0)
                    memcpy (s3, p1, p - p1);
                  if (p != NULL && sz > p - p1)
                    memcpy (s3 + (p - p1), p + len2, sz - (p - p1));
                }
              ret = alloc_typed_cell (flag);
              ret->x.str_val = s3;
              ret->size = sz;
            }
 
          g_free (s1);
          g_free (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]);
      z = x >> y;
#ifndef __GNUC__
      if (x < 0 && z >= 0) /* Fix it */
        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]);
      z = (unsigned) x >> (unsigned) y;
#ifndef __GNUC__
      if (x < 0 && z <= 0) /* Fix it! */
        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
        {
          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
        {
          p2 = s2 = cell2str (lexic, tc2);
          len2 = strlen (s2);
        }
 
      if (len1 <= len2)
        flag = (memmem (p2, len2, p1, len1) != NULL);
      else
        flag = 0;
 
      g_free (s1);
      g_free (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 = regexec (st->x.ref_val, s1, 0, NULL, 0);
      g_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;
    }
}

References nasl_iterator::a, alloc_expr_cell(), alloc_typed_cell(), bool2cell(), struct_lex_ctxt::break_flag, cell2atom(), cell2bool(), cell2int(), cell2intW(), cell2str(), cell_cmp(), COMP_EQ, COMP_GE, COMP_GT, COMP_LE, COMP_LT, COMP_MATCH, COMP_NE, COMP_NOMATCH, COMP_RE_MATCH, COMP_RE_NOMATCH, CONST_DATA, CONST_INT, CONST_STR, struct_lex_ctxt::cont_flag, decl_global_variables(), decl_local_variables(), decl_nasl_func(), deref_cell(), DYN_ARRAY, expo(), EXPR_AND, EXPR_BIT_AND, EXPR_BIT_NOT, EXPR_BIT_OR, EXPR_BIT_XOR, EXPR_DECR, EXPR_DIV, EXPR_EXPO, EXPR_INCR, EXPR_L_SHIFT, EXPR_MINUS, EXPR_MODULO, EXPR_MULT, EXPR_NOT, EXPR_OR, EXPR_PLUS, EXPR_R_SHIFT, EXPR_R_USHIFT, EXPR_U_MINUS, FAKE_CELL, free_array(), get_array_elem(), get_func_ref_by_name(), get_variable_by_name(), int2cell(), struct_lex_ctxt::line_nb, TC::line_nb, TC::link, nasl_affect(), nasl_array_iterator(), nasl_exec(), nasl_func_call(), nasl_incr_variable(), nasl_iterate_array(), nasl_perror(), nasl_read_var_ref(), nasl_return(), nasl_short_dump(), nasl_trace_fp, NODE_AFF, NODE_ARG, NODE_ARRAY_EL, NODE_BREAK, NODE_CONTINUE, NODE_DECL, NODE_DIV_EQ, NODE_EMPTY, NODE_FOR, NODE_FOREACH, NODE_FUN_CALL, NODE_FUN_DEF, NODE_GLOBAL, NODE_IF_ELSE, NODE_INSTR_L, NODE_L_SHIFT_EQ, NODE_LOCAL, NODE_MINUS_EQ, NODE_MODULO_EQ, NODE_MULT_EQ, NODE_PLUS_EQ, NODE_R_SHIFT_EQ, NODE_R_USHIFT_EQ, NODE_REPEAT_UNTIL, NODE_REPEATED, NODE_RETURN, NODE_VAR, NODE_WHILE, REF_ARRAY, ref_cell(), TC::ref_val, REF_VAR, struct_lex_ctxt::ret_val, TC::size, TC::str_val, TC::type, val, and TC::x.

Referenced by cell2atom(), cell2bool(), cell2int3(), cell2str(), exec_nasl_script(), nasl_exec(), and nasl_func_call().

Here is the call graph for this function:

Here is the caller graph for this function: