nasl_var.h File Reference

#include "nasl_tree.h"

Include dependency graph for nasl_var.h:

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

Go to the source code of this file.

Data Structures
struct	st_nasl_string
struct	st_nasl_array
struct	st_a_nasl_var
struct	st_n_nasl_var
struct	nasl_iterator

Macros
#define	VAR_NAME_HASH   17

Typedefs
typedef struct st_nasl_string	nasl_string_t
typedef struct st_nasl_array	nasl_array
typedef struct st_a_nasl_var	anon_nasl_var
typedef struct st_n_nasl_var	named_nasl_var

Enumerations
enum	{   VAR2_UNDEF = 0, VAR2_INT, VAR2_STRING, VAR2_DATA,   VAR2_ARRAY }

Functions
tree_cell *	nasl_affect (tree_cell *, tree_cell *)
void	clear_unnamed_var (anon_nasl_var *)
const char *	var2str (anon_nasl_var *)
anon_nasl_var *	nasl_get_var_by_num (void *, nasl_array *, int, int)
nasl_iterator	nasl_array_iterator (void *, tree_cell *)
tree_cell *	nasl_iterate_array (nasl_iterator *)
int	add_var_to_list (nasl_array *, int, const anon_nasl_var *)
int	add_var_to_array (nasl_array *, char *, const anon_nasl_var *)
int	array_max_index (nasl_array *)
void	free_array (nasl_array *)
tree_cell *	copy_ref_array (const tree_cell *)
int	hash_str2 (const char *, int)
tree_cell *	var2cell (anon_nasl_var *)
tree_cell *	make_array_from_elems (tree_cell *)
char *	array2str (const nasl_array *)

Macro Definition Documentation

VAR_NAME_HASH

#define VAR_NAME_HASH   17

Definition at line 22 of file nasl_var.h.

Typedef Documentation

anon_nasl_var

typedef struct st_a_nasl_var anon_nasl_var

named_nasl_var

typedef struct st_n_nasl_var named_nasl_var

nasl_array

typedef struct st_nasl_array nasl_array

nasl_string_t

typedef struct st_nasl_string nasl_string_t

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
VAR2_UNDEF
VAR2_INT
VAR2_STRING
VAR2_DATA
VAR2_ARRAY

Definition at line 13 of file nasl_var.h.

{
  VAR2_UNDEF = 0,
  VAR2_INT,
  VAR2_STRING,
  VAR2_DATA,
  VAR2_ARRAY
};

Function Documentation

add_var_to_array()

int add_var_to_array	(	nasl_array *	,
		char *	,
		const anon_nasl_var *
	)

Definition at line 1277 of file nasl_var.c.

 {
   named_nasl_var *v2;
   int h = hash_str (name);
 
   if (a->hash_elt == NULL)
     {
       a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
     }
 
   v2 = g_malloc0 (sizeof (named_nasl_var));
   v2->var_name = g_strdup (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;
 }

References copy_anon_var(), st_nasl_array::hash_elt, hash_str(), name, st_n_nasl_var::next_var, st_n_nasl_var::u, VAR2_UNDEF, st_n_nasl_var::var_name, VAR_NAME_HASH, and st_a_nasl_var::var_type.

Referenced by get_kb_list(), get_tcp_option(), get_tcp_v6_option(), make_array_from_elems(), nasl_localtime(), and nasl_make_array().

Here is the call graph for this function:

Here is the caller graph for this function:

add_var_to_list()

int add_var_to_list	(	nasl_array *	,
		int	,
		const anon_nasl_var *
	)

Definition at line 1245 of file nasl_var.c.

 {
   anon_nasl_var *v2 = NULL;
 
   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 = g_realloc (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;
     }
 
   if (a->num_elt)
     {
       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;
 }

References dup_anon_var(), free_anon_var(), st_nasl_array::max_idx, nasl_perror(), and st_nasl_array::num_elt.

Referenced by array_from_snmp_error(), array_from_snmp_result(), crypt_data(), get_hostnames(), make_array_from_elems(), nasl_bf_cbc(), nasl_eregmatch(), nasl_get_sock_info(), nasl_keys(), nasl_make_array(), nasl_make_list(), nasl_split(), and resolve_hostname_to_multiple_ips().

Here is the call graph for this function:

Here is the caller graph for this function:

array2str()

char* array2str

(

const nasl_array *

)

Definition at line 993 of file nasl_var.c.

 {
   GString *str;
   int i, n1 = 0;
   anon_nasl_var *u;
   named_nasl_var *v;
 
   if (a == NULL)
     return NULL;
 
   str = g_string_new ("[ ");
   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 (n1 > 0)
             g_string_append (str, ", ");
           n1++;
           switch (u->var_type)
             {
             case VAR2_INT:
               g_string_append_printf (str, "%d: %ld", i, u->v.v_int);
               break;
             case VAR2_STRING:
             case VAR2_DATA:
               if (u->v.v_str.s_siz < 64)
                 g_string_append_printf (str, "%d: '%s'", i, u->v.v_str.s_val);
               else
                 g_string_append_printf (str, "%d: '%s'...", i,
                                         u->v.v_str.s_val);
               break;
             default:
               g_string_append_printf (str, "%d: ????", i);
               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)
           {
             u = &v->u;
             if (n1 > 0)
               g_string_append (str, ", ");
             n1++;
             switch (u->var_type)
               {
               case VAR2_INT:
                 g_string_append_printf (str, "%s: %ld", v->var_name,
                                         u->v.v_int);
                 break;
               case VAR2_STRING:
               case VAR2_DATA:
                 if (u->v.v_str.s_siz < 64)
                   g_string_append_printf (str, "%s: '%s'", v->var_name,
                                           u->v.v_str.s_val);
                 else
                   g_string_append_printf (str, "%s: '%s'...", v->var_name,
                                           u->v.v_str.s_val);
                 break;
               default:
                 g_string_append_printf (str, "%s: ????", v->var_name);
                 break;
               }
           }
 
   g_string_append (str, " ]");
   return g_string_free (str, FALSE);
 }

References st_nasl_array::hash_elt, st_nasl_array::max_idx, st_n_nasl_var::next_var, st_nasl_array::num_elt, st_nasl_string::s_siz, st_nasl_string::s_val, st_n_nasl_var::u, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, st_n_nasl_var::var_name, VAR_NAME_HASH, and st_a_nasl_var::var_type.

Referenced by cell2str(), and var2str().

Here is the caller graph for this function:

array_max_index()

int array_max_index

(

nasl_array *

a

)

The name is not great: this function does not returns the index of the last element, but the index of the next free slot

Definition at line 1302 of file nasl_var.c.

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

References st_nasl_array::max_idx, st_nasl_array::num_elt, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_max_index(), nasl_rawstring(), nasl_strcat(), and nasl_string().

Here is the caller graph for this function:

clear_unnamed_var()

void clear_unnamed_var

(

anon_nasl_var *

)

copy_ref_array()

tree_cell* copy_ref_array

(

const tree_cell *

)

Definition at line 537 of file nasl_var.c.

 {
   tree_cell *c2;
   nasl_array *a2;
 
   if (c1 == NULL || c1 == FAKE_CELL || c1->type != REF_ARRAY)
     return NULL;
 
   c2 = alloc_typed_cell (DYN_ARRAY);
   c2->x.ref_val = a2 = g_malloc0 (sizeof (nasl_array));
   copy_array (a2, c1->x.ref_val, 1);
   return c2;
 }

References alloc_typed_cell(), copy_array(), DYN_ARRAY, FAKE_CELL, REF_ARRAY, TC::ref_val, TC::type, and TC::x.

Referenced by nasl_return().

Here is the call graph for this function:

Here is the caller graph for this function:

free_array()

void free_array

(

nasl_array *

a

)

Note: the function does not free the nasl_array structure. Do it if necessary

Definition at line 342 of file nasl_var.c.

 {
   int i;
 
   if (a == NULL)
     return;
   if (a->num_elt != NULL)
     {
       for (i = 0; i < a->max_idx; i++)
         free_anon_var (a->num_elt[i]);
       g_free (a->num_elt);
       a->num_elt = NULL;
     }
   a->max_idx = 0;
   if (a->hash_elt != NULL)
     {
       for (i = 0; i < VAR_NAME_HASH; i++)
         free_var_chain (a->hash_elt[i]);
       g_free (a->hash_elt);
       a->hash_elt = NULL;
     }
 }

References free_anon_var(), free_var_chain(), st_nasl_array::hash_elt, st_nasl_array::max_idx, st_nasl_array::num_elt, and VAR_NAME_HASH.

Referenced by clear_anon_var(), copy_array(), free_anon_var(), free_lex_ctxt(), free_tree(), free_var_chain(), and nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

hash_str2()

int hash_str2	(	const char *	s,
		int	n
	)

Todo:

Consider using GLibs string hash function.

Definition at line 26 of file nasl_var.c.

{
  unsigned long h = 0;
  const char *p;
 
  if (s == NULL)
    return 0;
 
  for (p = s; *p != '\0'; p++)
    h = (h << 3) + (unsigned char) *p;
  return h % n;
}

Referenced by hash_str().

Here is the caller graph for this function:

make_array_from_elems()

tree_cell* make_array_from_elems

(

tree_cell *

el

)

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

Definition at line 1323 of file nasl_var.c.

 {
   int n;
   tree_cell *c, *c2;
   nasl_array *a;
   anon_nasl_var *v;
 
   v = g_malloc0 (sizeof (anon_nasl_var));
   a = g_malloc0 (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 = g_malloc0 (sizeof (anon_nasl_var *) * n);
       a->hash_elt = NULL;
     }
   else
     {
       a->num_elt = NULL;
       a->hash_elt = g_malloc0 (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)
         {
           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);
     }
 
   g_free (v);
   c = alloc_typed_cell (DYN_ARRAY);
   c->x.ref_val = a;
   deref_cell (el);
   return c;
 }

References add_var_to_array(), add_var_to_list(), alloc_typed_cell(), CONST_DATA, CONST_INT, CONST_STR, deref_cell(), DYN_ARRAY, FAKE_CELL, st_nasl_array::hash_elt, TC::i_val, TC::link, st_nasl_array::max_idx, nasl_perror(), nasl_type_name(), st_nasl_array::num_elt, TC::ref_val, st_nasl_string::s_siz, st_nasl_string::s_val, TC::size, TC::str_val, TC::type, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, VAR_NAME_HASH, st_a_nasl_var::var_type, and TC::x.

Referenced by yyparse().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_affect()

tree_cell* nasl_affect	(	tree_cell *	,
		tree_cell *
	)

Definition at line 700 of file nasl_var.c.

 {
   anon_nasl_var *v1 = NULL;
 
   if (lval == NULL)
     {
       nasl_perror (NULL, "nasl_effect: invalid lvalue\n");
       return NULL;
     }
 
   if (lval->type != REF_VAR)
     {
       nasl_perror (NULL, "nasl_affect: cannot affect to non variable %s\n",
                    nasl_type_name (lval->type));
       return NULL;
     }
 
   v1 = lval->x.ref_val;
   return affect_to_anon_var (v1, rval);
 }

References affect_to_anon_var(), nasl_perror(), nasl_type_name(), TC::ref_val, REF_VAR, TC::type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_array_iterator()

nasl_iterator nasl_array_iterator	(	void *	,
		tree_cell *
	)

Definition at line 1169 of file nasl_var.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 = g_malloc0 (sizeof (nasl_array));
       copy_array (it.a, &v->v.v_arr, 1);
     }
   else if (c->type == REF_ARRAY || c->type == DYN_ARRAY)
     {
       it.a = g_malloc0 (sizeof (nasl_array));
       copy_array (it.a, c->x.ref_val, 1);
     }
   else
     {
       nasl_perror (ctxt, "nasl_array_iterator: unhandled type %d (0x%x)\n",
                    c->type, c->type);
     }
 
   return it;
 }

References nasl_iterator::a, copy_array(), DYN_ARRAY, FAKE_CELL, nasl_iterator::i1, nasl_iterator::iH, nasl_perror(), REF_ARRAY, TC::ref_val, REF_VAR, TC::type, st_a_nasl_var::v, nasl_iterator::v, st_a_nasl_var::v_arr, VAR2_ARRAY, st_a_nasl_var::var_type, and TC::x.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_get_var_by_num()

anon_nasl_var* nasl_get_var_by_num	(	void *	,
		nasl_array *	,
		int	,
		int
	)

Definition at line 46 of file nasl_var.c.

{
  anon_nasl_var *v = NULL;
 
  if (num < 0)
    {
      /* TBD: implement a min_index field, just like $[ in Perl */
      nasl_perror (ctxt, "Negative integer index %d are not supported yet!\n",
                   num);
      return NULL;
    }
 
  if (num < a->max_idx)
    v = a->num_elt[num];
  if (v != NULL || !create)
    return v;
 
  if (num >= a->max_idx)
    {
      a->num_elt = g_realloc (a->num_elt, sizeof (anon_nasl_var *) * (num + 1));
      bzero (a->num_elt + a->max_idx,
             sizeof (anon_nasl_var *) * (num + 1 - a->max_idx));
      a->max_idx = num + 1;
    }
  v = g_malloc0 (sizeof (anon_nasl_var));
  v->var_type = VAR2_UNDEF;
 
  a->num_elt[num] = v;
  return v;
}

References st_nasl_array::max_idx, nasl_perror(), st_nasl_array::num_elt, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by get_array_elem(), nasl_keys(), nasl_make_array(), nasl_make_list(), nasl_max_index(), and nasl_typeof().

Here is the call graph for this function:

Here is the caller graph for this function:

nasl_iterate_array()

tree_cell* nasl_iterate_array

(

nasl_iterator *

)

Definition at line 1205 of file nasl_var.c.

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

References nasl_iterator::a, st_nasl_array::hash_elt, nasl_iterator::i1, nasl_iterator::iH, st_nasl_array::max_idx, st_n_nasl_var::next_var, st_nasl_array::num_elt, st_n_nasl_var::u, nasl_iterator::v, VAR2_UNDEF, var2cell(), VAR_NAME_HASH, and st_a_nasl_var::var_type.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

var2cell()

tree_cell* var2cell

(

anon_nasl_var *

)

Definition at line 171 of file nasl_var.c.

{
  tree_cell *tc = alloc_typed_cell (REF_VAR);
  tc->x.ref_val = v; /* No need to free this later! */
  return tc;
}

References alloc_typed_cell(), TC::ref_val, REF_VAR, and TC::x.

Referenced by get_array_elem(), get_variable_by_name(), nasl_iterate_array(), and var_cmp().

Here is the call graph for this function:

Here is the caller graph for this function:

var2str()

const char* var2str

(

anon_nasl_var *

)

Definition at line 1065 of file nasl_var.c.

 {
   if (v == NULL)
     return NULL;
 
   if (v->string_form)
     return v->string_form;
   switch (v->var_type)
     {
     case VAR2_INT:
       v->string_form = g_strdup_printf ("%ld", v->v.v_int);
       break;
     case VAR2_STRING:
     case VAR2_DATA:
       v->string_form = g_malloc0 (v->v.v_str.s_siz + 1);
       memcpy (v->string_form,
               (char *) v->v.v_str.s_val ? (char *) v->v.v_str.s_val : "",
               v->v.v_str.s_siz + 1);
       break;
     case VAR2_UNDEF:
       break;
     case VAR2_ARRAY:
       v->string_form = array2str (&v->v.v_arr);
       break;
     default:
       v->string_form = g_strdup ("");
       break;
     }
   return v->string_form;
 }

References array2str(), st_nasl_string::s_siz, st_nasl_string::s_val, st_a_nasl_var::string_form, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by dump_tree(), get_str_var_by_name(), get_str_var_by_num(), nasl_make_array(), and nasl_pread().

Here is the call graph for this function:

Here is the caller graph for this function: