nasl_var.c

大国补丁后的nessus2.2.8的源代码

      nasl_perror(lexic, "nasl_incr_variable: variable %s is a STRING %s - converting to integer\n", "", get_line_nb(tc));
#endif
      old_val = v->v.v_str.s_val == NULL ? 0 : atoi((char*)v->v.v_str.s_val);
      break;
    case VAR2_UNDEF:
#if NASL_DEBUG > 0
      nasl_perror(lexic, "nasl_incr_variable: variable %s is undefined %s\n",
	      "", get_line_nb(tc));
#endif
      old_val = 0;
      break;

    default:
      nasl_perror(lexic, "nasl_incr_variable: variable %s has bad type %d %s\n",
	      /*get_var_name(v)*/ "", get_line_nb(tc));
      return NULL;
    }
  new_val = old_val + val;

  clear_anon_var(v);
  v->var_type = VAR2_INT;
  v->v.v_int = new_val;

  retc = alloc_tree_cell(0, NULL);
  retc->type = CONST_INT;
  retc->x.i_val = pre ? new_val : old_val;
  
  return retc;  
}


static int
var2int(anon_nasl_var* v, int defval)
{
  if (v == NULL)
    return defval;

  switch (v->var_type)
    {
    case VAR2_INT:
      return v->v.v_int;

    case VAR2_STRING:
    case VAR2_DATA:
      return atoi((char*)v->v.v_str.s_val);

    case VAR2_UNDEF:
#if NASL_DEBUG > 1
      nasl_perror(NULL, "var2int: variable %s is undefined!\n", get_var_name(v));
#endif
    case VAR2_ARRAY:
    default:
      return defval;
    }
  /*NOTREACHED*/
}

const char*
array2str(const nasl_array* a)
{
  static char	*s = NULL;
  static int	len = 0;

  int		i, n, n1 = 0, l;
  anon_nasl_var	 *u;
  named_nasl_var *v;


  if (a == NULL)
    return "";

  if (len == 0)
    {
      len = 80;
      s = emalloc(80);
    }

  strcpy(s, "[ "); n = strlen(s);

  if (a->num_elt != NULL)
    for (i = 0; i < a->max_idx; i ++)
      if ((u = a->num_elt[i]) != NULL && u->var_type != VAR2_UNDEF)
	{
	  if (n + 80 >= len)
	    {
	      len += 80;
	      s = erealloc(s, len);
	    }
	  if (n1 > 0)
	    n += sprintf(s+n, ", ");
	  n1 ++;
	  switch (u->var_type)
	    {
	    case VAR2_INT:
	      snprintf(s+n, len - n, "%d: %d", i, u->v.v_int);
	      n += strlen(s + n);
	      break;
	    case VAR2_STRING:
	    case VAR2_DATA:
	      if (u->v.v_str.s_siz < 64)
		{
		  snprintf(s+n, len - n, "%d: '%s'", i, u->v.v_str.s_val);
		  n += strlen(s + n);
		}
	      else
		{
		  snprintf(s+n, 70, "%d: '%s", i, u->v.v_str.s_val);
		  n += strlen(s + n);
		  n += sprintf(s+n, "'...");
		}
	      break;
	    default:
	      snprintf(s+n, len-n, "%d: ????", i);
	      n += strlen(s + n);
	      break;
	    }
	}

  if (a->hash_elt != NULL)
    for (i = 0; i < VAR_NAME_HASH; i ++)
      for (v = a->hash_elt[i]; v != NULL; v = v->next_var)
	if (v->u.var_type != VAR2_UNDEF)
	  {
	    l = strlen(v->var_name);
	    u = &v->u;
	    if (n + 80 >= len)
	      {
		len += 80 + l;
		s = erealloc(s, len);
	      }
	    if (n1 > 0)
	      n += sprintf(s+n, ", ");
	    n1 ++;
	    switch (u->var_type)
	      {
	      case VAR2_INT:
		n += snprintf(s+n, len - n, "%s: %d", v->var_name, u->v.v_int);
		break;
	      case VAR2_STRING:
	      case VAR2_DATA:
		if (u->v.v_str.s_siz < 64)
		  {
		    snprintf(s+n, len - n, "%s: '%s'", v->var_name, u->v.v_str.s_val);
		    n += strlen(s + n);
		  }
		else
		  {
		    snprintf(s+n, 70+l, "%s: '%s", v->var_name, u->v.v_str.s_val);
		    n += strlen(s + n);
		    n += sprintf(s+n, "'...");
		  }
		break;
	      default:
		snprintf(s+n, len-n, "%s: ????", v->var_name);
		n += strlen(s + n);
		break;
	      }
	  }

  if (n + 2 >= len)
    {
      len += 80;
      s = erealloc(s, len);
    }
  strcpy(s + n, " ]");
  return s;
}

const char*	var2str(const anon_nasl_var* v)
{
  static char	s1[16];

  if (v == NULL)
    return NULL;

  switch (v->var_type)
    {
    case VAR2_INT:
      snprintf(s1, sizeof(s1), "%d", v->v.v_int);
      return s1;		/* buggy if called twice in a row */

    case VAR2_STRING:
    case VAR2_DATA:
      return v->v.v_str.s_val == NULL ? "" : (const char*)v->v.v_str.s_val;

    case VAR2_UNDEF:
#if NASL_DEBUG > 1
      nasl_perror(NULL, "var2str: variable %s is undefined!\n", get_var_name(v));
#endif
      return NULL;

    case VAR2_ARRAY:
      return array2str(&v->v.v_arr);

    default:
#if NASL_DEBUG > 0
      nasl_perror(NULL, "var2str: variable %s has unhandled type %d\n",
		  get_var_name(v), v->var_type);
#endif
      return "";
    }
}

int
get_int_var_by_num(lex_ctxt* lexic, int num, int defval)
{
  anon_nasl_var	*v = get_var_ref_by_num(lexic, num);
  return  var2int(v, defval);
}

int
get_int_var_by_name(lex_ctxt* lexic, const char* name, int defval)
{
  named_nasl_var	*v = get_var_ref_by_name(lexic, name, 1);
  return  var2int(&v->u, defval);
}

int 
get_int_local_var_by_name(lex_ctxt * lexic, const char * name, int defval)
{
  named_nasl_var 	*v = get_var_ref_by_name(lexic, name, 0);
  return var2int(&v->u, defval);
}


char*
get_str_var_by_num(lex_ctxt* lexic, int num)
{
  anon_nasl_var	*v = get_var_ref_by_num(lexic, num);
  return  (char*)var2str(v);
}

char*
get_str_var_by_name(lex_ctxt* lexic, const char* name)
{
  named_nasl_var	*v = get_var_ref_by_name(lexic, name, 1);
  return  (char*)var2str(&v->u);
}

char *
get_str_local_var_by_name(lex_ctxt * lexic, const char * name)
{
  named_nasl_var	*v = get_var_ref_by_name(lexic, name, 0);
  return  (char*)var2str(&v->u);
}

static int
get_var_size(const anon_nasl_var* v)
{
  if (v == NULL)
    return 0;
  switch (v->var_type)
    {
    case VAR2_DATA:
    case VAR2_STRING:
      return v->v.v_str.s_siz;
#if 0
      /*
       * This code confuses nasl_string() because it does not returns the same
       * length as array2str
       */
    case VAR2_ARRAY:
      return v->v.v_arr.max_idx; /* Do not count 'named' elements yet */
#endif
    }
  return 0;
}

int
get_var_size_by_name(lex_ctxt* lexic, const char* name)
{
  named_nasl_var	*v = get_var_ref_by_name(lexic, name, 1);
  return get_var_size(&v->u);
}

int
get_local_var_size_by_name(lex_ctxt * lexic, const char * name)
{
  named_nasl_var 	*v = get_var_ref_by_name(lexic, name, 0);
  return get_var_size(&v->u);
}

int
get_var_size_by_num(lex_ctxt* lexic, int num)
{
  anon_nasl_var	*v = get_var_ref_by_num(lexic, num);
  return get_var_size(v);
}


int
get_var_type_by_num(lex_ctxt* lexic, int num)
{
  anon_nasl_var	*v = get_var_ref_by_num(lexic, num);
  return v == NULL ? VAR2_UNDEF : v->var_type;
}

int
get_var_type_by_name(lex_ctxt* lexic, const char * name)
{
  named_nasl_var	*v = get_var_ref_by_name(lexic, name, 1);
  return v == NULL ? VAR2_UNDEF : v->u.var_type;
}

int get_local_var_type_by_name(lex_ctxt * lexic, const char * name)
{
  named_nasl_var	*v = get_var_ref_by_name(lexic, name, 0);
  return v == NULL ? VAR2_UNDEF : v->u.var_type;
}

nasl_iterator
nasl_array_iterator(tree_cell* c)
{
  nasl_iterator		it;
  anon_nasl_var	*v;

  it.a = NULL;
  it.v = NULL;
  it.i1 = 0;
  it.iH = 0;
  
  if (c == NULL || c == FAKE_CELL)
    return it;

  if (c->type == REF_VAR)
    {
      v = c->x.ref_val;
      if (v == NULL || v->var_type != VAR2_ARRAY)
	return it;
      it.a = &v->v.v_arr;
    }
  else if (c->type == REF_ARRAY || c->type == DYN_ARRAY)
    {
      it.a = c->x.ref_val;
    }
  else
    {
      nasl_perror(NULL, "nasl_array_iterator: unhandled type %d (0x%x)\n",
	      c->type, c->type);
    }

  return it;
}

tree_cell*
nasl_iterate_array(nasl_iterator* it)
{
  anon_nasl_var	 *av;


  if (it == NULL || it->a == NULL)
    return NULL;

  if (it->i1 >= 0)
    {
      while (it->i1 < it->a->max_idx)
	{
	  av = it->a->num_elt[it->i1 ++];
	  if (av != NULL && av->var_type != VAR2_UNDEF)
	    return var2cell(av);
	}
      it->i1 = -1;
    }

  if (it->a->hash_elt == NULL)
    return NULL;

  if (it->v != NULL)
    it->v = it->v->next_var;
  do
    {
      while (it->v == NULL)
	if (it->iH >= VAR_NAME_HASH)
	  return NULL;
	else
	  it->v = it->a->hash_elt[it->iH ++];

      while (it->v != NULL && it->v->u.var_type == VAR2_UNDEF)
	it->v = it->v->next_var;
    }
  while (it->v == NULL);


  return var2cell(&it->v->u);
}

int
add_var_to_list(nasl_array* a, int i, const anon_nasl_var* v)
{
  anon_nasl_var	*v2;

  if (i < 0)
    {
      nasl_perror(NULL, "add_var_to_list: negative index are not (yet) supported\n");
      return -1;
    }

  if (i >= a->max_idx)
    {
      a->num_elt = erealloc(a->num_elt, sizeof(anon_nasl_var*) * (i+1));
      bzero(a->num_elt + a->max_idx, sizeof(anon_nasl_var*) * (i+1-a->max_idx));
      a->max_idx = i +1;
    }

  free_anon_var(a->num_elt[i]);
  v2 = dup_anon_var(v);	/* May return NULL */
  a->num_elt[i] = v2;
  if (v2 == NULL)
    return 0;
  else
    return 1;
}

int add_var_to_array(nasl_array *a, char * name, const anon_nasl_var* v)
{
 named_nasl_var * v2;
 int h = hash_str(name);
 
 if( a->hash_elt == NULL )
 {
  a->hash_elt = emalloc(VAR_NAME_HASH * sizeof(named_nasl_var*));
 }
 
 v2 = emalloc(sizeof(named_nasl_var));
 v2->var_name = estrdup(name);
 v2->u.var_type = VAR2_UNDEF;
 v2->next_var = a->hash_elt[h];
 a->hash_elt[h] = v2;
 
  
 copy_anon_var(&(v2->u), v);
 return 0;
}

/*
 * The name is not great: this function does not returns the index of the
 * last element, but the index of the next free slot
 */
int
array_max_index(nasl_array* a)
{
  int	i;

  for (i = a->max_idx - 1; i >= 0; i --)
    if (a->num_elt[i] != NULL && a->num_elt[i]->var_type != VAR2_UNDEF)
      {
	/* Fixing max_index will realloc() at next store.
	 * I am not sure it is a good idea
	 * Wait and see */
	a->max_idx = i + 1;
	return i+1;
      }
  return 0;
}

/*
 * make_array_from_list is used by the parser only
 * The list of elements is freed after use
 */

tree_cell*
make_array_from_elems(tree_cell* el)
{
  int		n;
  tree_cell	*c, *c2;
  nasl_array	*a;
  anon_nasl_var	v;

  a = emalloc(sizeof(nasl_array));
  /* Either the elements are all "named", or they are "numbered". No mix! */
  if (el->x.str_val == NULL) /* numbered */
    {
      for (n = 0, c = el; c != NULL; c= c->link[1])
	n ++;
      a->max_idx = n;
      a->num_elt = emalloc(sizeof(anon_nasl_var*) * n);
      a->hash_elt = NULL;
    }
  else
    {
      a->num_elt = NULL;
      a->hash_elt = emalloc(VAR_NAME_HASH * sizeof(named_nasl_var*));
    }
  
  for (n = 0, c = el; c != NULL; c= c->link[1])
    {
      c2 = c->link[0];
      if (c2 != NULL && c2 != FAKE_CELL)
	{
	  memset(&v, 0, sizeof(v));
	  switch (c2->type)
	    {
	    case CONST_INT:
	      v.var_type = VAR2_INT;
	      v.v.v_int = c2->x.i_val;
	      break;
	    case CONST_STR:
	    case CONST_DATA:
	      v.var_type = c2->type == CONST_STR ? VAR2_STRING : VAR2_DATA;
	      if (c2->x.str_val == NULL )
		{
		  v.v.v_str.s_val = NULL;
		  v.v.v_str.s_siz = 0;
		}
	      else
		{
		  v.v.v_str.s_siz = c2->size;
		  v.v.v_str.s_val = (unsigned char*)c2->x.str_val;
		}
	      break;
	    default:
	      nasl_perror(NULL, "make_array_from_list: unhandled cell type %s at position %d\n", nasl_type_name(c2->type), n);
	      v.var_type = VAR2_UNDEF;
	      break;
	    }
	}

      if (c->x.str_val == NULL)
	add_var_to_list(a, n ++, &v);
      else
	add_var_to_array(a, c->x.str_val, &v);
    }

  c = alloc_typed_cell(DYN_ARRAY);
  c->x.ref_val = a;
  deref_cell(el);
  return c;
}