#include "nasl_var.h"
#include "exec.h"
#include "nasl_debug.h"
#include "nasl_func.h"
#include "nasl_global_ctxt.h"
#include "nasl_lex_ctxt.h"
#include "nasl_tree.h"
#include <glib.h>
#include <stdlib.h>
#include <string.h>

Include dependency graph for nasl_var.c:

Functions
static void	copy_array (nasl_array , const nasl_array , int)

int	hash_str2 (const char *s, int n)

static int	hash_str (const char *s)

anon_nasl_var *	nasl_get_var_by_num (void ctxt, nasl_array a, int num, int create)

static named_nasl_var *	get_var_by_name (nasl_array a, const char s)

static named_nasl_var *	get_var_ref_by_name (lex_ctxt ctxt, const char name, int climb)
	This function climbs up in the context list.

static anon_nasl_var *	get_var_ref_by_num (lex_ctxt *ctxt, int num)

tree_cell *	var2cell (anon_nasl_var *v)

tree_cell *	get_variable_by_name (lex_ctxt ctxt, const char name)

static const char *	get_var_name (anon_nasl_var *v)

tree_cell *	get_array_elem (lex_ctxt ctxt, const char name, tree_cell *idx)

static void	free_var_chain (named_nasl_var *)

static void	free_anon_var (anon_nasl_var *)

void	free_array (nasl_array *a)

static void	clear_anon_var (anon_nasl_var *v)

static void	copy_anon_var (anon_nasl_var v1, const anon_nasl_var v2)

static anon_nasl_var *	dup_anon_var (const anon_nasl_var *v)

static named_nasl_var *	dup_named_var (const named_nasl_var *v)

tree_cell *	copy_ref_array (const tree_cell *c1)

static tree_cell *	affect_to_anon_var (anon_nasl_var v1, tree_cell rval)

tree_cell *	nasl_affect (tree_cell lval, tree_cell rval)

static named_nasl_var *	create_named_var (const char name, tree_cell val)

static anon_nasl_var *	create_anon_var (tree_cell *val)

tree_cell *	decl_local_variables (lex_ctxt lexic, tree_cell vars)

tree_cell *	decl_global_variables (lex_ctxt lexic, tree_cell vars)

anon_nasl_var *	add_numbered_var_to_ctxt (lex_ctxt lexic, int num, tree_cell val)

named_nasl_var *	add_named_var_to_ctxt (lex_ctxt lexic, const char name, tree_cell *val)

tree_cell *	nasl_read_var_ref (lex_ctxt lexic, tree_cell tc)

tree_cell *	nasl_incr_variable (lex_ctxt lexic, tree_cell tc, int pre, int val)

static long int	var2int (anon_nasl_var *v, int defval)

char *	array2str (const nasl_array *a)

const char *	var2str (anon_nasl_var *v)

long int	get_int_var_by_num (lex_ctxt *lexic, int num, int defval)

long int	get_int_var_by_name (lex_ctxt lexic, const char name, int defval)

char *	get_str_var_by_num (lex_ctxt *lexic, int num)

char *	get_str_var_by_name (lex_ctxt lexic, const char name)

static int	get_var_size (const anon_nasl_var *v)

int	get_var_size_by_name (lex_ctxt lexic, const char name)

int	get_var_size_by_num (lex_ctxt *lexic, int num)

int	get_var_type_by_num (lex_ctxt *lexic, int num)
	Returns NASL variable/cell type, VAR2_UNDEF if value is NULL.

int	get_var_type_by_name (lex_ctxt lexic, const char name)

nasl_iterator	nasl_array_iterator (void ctxt, tree_cell c)

tree_cell *	nasl_iterate_array (nasl_iterator *it)

int	add_var_to_list (nasl_array a, int i, const anon_nasl_var v)

int	add_var_to_array (nasl_array a, char name, const anon_nasl_var *v)

int	array_max_index (nasl_array *a)

tree_cell *	make_array_from_elems (tree_cell *el)

Variables
FILE *	nasl_trace_fp

Function Documentation

◆ add_named_var_to_ctxt()

named_nasl_var * add_named_var_to_ctxt	(	lex_ctxt *	lexic,
		const char *	name,
		tree_cell *	val
	)

Definition at line 813 of file nasl_var.c.

 {
   int h = hash_str (name);
   named_nasl_var *v;
 
   /* Duplicated code ? */
   for (v = lexic->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
     if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
       {
         if (val != NULL)
           nasl_perror (lexic, "Cannot add existing variable %s\n", name);
         return NULL;
       }
   v = create_named_var (name, val);
   if (v == NULL)
     return NULL;
   v->next_var = lexic->ctx_vars.hash_elt[h];
   lexic->ctx_vars.hash_elt[h] = v;
   return v;
 }

References create_named_var(), struct_lex_ctxt::ctx_vars, st_nasl_array::hash_elt, hash_str(), name, nasl_perror(), st_n_nasl_var::next_var, val, and st_n_nasl_var::var_name.

Referenced by decl_local_variables(), exec_nasl_script(), init_nasl_library(), and nasl_func_call().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_numbered_var_to_ctxt()

anon_nasl_var * add_numbered_var_to_ctxt	(	lex_ctxt *	lexic,
		int	num,
		tree_cell *	val
	)

Definition at line 784 of file nasl_var.c.

 {
   anon_nasl_var *v;
   nasl_array *a = &lexic->ctx_vars;
 
   if (a->max_idx > num)
     {
       v = a->num_elt[num];
       if (v != NULL && v->var_type != VAR2_UNDEF)
         {
           if (val != NULL)
             nasl_perror (lexic, "Cannot add existing variable %d\n", num);
           return NULL;
         }
       free_anon_var (a->num_elt[num]);
     }
   else
     {
       a->num_elt =
         g_realloc (a->num_elt, (num + 1) * sizeof (anon_nasl_var *));
       bzero (a->num_elt + a->max_idx,
              sizeof (anon_nasl_var *) * (num + 1 - a->max_idx));
       a->max_idx = num + 1;
     }
   a->num_elt[num] = v = create_anon_var (val);
   return v;
 }

References create_anon_var(), struct_lex_ctxt::ctx_vars, free_anon_var(), st_nasl_array::max_idx, nasl_perror(), st_nasl_array::num_elt, val, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_func_call().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_var_to_array()

int add_var_to_array	(	nasl_array *	a,
		char *	name,
		const anon_nasl_var *	v
	)

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 *	a,
		int	i,
		const anon_nasl_var *	v
	)

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:

◆ affect_to_anon_var()

static tree_cell * affect_to_anon_var	(	anon_nasl_var *	v1,
		tree_cell *	rval
	)

static

Definition at line 554 of file nasl_var.c.

 {
   anon_nasl_var *v2 = NULL, v0;
   nasl_array *a = NULL;
   int t2;
   void *p;
 
   if (v1 == NULL || v1 == FAKE_CELL)
     return NULL;
 
   if (rval == NULL || rval == FAKE_CELL)
     {
       clear_anon_var (v1);
       if (nasl_trace_enabled ())
         nasl_trace (NULL, "NASL> %s <- undef\n", get_var_name (v1));
       return NULL;
     }
 
   switch (rval->type)
     {
     case CONST_INT:
       t2 = VAR2_INT;
       break;
     case CONST_STR:
       t2 = VAR2_STRING;
       break;
     case CONST_DATA:
       t2 = VAR2_DATA;
       break;
 
     case REF_VAR:
       v2 = rval->x.ref_val;
       if (v2 == NULL)
         {
           t2 = 0;
           a = NULL;
           break;
         }
 
       if (v2 == v1)
         return FAKE_CELL;
 
       t2 = v2->var_type;
       if (t2 == VAR2_ARRAY)
         a = &v2->v.v_arr; /* ? */
       break;
 
     case REF_ARRAY:
     case DYN_ARRAY:
       a = rval->x.ref_val;
       t2 = VAR2_ARRAY;
       if (v1->var_type == VAR2_ARRAY && &v1->v.v_arr == a)
         return FAKE_CELL;
       break;
 
     default:
       nasl_perror (NULL, "Cannot affect rvalue 0x%x to variable\n",
                    rval->type);
       return NULL;
     }
 
   /*
    * Bug #146: when executing
    *    x = 'abc'; x = x;  or   x = make_list(...); x = x[0];
    * the rvalue will be freed before it is copied to the lvalue
    */
   v0 = *v1;
 
   /* Bug #146: this fake clear is necessary if we copy an array */
   memset (v1, 0, sizeof (*v1));
   /* Bug #146: no risk with the type, we already copied it */
   v1->var_type = t2;
 
   if (rval->type != REF_VAR && rval->type != REF_ARRAY
       && rval->type != DYN_ARRAY)
     switch (t2)
       {
       case VAR2_INT:
         v1->v.v_int = rval->x.i_val;
         break;
       case VAR2_STRING:
       case VAR2_DATA:
         if (rval->x.str_val == NULL)
           {
             v1->v.v_str.s_val = NULL;
             v1->v.v_str.s_siz = 0;
           }
         else
           {
             p = g_malloc0 (rval->size + 1);
             memcpy (p, rval->x.str_val, rval->size);
             v1->v.v_str.s_siz = rval->size;
             v1->v.v_str.s_val = p;
           }
         break;
       }
   else /* REF_xxx */
     switch (t2)
       {
       case VAR2_INT:
         v1->v.v_int = v2->v.v_int;
         break;
       case VAR2_STRING:
       case VAR2_DATA:
         if (v2->v.v_str.s_val == NULL)
           {
             v1->v.v_str.s_val = NULL;
             v1->v.v_str.s_siz = 0;
           }
         else
           {
             p = g_malloc0 (v2->v.v_str.s_siz + 1);
             memcpy (p, v2->v.v_str.s_val, v2->v.v_str.s_siz);
             v1->v.v_str.s_siz = v2->v.v_str.s_siz;
             v1->v.v_str.s_val = p;
           }
         break;
       case VAR2_ARRAY:
         copy_array (&v1->v.v_arr, a, 1);
         break;
       }
 
   if (nasl_trace_fp != NULL)
     switch (t2)
       {
       case VAR2_INT:
         nasl_trace (NULL, "NASL> %s <- %lu\n", get_var_name (v1), v1->v.v_int);
         break;
       case VAR2_STRING:
       case VAR2_DATA:
         nasl_trace (NULL, "NASL> %s <- \"%s\"\n", get_var_name (v1),
                     v1->v.v_str.s_val);
         break;
       case VAR2_ARRAY:
         nasl_trace (NULL, "NASL> %s <- (VAR2_ARRAY)\n", get_var_name (v1));
         break;
       default:
         nasl_trace (NULL, "NASL> %s <- (Type 0x%x)\n", get_var_name (v1), t2);
         break;
       }
 
   clear_anon_var (&v0);
   return FAKE_CELL;
 }

References clear_anon_var(), CONST_DATA, CONST_INT, CONST_STR, copy_array(), DYN_ARRAY, FAKE_CELL, get_var_name(), TC::i_val, nasl_perror(), nasl_trace(), nasl_trace_enabled(), nasl_trace_fp, REF_ARRAY, TC::ref_val, REF_VAR, 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_arr, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, st_a_nasl_var::var_type, and TC::x.

Referenced by create_anon_var(), create_named_var(), and nasl_affect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ array2str()

char * array2str ( const nasl_array * a )

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_anon_var()

static void clear_anon_var ( anon_nasl_var * v )

static

Definition at line 406 of file nasl_var.c.

 {
   if (v == NULL)
     return;
 
   switch (v->var_type)
     {
     case VAR2_INT:
       v->v.v_int = 0;
       break;
     case VAR2_STRING:
     case VAR2_DATA:
       g_free (v->v.v_str.s_val);
       v->v.v_str.s_val = NULL;
       v->v.v_str.s_siz = 0;
       break;
     case VAR2_ARRAY:
       free_array (&v->v.v_arr);
       break;
     }
   v->var_type = VAR2_UNDEF;
 }

References free_array(), st_nasl_string::s_siz, st_nasl_string::s_val, 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 affect_to_anon_var(), copy_anon_var(), and nasl_incr_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_anon_var()

static void copy_anon_var	(	anon_nasl_var *	v1,
		const anon_nasl_var *	v2
	)

static

Definition at line 430 of file nasl_var.c.

 {
   /* TBD: free variable if necessary? */
   v1->var_type = v2->var_type;
   switch (v2->var_type)
     {
     case VAR2_STRING:
     case VAR2_DATA:
       if (v2->v.v_str.s_val != NULL)
         {
           v1->v.v_str.s_val = g_malloc0 (v2->v.v_str.s_siz + 1);
           memcpy (v1->v.v_str.s_val, v2->v.v_str.s_val, v2->v.v_str.s_siz);
           v1->v.v_str.s_siz = v2->v.v_str.s_siz;
         }
       else
         {
           v1->v.v_str.s_val = NULL;
           v1->v.v_str.s_siz = 0;
         }
       break;
 
     case VAR2_UNDEF:
       break;
 
     case VAR2_INT:
       v1->v.v_int = v2->v.v_int;
       break;
 
     case VAR2_ARRAY:
       copy_array (&v1->v.v_arr, &v2->v.v_arr, 1);
       break;
 
     default:
       nasl_perror (NULL, "copy_anon_var: unhandled type 0x%x\n", v2->var_type);
       clear_anon_var (v1);
     }
 }

References clear_anon_var(), copy_array(), nasl_perror(), st_nasl_string::s_siz, st_nasl_string::s_val, 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 add_var_to_array(), dup_anon_var(), and dup_named_var().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_array()

static void copy_array	(	nasl_array *	a1,
		const nasl_array *	a2,
		int	copy_named
	)

static

Definition at line 496 of file nasl_var.c.

 {
   int i;
   named_nasl_var *v1, *v2, *v;
 
   if (a1 == a2)
     return;
 
   if (a1 == NULL || a2 == NULL)
     {
       nasl_perror (NULL, "Internal inconsistency - null array\n");
       abort ();
     }
 
   free_array (a1);
 
   if (a2->num_elt != NULL)
     {
       a1->max_idx = a2->max_idx;
       a1->num_elt = g_malloc0 (sizeof (anon_nasl_var *) * a2->max_idx);
       for (i = 0; i < a2->max_idx; i++)
         a1->num_elt[i] = dup_anon_var (a2->num_elt[i]);
     }
   if (copy_named && a2->hash_elt != NULL)
     {
       a1->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
       for (i = 0; i < VAR_NAME_HASH; i++)
         {
           v1 = NULL;
           for (v2 = a2->hash_elt[i]; v2 != NULL; v2 = v2->next_var)
             {
               v = dup_named_var (v2);
               v->next_var = v1;
               a1->hash_elt[i] = v;
               v1 = v;
             }
         }
     }
 }

References dup_anon_var(), dup_named_var(), free_array(), st_nasl_array::hash_elt, st_nasl_array::max_idx, nasl_perror(), st_n_nasl_var::next_var, st_nasl_array::num_elt, and VAR_NAME_HASH.

Referenced by affect_to_anon_var(), copy_anon_var(), copy_ref_array(), get_variable_by_name(), and nasl_array_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copy_ref_array()

tree_cell * copy_ref_array ( const tree_cell * c1 )

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:

◆ create_anon_var()

static anon_nasl_var * create_anon_var ( tree_cell * val )

static

Definition at line 743 of file nasl_var.c.

 {
   anon_nasl_var *v = g_malloc0 (sizeof (anon_nasl_var));
   tree_cell *tc;
 
   if (val == NULL || val == FAKE_CELL)
     {
       v->var_type = VAR2_UNDEF;
       return v;
     }
 
   tc = affect_to_anon_var (v, val);
   /* Here we might test the return value */
   deref_cell (tc);
   return v;
 }

References affect_to_anon_var(), deref_cell(), FAKE_CELL, val, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by add_numbered_var_to_ctxt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_named_var()

static named_nasl_var * create_named_var	(	const char *	name,
		tree_cell *	val
	)

static

Definition at line 722 of file nasl_var.c.

 {
   named_nasl_var *v = g_malloc0 (sizeof (named_nasl_var));
   tree_cell *tc;
 
   if (name != NULL)
     v->var_name = g_strdup (name);
 
   if (val == NULL || val == FAKE_CELL)
     {
       v->u.var_type = VAR2_UNDEF;
       return v;
     }
 
   tc = affect_to_anon_var (&v->u, val);
   /* Here we might test the return value */
   deref_cell (tc);
   return v;
 }

References affect_to_anon_var(), deref_cell(), FAKE_CELL, name, st_n_nasl_var::u, val, VAR2_UNDEF, st_n_nasl_var::var_name, and st_a_nasl_var::var_type.

Referenced by add_named_var_to_ctxt().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decl_global_variables()

tree_cell * decl_global_variables	(	lex_ctxt *	lexic,
		tree_cell *	vars
	)

Definition at line 774 of file nasl_var.c.

 {
   lex_ctxt *c = lexic;
 
   while (c->up_ctxt != NULL)
     c = c->up_ctxt;
   return decl_local_variables (c, vars);
 }

References decl_local_variables(), and struct_lex_ctxt::up_ctxt.

Referenced by nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decl_local_variables()

tree_cell * decl_local_variables	(	lex_ctxt *	lexic,
		tree_cell *	vars
	)

Definition at line 761 of file nasl_var.c.

 {
   tree_cell *t;
 
   for (t = vars; t != NULL; t = t->link[0])
     if (t->x.str_val == NULL)
       nasl_perror (lexic, "decl_local_variables: null name!\n");
     else
       add_named_var_to_ctxt (lexic, t->x.str_val, NULL);
   return FAKE_CELL;
 }

References add_named_var_to_ctxt(), FAKE_CELL, TC::link, nasl_perror(), TC::str_val, and TC::x.

Referenced by decl_global_variables(), and nasl_exec().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dup_anon_var()

static anon_nasl_var * dup_anon_var ( const anon_nasl_var * v )

static

Definition at line 469 of file nasl_var.c.

 {
   anon_nasl_var *v1;
 
   if (v == NULL)
     return NULL;
 
   v1 = g_malloc0 (sizeof (anon_nasl_var));
   copy_anon_var (v1, v);
   return v1;
 }

References copy_anon_var().

Referenced by add_var_to_list(), and copy_array().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dup_named_var()

static named_nasl_var * dup_named_var ( const named_nasl_var * v )

static

Definition at line 482 of file nasl_var.c.

 {
   named_nasl_var *v1;
 
   if (v == NULL)
     return NULL;
 
   v1 = g_malloc0 (sizeof (named_nasl_var));
   copy_anon_var (&v1->u, &v->u);
   v1->var_name = g_strdup (v->var_name);
   return v1;
 }

References copy_anon_var(), st_n_nasl_var::u, and st_n_nasl_var::var_name.

Referenced by copy_array().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_anon_var()

static void free_anon_var ( anon_nasl_var * v )

static

Definition at line 387 of file nasl_var.c.

 {
   if (v == NULL)
     return;
   switch (v->var_type)
     {
     case VAR2_STRING:
     case VAR2_DATA:
       g_free (v->v.v_str.s_val);
       break;
     case VAR2_ARRAY:
       free_array (&v->v.v_arr);
       break;
     }
   g_free (v->string_form);
   g_free (v);
 }

References free_array(), 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_str, VAR2_ARRAY, VAR2_DATA, VAR2_STRING, and st_a_nasl_var::var_type.

Referenced by add_numbered_var_to_ctxt(), add_var_to_list(), and free_array().

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:

◆ free_var_chain()

static void free_var_chain ( named_nasl_var * v )

static

Definition at line 366 of file nasl_var.c.

 {
   if (v == NULL)
     return;
   free_var_chain (v->next_var);
   g_free (v->var_name);
   switch (v->u.var_type)
     {
     case VAR2_STRING:
     case VAR2_DATA:
       g_free (v->u.v.v_str.s_val);
       break;
     case VAR2_ARRAY:
       free_array (&v->u.v.v_arr);
       break;
     }
   g_free (v->u.string_form);
   g_free (v);
 }

References free_array(), free_var_chain(), st_n_nasl_var::next_var, st_nasl_string::s_val, st_a_nasl_var::string_form, st_n_nasl_var::u, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_STRING, st_n_nasl_var::var_name, and st_a_nasl_var::var_type.

Referenced by free_array(), and free_var_chain().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_array_elem()

tree_cell * get_array_elem	(	lex_ctxt *	ctxt,
		const char *	name,
		tree_cell *	idx
	)

Definition at line 211 of file nasl_var.c.

 {
   named_nasl_var *nv;
   anon_nasl_var *u, *av, fake_var;
   tree_cell *tc, idx0;
 
   /* Fake variable */
   if (strcmp (name, "_FCT_ANON_ARGS") == 0)
     {
       lex_ctxt *c;
       for (c = ctxt; c != NULL && !c->fct_ctxt; c = c->up_ctxt)
         ;
       if (c == NULL)
         return NULL;
       fake_var.var_type = VAR2_ARRAY;
       fake_var.v.v_arr = c->ctx_vars;
       fake_var.v.v_arr.hash_elt = NULL; /* mask named elements */
       u = &fake_var;
     }
   else
     {
       named_nasl_var *v = get_var_ref_by_name (ctxt, name, 1);
       u = &v->u;
     }
 
   if (idx == NULL)
     {
       /* Treat it as zero */
       memset (&idx0, '\0', sizeof (idx0));
       idx = &idx0;
       idx->type = CONST_INT;
     }
 
   switch (u->var_type)
     {
     case VAR2_UNDEF:
       /* We define the array here */
       u->var_type = VAR2_ARRAY;
       /* fallthrough */
     case VAR2_ARRAY:
       switch (idx->type)
         {
         case CONST_INT:
           av = nasl_get_var_by_num (ctxt, &u->v.v_arr, idx->x.i_val,
                                     /* avoid dangling pointers */
                                     strcmp (name, "_FCT_ANON_ARGS"));
           return var2cell (av);
 
         case CONST_STR:
         case CONST_DATA:
           nv = get_var_by_name (&u->v.v_arr, idx->x.str_val);
           return var2cell (nv != NULL ? &nv->u : NULL);
 
         default:
           nasl_perror (ctxt,
                        "get_array_elem: unhandled index type 0x%x for "
                        "variable %s\n",
                        idx->type, name);
           return NULL;
         }
       /*NOTREACHED*/ break;
 
     case VAR2_INT:
       nasl_perror (ctxt, "get_array_elem: variable %s is an integer\n", name);
       return NULL;
 
     case VAR2_STRING:
     case VAR2_DATA:
       if (idx->type == CONST_INT)
         {
           int l = u->v.v_str.s_siz;
 
           if (idx->x.i_val >= l)
             {
               nasl_perror (ctxt,
                            "get_array_elem: requesting character after end "
                            "of string %s (%d >= %d)\n",
                            name, idx->x.i_val, l);
               tc = alloc_expr_cell (idx->line_nb, CONST_DATA /*CONST_STR */,
                                     NULL, NULL);
               tc->x.str_val = g_strdup ("");
               tc->size = 0;
               return tc;
             }
           else
             {
               if (idx->x.i_val < 0)
                 {
                   nasl_perror (ctxt,
                                "get_array_elem: Negative index (%d) passed to "
                                "\"%s\"!\n",
                                idx->x.i_val, name);
                   return NULL;
                 }
               tc = alloc_expr_cell (idx->line_nb, CONST_DATA /*CONST_STR */,
                                     NULL, NULL);
               tc->x.str_val = g_malloc0 (2);
               tc->x.str_val[0] = u->v.v_str.s_val[idx->x.i_val];
               tc->x.str_val[1] = '\0';
               tc->size = 1;
               return tc;
             }
         }
       else
         {
           nasl_perror (ctxt,
                        "get_array_elem: Cannot use a non integer index"
                        " (type 0x%x) in string. Variable: %s\n",
                        idx->type, name);
           return NULL;
         }
       /*NOTREACHED*/ break;
 
     default:
       nasl_perror (ctxt, "Severe bug: unknown variable type 0x%x %s\n",
                    u->var_type, get_line_nb (idx));
       return NULL;
     }
   /*NOTREACHED*/ return NULL;
 }

References alloc_expr_cell(), CONST_DATA, CONST_INT, CONST_STR, struct_lex_ctxt::ctx_vars, struct_lex_ctxt::fct_ctxt, get_line_nb(), get_var_by_name(), get_var_ref_by_name(), st_nasl_array::hash_elt, TC::i_val, TC::line_nb, name, nasl_get_var_by_num(), nasl_perror(), st_nasl_string::s_siz, st_nasl_string::s_val, TC::size, TC::str_val, TC::type, st_n_nasl_var::u, struct_lex_ctxt::up_ctxt, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, var2cell(), 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:

◆ get_int_var_by_name()

long int get_int_var_by_name	(	lex_ctxt *	lexic,
		const char *	name,
		int	defval
	)

Definition at line 1104 of file nasl_var.c.

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

References get_var_ref_by_name(), name, st_n_nasl_var::u, and var2int().

Referenced by __attribute__(), _http_req(), crypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ip_v6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_port_transport(), get_tcp_option(), get_tcp_v6_option(), insert_ip_options(), nasl_bn_random(), nasl_close_stream_cipher(), nasl_crap(), nasl_dec2str(), nasl_egrep(), nasl_ereg(), nasl_ereg_replace(), nasl_eregmatch(), nasl_file_read(), nasl_file_seek(), nasl_file_write(), nasl_forge_frame(), nasl_ftp_get_pasv_address(), nasl_ftp_log_in(), nasl_get_sign(), nasl_get_sock_info(), nasl_isotime_add(), nasl_localtime(), nasl_match(), nasl_mktime(), nasl_ntlm_response(), nasl_ntlmv2_hash(), nasl_ntlmv2_response(), nasl_open_privileged_socket(), nasl_open_sock_tcp_bufsz(), nasl_pcap_next(), nasl_pread(), nasl_prf(), nasl_rc4_encrypt(), nasl_recv(), nasl_recv_line(), nasl_rsa_private_decrypt(), nasl_rsa_public_encrypt(), nasl_same_host(), nasl_scanner_add_port(), nasl_send(), nasl_send_arp_request(), nasl_send_capture(), nasl_send_frame(), nasl_send_packet(), nasl_send_v6packet(), nasl_smb3kdf(), nasl_smb_close(), nasl_smb_file_group_sid(), nasl_smb_file_owner_sid(), nasl_smb_file_SDDL(), nasl_smb_file_trustee_rights(), nasl_snmpv1v2c_get(), nasl_snmpv3_get_action(), nasl_socket_cert_verify(), nasl_socket_check_ssl_safe_renegotiation(), nasl_socket_get_cert(), nasl_socket_get_ssl_ciphersuite(), nasl_socket_get_ssl_session_id(), nasl_socket_get_ssl_version(), nasl_socket_negotiate_ssl(), nasl_socket_ssl_do_handshake(), nasl_split(), nasl_ssh_connect(), nasl_ssh_request_exec(), nasl_ssh_shell_open(), nasl_ssh_shell_read(), nasl_str_replace(), nasl_tcp_ping(), nasl_tcp_v6_ping(), nasl_wmi_close(), nasl_wmi_query(), nasl_wmi_query_rsop(), nasl_wmi_reg_create_key(), nasl_wmi_reg_delete_key(), nasl_wmi_reg_enum_key(), nasl_wmi_reg_enum_value(), nasl_wmi_reg_get_bin_val(), nasl_wmi_reg_get_dword_val(), nasl_wmi_reg_get_ex_string_val(), nasl_wmi_reg_get_mul_string_val(), nasl_wmi_reg_get_qword_val(), nasl_wmi_reg_get_sz(), nasl_wmi_reg_set_dword_val(), nasl_wmi_reg_set_ex_string_val(), nasl_wmi_reg_set_qword_val(), nasl_wmi_reg_set_string_val(), replace_kb_item(), script_add_preference(), script_get_preference(), security_something(), set_ip_elements(), set_ip_v6_elements(), set_kb_item(), set_kb_item_volatile(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

Here is the call graph for this function:

◆ get_int_var_by_num()

long int get_int_var_by_num	(	lex_ctxt *	lexic,
		int	num,
		int	defval
	)

Definition at line 1097 of file nasl_var.c.

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

References get_var_ref_by_num(), and var2int().

Referenced by get_kb_item(), get_port_state(), get_port_transport(), get_udp_port_state(), insert_tcp_options(), insert_tcp_v6_options(), nasl_close_socket(), nasl_crap(), nasl_do_exit(), nasl_file_close(), nasl_get_sock_info(), nasl_get_source_port(), nasl_hex(), nasl_insstr(), nasl_int(), nasl_localtime(), nasl_open_sock_tcp_bufsz(), nasl_open_sock_udp(), nasl_rawstring(), nasl_scanner_get_port(), nasl_sftp_enabled_check(), nasl_sleep(), nasl_socket_get_error(), nasl_ssh_disconnect(), nasl_ssh_get_auth_methods(), nasl_ssh_get_host_key(), nasl_ssh_get_issue_banner(), nasl_ssh_get_server_banner(), nasl_ssh_get_sock(), nasl_ssh_login_interactive(), nasl_ssh_login_interactive_pass(), nasl_ssh_request_exec(), nasl_ssh_session_id_from_sock(), nasl_ssh_set_login(), nasl_ssh_shell_close(), nasl_ssh_shell_open(), nasl_ssh_shell_read(), nasl_ssh_shell_write(), nasl_ssh_userauth(), nasl_stridx(), nasl_substr(), nasl_telnet_init(), nasl_usleep(), script_category(), script_timeout(), and security_something().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_str_var_by_name()

char * get_str_var_by_name	(	lex_ctxt *	lexic,
		const char *	name
	)

Definition at line 1118 of file nasl_var.c.

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

References get_var_ref_by_name(), name, st_n_nasl_var::u, and var2str().

Here is the call graph for this function:

◆ get_str_var_by_num()

char * get_str_var_by_num	(	lex_ctxt *	lexic,
		int	num
	)

Definition at line 1111 of file nasl_var.c.

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

References get_var_ref_by_num(), and var2str().

Referenced by __attribute__(), dump_icmp_packet(), dump_icmp_v6_packet(), dump_ip_v6_packet(), dump_tcp_packet(), dump_tcp_v6_packet(), dump_udp_packet(), dump_udp_v6_packet(), get_kb_item(), get_kb_list(), nasl_chomp(), nasl_cipher_des(), nasl_defined_func(), nasl_file_stat(), nasl_find_in_path(), nasl_fread(), nasl_get_local_mac_address_from_ip(), nasl_get_preference(), nasl_get_sock_info(), nasl_hash(), nasl_hexstr(), nasl_insstr(), nasl_isotime_add(), nasl_isotime_is_valid(), nasl_isotime_print(), nasl_isotime_scan(), nasl_join_multicast_group(), nasl_leave_multicast_group(), nasl_lm_owf_gen(), nasl_nt_owf_gen(), nasl_ord(), nasl_rawstring(), nasl_same_host(), nasl_send_packet(), nasl_send_v6packet(), nasl_split(), nasl_strcat(), nasl_stridx(), nasl_string(), nasl_strstr(), nasl_substr(), nasl_tolower(), nasl_toupper(), nasl_unlink(), script_cve_id(), script_dependencies(), script_exclude_keys(), script_family(), script_get_preference(), script_get_preference_file_content(), script_get_preference_file_location(), script_mandatory_keys(), script_name(), script_oid(), script_require_keys(), script_require_ports(), and script_require_udp_ports().

Here is the call graph for this function:

◆ get_var_by_name()

static named_nasl_var * get_var_by_name	(	nasl_array *	a,
		const char *	s
	)

static

Definition at line 78 of file nasl_var.c.

{
  int h = hash_str (s);
  named_nasl_var *v;
 
  if (a->hash_elt == NULL)
    a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
 
  for (v = a->hash_elt[h]; v != NULL; v = v->next_var)
    if (v->var_name != NULL && strcmp (s, v->var_name) == 0)
      return v;
 
  v = g_malloc0 (sizeof (named_nasl_var));
  v->var_name = g_strdup (s);
  v->u.var_type = VAR2_UNDEF;
  v->next_var = a->hash_elt[h];
 
  a->hash_elt[h] = v;
  return v;
}

References st_nasl_array::hash_elt, hash_str(), 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_array_elem().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_var_name()

static const char * get_var_name ( anon_nasl_var * v )

static

Definition at line 199 of file nasl_var.c.

 {
   static char str[16];
#ifdef ALL_VARIABLES_NAMED
   if (v->av_name != NULL)
     return v->av_name;
#endif
   snprintf (str, sizeof (str), "[%p]", (void *) v);
   return str;
 }

Referenced by affect_to_anon_var(), and nasl_read_var_ref().

Here is the caller graph for this function:

◆ get_var_ref_by_name()

static named_nasl_var * get_var_ref_by_name	(	lex_ctxt *	ctxt,
		const char *	name,
		int	climb
	)

static

This function climbs up in the context list.

Definition at line 103 of file nasl_var.c.

{
  named_nasl_var *v;
  int h = hash_str (name);
  lex_ctxt *c;
 
  if (!ctxt)
    return NULL;
  if (climb != 0)
    {
      for (c = ctxt; c != NULL; c = c->up_ctxt)
        if (c->ctx_vars.hash_elt != NULL)
          for (v = c->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
            if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
              return v;
    }
  else
    {
      if (ctxt->ctx_vars.hash_elt != NULL)
        for (v = ctxt->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
          if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
            return v;
    }
 
  if (ctxt->ctx_vars.hash_elt == NULL)
    ctxt->ctx_vars.hash_elt =
      g_malloc0 (sizeof (named_nasl_var *) * VAR_NAME_HASH);
 
  v = g_malloc0 (sizeof (named_nasl_var));
  v->var_name = g_strdup (name);
  v->u.var_type = VAR2_UNDEF;
  v->next_var = ctxt->ctx_vars.hash_elt[h];
  ctxt->ctx_vars.hash_elt[h] = v;
 
  return v;
}

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

Referenced by get_array_elem(), get_int_var_by_name(), get_str_var_by_name(), get_var_size_by_name(), get_var_type_by_name(), and get_variable_by_name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_var_ref_by_num()

static anon_nasl_var * get_var_ref_by_num	(	lex_ctxt *	ctxt,
		int	num
	)

static

Definition at line 141 of file nasl_var.c.

{
  anon_nasl_var *v;
 
  if (num < 0) /* safer */
    {
      nasl_perror (ctxt, "Negative index %d is invalid for array\n", num);
      return NULL;
    }
 
  if (ctxt->ctx_vars.max_idx <= num)
    {
      ctxt->ctx_vars.num_elt = g_realloc (ctxt->ctx_vars.num_elt,
                                          sizeof (anon_nasl_var *) * (num + 1));
      bzero (ctxt->ctx_vars.num_elt + ctxt->ctx_vars.max_idx,
             sizeof (anon_nasl_var *) * (num + 1 - ctxt->ctx_vars.max_idx));
      ctxt->ctx_vars.max_idx = num + 1;
    }
 
  v = ctxt->ctx_vars.num_elt[num];
  if (v != NULL)
    return v;
 
  v = g_malloc0 (sizeof (anon_nasl_var));
  v->var_type = VAR2_UNDEF;
  ctxt->ctx_vars.num_elt[num] = v;
  return v;
}

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

Referenced by get_int_var_by_num(), get_str_var_by_num(), get_var_size_by_num(), and get_var_type_by_num().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_var_size()

static int get_var_size ( const anon_nasl_var * v )

static

Definition at line 1124 of file nasl_var.c.

 {
   if (v == NULL)
     return 0;
   switch (v->var_type)
     {
     case VAR2_DATA:
     case VAR2_STRING:
       return v->v.v_str.s_siz;
     }
   return 0;
 }

References st_nasl_string::s_siz, st_a_nasl_var::v, st_a_nasl_var::v_str, VAR2_DATA, VAR2_STRING, and st_a_nasl_var::var_type.

Referenced by get_var_size_by_name(), and get_var_size_by_num().

Here is the caller graph for this function:

◆ get_var_size_by_name()

int get_var_size_by_name	(	lex_ctxt *	lexic,
		const char *	name
	)

Definition at line 1138 of file nasl_var.c.

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

References get_var_ref_by_name(), get_var_size(), name, and st_n_nasl_var::u.

Referenced by __attribute__(), crypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ip_v6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_icmp_element(), get_icmp_v6_element(), get_tcp_element(), get_tcp_option(), get_tcp_v6_element(), get_tcp_v6_option(), get_udp_element(), get_udp_v6_element(), insert_ip_options(), insert_tcp_options(), insert_tcp_v6_options(), mpi_from_named_parameter(), nasl_bf_cbc(), nasl_crap(), nasl_dump_frame(), nasl_egrep(), nasl_ereg(), nasl_ereg_replace(), nasl_eregmatch(), nasl_file_write(), nasl_forge_frame(), nasl_fwrite(), nasl_gunzip(), nasl_gzip(), nasl_hmac(), nasl_hmac_sha256(), nasl_insert_hexzeros(), nasl_load_privkey_param(), nasl_mac(), nasl_ntlm2_response(), nasl_ntlm_response(), nasl_ntlmv1_hash(), nasl_ntlmv2_hash(), nasl_ntv2_owf_gen(), nasl_open_stream_cipher(), nasl_prf(), nasl_rsa_sign(), nasl_send(), nasl_send_frame(), nasl_smb3kdf(), nasl_smb_sign(), nasl_split(), nasl_str_replace(), replace_kb_item(), security_something(), set_ip_elements(), set_ip_v6_elements(), set_kb_item(), set_kb_item_volatile(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

Here is the call graph for this function:

◆ get_var_size_by_num()

int get_var_size_by_num	(	lex_ctxt *	lexic,
		int	num
	)

Definition at line 1145 of file nasl_var.c.

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

References get_var_ref_by_num(), and get_var_size().

Referenced by dump_icmp_v6_packet(), dump_tcp_packet(), dump_tcp_v6_packet(), dump_udp_packet(), dump_udp_v6_packet(), nasl_cipher_des(), nasl_hash(), nasl_hexstr(), nasl_insstr(), nasl_isotime_add(), nasl_isotime_is_valid(), nasl_isotime_print(), nasl_isotime_scan(), nasl_lm_owf_gen(), nasl_rawstring(), nasl_send_packet(), nasl_send_v6packet(), nasl_split(), nasl_strcat(), nasl_stridx(), nasl_string(), nasl_strlen(), nasl_strstr(), nasl_substr(), nasl_tolower(), and nasl_toupper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_var_type_by_name()

int get_var_type_by_name	(	lex_ctxt *	lexic,
		const char *	name
	)

Definition at line 1162 of file nasl_var.c.

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

References get_var_ref_by_name(), name, st_n_nasl_var::u, VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_open_sock_tcp_bufsz(), nasl_rsa_private_decrypt(), nasl_rsa_public_encrypt(), replace_kb_item(), set_kb_item(), and set_kb_item_volatile().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_var_type_by_num()

int get_var_type_by_num	(	lex_ctxt *	lexic,
		int	num
	)

Returns NASL variable/cell type, VAR2_UNDEF if value is NULL.

Definition at line 1155 of file nasl_var.c.

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

References get_var_ref_by_num(), VAR2_UNDEF, and st_a_nasl_var::var_type.

Referenced by nasl_get_sock_info(), nasl_isnull(), nasl_isotime_is_valid(), nasl_isotime_scan(), nasl_rawstring(), nasl_string(), and nasl_substr().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_variable_by_name()

tree_cell * get_variable_by_name	(	lex_ctxt *	ctxt,
		const char *	name
	)

Definition at line 179 of file nasl_var.c.

{
  if (name == NULL)
    return NULL;
  /* Broken: Need also code in get_array_elem */
  if (strcmp (name, "_FCT_ANON_ARGS") == 0)
    {
      tree_cell *retc = alloc_typed_cell (DYN_ARRAY);
      nasl_array *a = retc->x.ref_val = g_malloc0 (sizeof (nasl_array));
      copy_array (a, &ctxt->ctx_vars, 0);
      return retc;
    }
  else
    {
      named_nasl_var *v = get_var_ref_by_name (ctxt, name, 1);
      return var2cell (&v->u);
    }
 /*NOTREACHED*/}

References alloc_typed_cell(), copy_array(), struct_lex_ctxt::ctx_vars, DYN_ARRAY, get_var_ref_by_name(), name, TC::ref_val, st_n_nasl_var::u, var2cell(), and TC::x.

Referenced by nasl_exec(), and nasl_pread().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hash_str()

static int hash_str ( const char * s )

static

Definition at line 40 of file nasl_var.c.

{
  return hash_str2 (s, VAR_NAME_HASH);
}

References hash_str2(), and VAR_NAME_HASH.

Referenced by add_named_var_to_ctxt(), add_var_to_array(), get_var_by_name(), and get_var_ref_by_name().

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 *	lval,
		tree_cell *	rval
	)

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 *	ctxt,
		tree_cell *	c
	)

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 *	ctxt,
		nasl_array *	a,
		int	num,
		int	create
	)

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_incr_variable()

tree_cell * nasl_incr_variable	(	lex_ctxt *	lexic,
		tree_cell *	tc,
		int	pre,
		int	val
	)

Definition at line 922 of file nasl_var.c.

 {
   anon_nasl_var *v;
   int old_val = 0, new_val;
   tree_cell *retc;
 
   if (tc->type != REF_VAR)
     {
       nasl_perror (
         lexic, "nasl_incr_variable: argument (type=%d) is not REF_VAR %s\n",
         tc->type, get_line_nb (tc));
       return NULL;
     }
 
   v = tc->x.ref_val;
 
   switch (v->var_type)
     {
     case VAR2_INT:
       old_val = v->v.v_int;
       break;
     case VAR2_STRING:
     case VAR2_DATA:
       old_val =
         v->v.v_str.s_val == NULL ? 0 : atoi ((char *) v->v.v_str.s_val);
       break;
     case VAR2_UNDEF:
       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_typed_cell (CONST_INT);
   retc->x.i_val = pre ? new_val : old_val;
 
   return retc;
 }

References alloc_typed_cell(), clear_anon_var(), CONST_INT, get_line_nb(), TC::i_val, nasl_perror(), TC::ref_val, REF_VAR, st_nasl_string::s_val, TC::type, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, val, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, 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_iterate_array()

tree_cell * nasl_iterate_array ( nasl_iterator * it )

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:

◆ nasl_read_var_ref()

tree_cell * nasl_read_var_ref	(	lex_ctxt *	lexic,
		tree_cell *	tc
	)

Definition at line 835 of file nasl_var.c.

 {
   tree_cell *ret;
   anon_nasl_var *v;
 
   if (tc == NULL || tc == FAKE_CELL)
     {
       nasl_perror (lexic,
                    "nasl_read_var_ref: cannot read NULL or FAKE cell\n");
       return NULL;
     }
   if (tc->type != REF_VAR)
     {
       nasl_perror (lexic,
                    "nasl_read_var_ref: argument (type=%d) is not REF_VAR %s\n",
                    tc->type, get_line_nb (tc));
       return NULL;
     }
 
   v = tc->x.ref_val;
   if (v == NULL)
     return NULL;
 
   ret = alloc_typed_cell (NODE_EMPTY);
   ret->line_nb = tc->line_nb;
 
   switch (v->var_type)
     {
     case VAR2_INT:
       ret->type = CONST_INT;
       ret->x.i_val = v->v.v_int;
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> %lu\n", get_var_name (v),
                     ret->x.i_val);
       return ret;
 
     case VAR2_STRING:
       ret->type = CONST_STR;
       /* Fix bad string length */
       if (v->v.v_str.s_siz <= 0 && v->v.v_str.s_val[0] != '\0')
         {
           v->v.v_str.s_siz = strlen ((char *) v->v.v_str.s_val);
           nasl_perror (lexic, "nasl_read_var_ref: Bad string length fixed\n");
         }
       /* fallthrough */
     case VAR2_DATA:
       ret->type = v->var_type == VAR2_STRING ? CONST_STR : CONST_DATA;
       if (v->v.v_str.s_val == NULL)
         {
           ret->x.str_val = NULL;
           ret->size = 0;
         }
       else
         {
           ret->x.str_val = g_malloc0 (v->v.v_str.s_siz + 1);
           memcpy (ret->x.str_val, v->v.v_str.s_val, v->v.v_str.s_siz);
           ret->size = v->v.v_str.s_siz;
         }
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> \"%s\"\n", get_var_name (v),
                     ret->x.str_val);
       return ret;
 
     case VAR2_ARRAY:
       ret->type = REF_ARRAY;
       ret->x.ref_val = &v->v.v_arr;
       return ret;
 
     case VAR2_UNDEF:
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> undef\n", get_var_name (v),
                     v->var_type);
       break;
 
     default:
       nasl_perror (lexic, "nasl_read_var_ref: unhandled variable type %d\n",
                    v->var_type);
       if (nasl_trace_enabled ())
         nasl_trace (lexic, "NASL> %s -> ???? (Var type %d)\n",
                     get_var_name (v), v->var_type);
       break;
     }
   deref_cell (ret);
   return NULL;
 }

References alloc_typed_cell(), CONST_DATA, CONST_INT, CONST_STR, deref_cell(), FAKE_CELL, get_line_nb(), get_var_name(), TC::i_val, TC::line_nb, nasl_perror(), nasl_trace(), nasl_trace_enabled(), NODE_EMPTY, REF_ARRAY, TC::ref_val, REF_VAR, 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_arr, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_DATA, VAR2_INT, VAR2_STRING, VAR2_UNDEF, 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:

◆ var2cell()

tree_cell * var2cell ( anon_nasl_var * v )

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:

◆ var2int()

static long int var2int	(	anon_nasl_var *	v,
		int	defval
	)

static

Definition at line 971 of file nasl_var.c.

 {
   if (v == NULL)
     return defval;
 
   switch (v->var_type)
     {
     case VAR2_INT:
       return v->v.v_int;
 
     case VAR2_STRING:
     case VAR2_DATA:
       return atol ((char *) v->v.v_str.s_val);
 
     case VAR2_UNDEF:
     case VAR2_ARRAY:
     default:
       return defval;
     }
 /*NOTREACHED*/}

References st_nasl_string::s_val, st_a_nasl_var::v, 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 get_int_var_by_name(), and get_int_var_by_num().

Here is the caller graph for this function:

◆ var2str()

const char * var2str ( anon_nasl_var * v )

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:

Variable Documentation

◆ nasl_trace_fp

FILE* nasl_trace_fp

extern

Definition at line 357 of file exec.c.

Referenced by affect_to_anon_var(), and nasl_exec().

Functions

Variables

Function Documentation

◆ add_named_var_to_ctxt()

◆ add_numbered_var_to_ctxt()

◆ add_var_to_array()

◆ add_var_to_list()

◆ affect_to_anon_var()

◆ array2str()

◆ array_max_index()

◆ clear_anon_var()

◆ copy_anon_var()

◆ copy_array()

◆ copy_ref_array()

◆ create_anon_var()

◆ create_named_var()

◆ decl_global_variables()

◆ decl_local_variables()

◆ dup_anon_var()

◆ dup_named_var()

◆ free_anon_var()

◆ free_array()

◆ free_var_chain()

◆ get_array_elem()

◆ get_int_var_by_name()

◆ get_int_var_by_num()

◆ get_str_var_by_name()

◆ get_str_var_by_num()

◆ get_var_by_name()

◆ get_var_name()

◆ get_var_ref_by_name()

◆ get_var_ref_by_num()

◆ get_var_size()

◆ get_var_size_by_name()

◆ get_var_size_by_num()

◆ get_var_type_by_name()

◆ get_var_type_by_num()

◆ get_variable_by_name()

◆ hash_str()

◆ hash_str2()

◆ make_array_from_elems()

◆ nasl_affect()

◆ nasl_array_iterator()

◆ nasl_get_var_by_num()

◆ nasl_incr_variable()

◆ nasl_iterate_array()

◆ nasl_read_var_ref()

◆ var2cell()

◆ var2int()

◆ var2str()

Variable Documentation

◆ nasl_trace_fp