OpenVAS Scanner  7.0.1~git
nasl_var.c File Reference
#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:

Go to the source code of this file.

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_varnasl_get_var_by_num (void *ctxt, nasl_array *a, int num, int create)
 
static named_nasl_varget_var_by_name (nasl_array *a, const char *s)
 
static named_nasl_varget_var_ref_by_name (lex_ctxt *ctxt, const char *name, int climb)
 This function climbs up in the context list. More...
 
static anon_nasl_varget_var_ref_by_num (lex_ctxt *ctxt, int num)
 
tree_cellvar2cell (anon_nasl_var *v)
 
tree_cellget_variable_by_name (lex_ctxt *ctxt, const char *name)
 
static const char * get_var_name (anon_nasl_var *v)
 
tree_cellget_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)
 
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_vardup_anon_var (const anon_nasl_var *v)
 
static named_nasl_vardup_named_var (const named_nasl_var *v)
 
tree_cellcopy_ref_array (const tree_cell *c1)
 
static tree_cellaffect_to_anon_var (anon_nasl_var *v1, tree_cell *rval)
 
tree_cellnasl_affect (tree_cell *lval, tree_cell *rval)
 
static named_nasl_varcreate_named_var (const char *name, tree_cell *val)
 
static anon_nasl_varcreate_anon_var (tree_cell *val)
 
tree_celldecl_local_variables (lex_ctxt *lexic, tree_cell *vars)
 
tree_celldecl_global_variables (lex_ctxt *lexic, tree_cell *vars)
 
anon_nasl_varadd_numbered_var_to_ctxt (lex_ctxt *lexic, int num, tree_cell *val)
 
named_nasl_varadd_named_var_to_ctxt (lex_ctxt *lexic, const char *name, tree_cell *val)
 
tree_cellnasl_read_var_ref (lex_ctxt *lexic, tree_cell *tc)
 
tree_cellnasl_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. More...
 
int get_var_type_by_name (lex_ctxt *lexic, const char *name)
 
nasl_iterator nasl_array_iterator (void *ctxt, tree_cell *c)
 
tree_cellnasl_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_cellmake_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 825 of file nasl_var.c.

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

826  {
827  int h = hash_str (name);
828  named_nasl_var *v;
829 
830  /* Duplicated code ? */
831  for (v = lexic->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
832  if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
833  {
834  if (val != NULL)
835  nasl_perror (lexic, "Cannot add existing variable %s\n", name);
836  return NULL;
837  }
838  v = create_named_var (name, val);
839  if (v == NULL)
840  return NULL;
841  v->next_var = lexic->ctx_vars.hash_elt[h];
842  lexic->ctx_vars.hash_elt[h] = v;
843  return v;
844  }
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
char * var_name
Definition: nasl_var.h:69
const char * val
Definition: nasl_init.c:378
static named_nasl_var * create_named_var(const char *name, tree_cell *val)
Definition: nasl_var.c:734
static int hash_str(const char *s)
Definition: nasl_var.c:52
const char * name
Definition: nasl_init.c:377
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
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 796 of file nasl_var.c.

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

797  {
798  anon_nasl_var *v;
799  nasl_array *a = &lexic->ctx_vars;
800 
801  if (a->max_idx > num)
802  {
803  v = a->num_elt[num];
804  if (v != NULL && v->var_type != VAR2_UNDEF)
805  {
806  if (val != NULL)
807  nasl_perror (lexic, "Cannot add existing variable %d\n", num);
808  return NULL;
809  }
810  free_anon_var (a->num_elt[num]);
811  }
812  else
813  {
814  a->num_elt =
815  g_realloc (a->num_elt, (num + 1) * sizeof (anon_nasl_var *));
816  bzero (a->num_elt + a->max_idx,
817  sizeof (anon_nasl_var *) * (num + 1 - a->max_idx));
818  a->max_idx = num + 1;
819  }
820  a->num_elt[num] = v = create_anon_var (val);
821  return v;
822  }
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
static void free_anon_var(anon_nasl_var *)
Definition: nasl_var.c:399
const char * val
Definition: nasl_init.c:378
static anon_nasl_var * create_anon_var(tree_cell *val)
Definition: nasl_var.c:755
int var_type
Definition: nasl_var.h:52
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
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 1286 of file nasl_var.c.

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(), make_array_from_elems(), nasl_localtime(), and nasl_make_array().

1287  {
1288  named_nasl_var *v2;
1289  int h = hash_str (name);
1290 
1291  if (a->hash_elt == NULL)
1292  {
1293  a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
1294  }
1295 
1296  v2 = g_malloc0 (sizeof (named_nasl_var));
1297  v2->var_name = g_strdup (name);
1298  v2->u.var_type = VAR2_UNDEF;
1299  v2->next_var = a->hash_elt[h];
1300  a->hash_elt[h] = v2;
1301 
1302  copy_anon_var (&(v2->u), v);
1303  return 0;
1304  }
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
char * var_name
Definition: nasl_var.h:69
static void copy_anon_var(anon_nasl_var *v1, const anon_nasl_var *v2)
Definition: nasl_var.c:442
struct st_a_nasl_var u
Definition: nasl_var.h:67
int var_type
Definition: nasl_var.h:52
#define VAR_NAME_HASH
Definition: nasl_var.h:33
static int hash_str(const char *s)
Definition: nasl_var.c:52
const char * name
Definition: nasl_init.c:377
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
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 1254 of file nasl_var.c.

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

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

1255  {
1256  anon_nasl_var *v2 = NULL;
1257 
1258  if (i < 0)
1259  {
1260  nasl_perror (
1261  NULL, "add_var_to_list: negative index are not (yet) supported\n");
1262  return -1;
1263  }
1264 
1265  if (i >= a->max_idx)
1266  {
1267  a->num_elt = g_realloc (a->num_elt, sizeof (anon_nasl_var *) * (i + 1));
1268  bzero (a->num_elt + a->max_idx,
1269  sizeof (anon_nasl_var *) * (i + 1 - a->max_idx));
1270  a->max_idx = i + 1;
1271  }
1272 
1273  if (a->num_elt)
1274  {
1275  free_anon_var (a->num_elt[i]);
1276  v2 = dup_anon_var (v); /* May return NULL */
1277  a->num_elt[i] = v2;
1278  }
1279  if (v2 == NULL)
1280  return 0;
1281  else
1282  return 1;
1283  }
static void free_anon_var(anon_nasl_var *)
Definition: nasl_var.c:399
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
static anon_nasl_var * dup_anon_var(const anon_nasl_var *v)
Definition: nasl_var.c:481
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 566 of file nasl_var.c.

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

567  {
568  anon_nasl_var *v2 = NULL, v0;
569  nasl_array *a = NULL;
570  int t2;
571  void *p;
572 
573  if (v1 == NULL || v1 == FAKE_CELL)
574  return NULL;
575 
576  if (rval == NULL || rval == FAKE_CELL)
577  {
578  clear_anon_var (v1);
579  if (nasl_trace_enabled ())
580  nasl_trace (NULL, "NASL> %s <- undef\n", get_var_name (v1));
581  return NULL;
582  }
583 
584  switch (rval->type)
585  {
586  case CONST_INT:
587  t2 = VAR2_INT;
588  break;
589  case CONST_STR:
590  t2 = VAR2_STRING;
591  break;
592  case CONST_DATA:
593  t2 = VAR2_DATA;
594  break;
595 
596  case REF_VAR:
597  v2 = rval->x.ref_val;
598  if (v2 == NULL)
599  {
600  t2 = 0;
601  a = NULL;
602  break;
603  }
604 
605  if (v2 == v1)
606  return FAKE_CELL;
607 
608  t2 = v2->var_type;
609  if (t2 == VAR2_ARRAY)
610  a = &v2->v.v_arr; /* ? */
611  break;
612 
613  case REF_ARRAY:
614  case DYN_ARRAY:
615  a = rval->x.ref_val;
616  t2 = VAR2_ARRAY;
617  if (v1->var_type == VAR2_ARRAY && &v1->v.v_arr == a)
618  return FAKE_CELL;
619  break;
620 
621  default:
622  nasl_perror (NULL, "Cannot affect rvalue 0x%x to variable\n",
623  rval->type);
624  return NULL;
625  }
626 
627  /*
628  * Bug #146: when executing
629  * x = 'abc'; x = x; or x = make_list(...); x = x[0];
630  * the rvalue will be freed before it is copied to the lvalue
631  */
632  v0 = *v1;
633 
634  /* Bug #146: this fake clear is necessary if we copy an array */
635  memset (v1, 0, sizeof (*v1));
636  /* Bug #146: no risk with the type, we already copied it */
637  v1->var_type = t2;
638 
639  if (rval->type != REF_VAR && rval->type != REF_ARRAY
640  && rval->type != DYN_ARRAY)
641  switch (t2)
642  {
643  case VAR2_INT:
644  v1->v.v_int = rval->x.i_val;
645  break;
646  case VAR2_STRING:
647  case VAR2_DATA:
648  if (rval->x.str_val == NULL)
649  {
650  v1->v.v_str.s_val = NULL;
651  v1->v.v_str.s_siz = 0;
652  }
653  else
654  {
655  p = g_malloc0 (rval->size + 1);
656  memcpy (p, rval->x.str_val, rval->size);
657  v1->v.v_str.s_siz = rval->size;
658  v1->v.v_str.s_val = p;
659  }
660  break;
661  }
662  else /* REF_xxx */
663  switch (t2)
664  {
665  case VAR2_INT:
666  v1->v.v_int = v2->v.v_int;
667  break;
668  case VAR2_STRING:
669  case VAR2_DATA:
670  if (v2->v.v_str.s_val == NULL)
671  {
672  v1->v.v_str.s_val = NULL;
673  v1->v.v_str.s_siz = 0;
674  }
675  else
676  {
677  p = g_malloc0 (v2->v.v_str.s_siz + 1);
678  memcpy (p, v2->v.v_str.s_val, v2->v.v_str.s_siz);
679  v1->v.v_str.s_siz = v2->v.v_str.s_siz;
680  v1->v.v_str.s_val = p;
681  }
682  break;
683  case VAR2_ARRAY:
684  copy_array (&v1->v.v_arr, a, 1);
685  break;
686  }
687 
688  if (nasl_trace_fp != NULL)
689  switch (t2)
690  {
691  case VAR2_INT:
692  nasl_trace (NULL, "NASL> %s <- %d\n", get_var_name (v1), v1->v.v_int);
693  break;
694  case VAR2_STRING:
695  case VAR2_DATA:
696  nasl_trace (NULL, "NASL> %s <- \"%s\"\n", get_var_name (v1),
697  v1->v.v_str.s_val);
698  break;
699  case VAR2_ARRAY:
700  nasl_trace (NULL, "NASL> %s <- (VAR2_ARRAY)\n", get_var_name (v1));
701  break;
702  default:
703  nasl_trace (NULL, "NASL> %s <- (Type 0x%x)\n", get_var_name (v1), t2);
704  break;
705  }
706 
707  clear_anon_var (&v0);
708  return FAKE_CELL;
709  }
int nasl_trace_enabled(void)
Checks if the nasl_trace_fp is set.
Definition: nasl_debug.c:170
#define FAKE_CELL
Definition: nasl_tree.h:119
static const char * get_var_name(anon_nasl_var *v)
Definition: nasl_var.c:211
short type
Definition: nasl_tree.h:106
char * str_val
Definition: nasl_tree.h:112
void * ref_val
Definition: nasl_tree.h:114
void clear_anon_var(anon_nasl_var *v)
Definition: nasl_var.c:418
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
void nasl_trace(lex_ctxt *lexic, char *msg,...)
Prints debug message in printf fashion to nasl_trace_fp if it exists.
Definition: nasl_debug.c:184
FILE * nasl_trace_fp
Definition: exec.c:368
int var_type
Definition: nasl_var.h:52
union TC::@2 x
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
union st_a_nasl_var::@4 v
long int i_val
Definition: nasl_tree.h:113
unsigned char * s_val
Definition: nasl_var.h:37
long int v_int
Definition: nasl_var.h:59
int size
Definition: nasl_tree.h:109
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 1004 of file nasl_var.c.

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

1005  {
1006  GString *str;
1007  int i, n1 = 0;
1008  anon_nasl_var *u;
1009  named_nasl_var *v;
1010 
1011  if (a == NULL)
1012  return NULL;
1013 
1014  str = g_string_new ("[ ");
1015  if (a->num_elt != NULL)
1016  for (i = 0; i < a->max_idx; i++)
1017  if ((u = a->num_elt[i]) != NULL && u->var_type != VAR2_UNDEF)
1018  {
1019  if (n1 > 0)
1020  g_string_append (str, ", ");
1021  n1++;
1022  switch (u->var_type)
1023  {
1024  case VAR2_INT:
1025  g_string_append_printf (str, "%d: %ld", i, u->v.v_int);
1026  break;
1027  case VAR2_STRING:
1028  case VAR2_DATA:
1029  if (u->v.v_str.s_siz < 64)
1030  g_string_append_printf (str, "%d: '%s'", i, u->v.v_str.s_val);
1031  else
1032  g_string_append_printf (str, "%d: '%s'...", i,
1033  u->v.v_str.s_val);
1034  break;
1035  default:
1036  g_string_append_printf (str, "%d: ????", i);
1037  break;
1038  }
1039  }
1040 
1041  if (a->hash_elt != NULL)
1042  for (i = 0; i < VAR_NAME_HASH; i++)
1043  for (v = a->hash_elt[i]; v != NULL; v = v->next_var)
1044  if (v->u.var_type != VAR2_UNDEF)
1045  {
1046  u = &v->u;
1047  if (n1 > 0)
1048  g_string_append (str, ", ");
1049  n1++;
1050  switch (u->var_type)
1051  {
1052  case VAR2_INT:
1053  g_string_append_printf (str, "%s: %ld", v->var_name,
1054  u->v.v_int);
1055  break;
1056  case VAR2_STRING:
1057  case VAR2_DATA:
1058  if (u->v.v_str.s_siz < 64)
1059  g_string_append_printf (str, "%s: '%s'", v->var_name,
1060  u->v.v_str.s_val);
1061  else
1062  g_string_append_printf (str, "%s: '%s'...", v->var_name,
1063  u->v.v_str.s_val);
1064  break;
1065  default:
1066  g_string_append_printf (str, "%s: ????", v->var_name);
1067  break;
1068  }
1069  }
1070 
1071  g_string_append (str, " ]");
1072  return g_string_free (str, FALSE);
1073  }
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
char * var_name
Definition: nasl_var.h:69
struct st_a_nasl_var u
Definition: nasl_var.h:67
nasl_string_t v_str
Definition: nasl_var.h:58
int var_type
Definition: nasl_var.h:52
#define VAR_NAME_HASH
Definition: nasl_var.h:33
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
union st_a_nasl_var::@4 v
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
unsigned char * s_val
Definition: nasl_var.h:37
long int v_int
Definition: nasl_var.h:59
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 1311 of file nasl_var.c.

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

1312  {
1313  int i;
1314 
1315  for (i = a->max_idx - 1; i >= 0; i--)
1316  if (a->num_elt[i] != NULL && a->num_elt[i]->var_type != VAR2_UNDEF)
1317  {
1318  /* Fixing max_index will realloc() at next store.
1319  * I am not sure it is a good idea
1320  * Wait and see */
1321  a->max_idx = i + 1;
1322  return i + 1;
1323  }
1324  return 0;
1325  }
int var_type
Definition: nasl_var.h:52
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
Here is the caller graph for this function:

◆ clear_anon_var()

void clear_anon_var ( anon_nasl_var v)

Definition at line 418 of file nasl_var.c.

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

419  {
420  if (v == NULL)
421  return;
422 
423  switch (v->var_type)
424  {
425  case VAR2_INT:
426  v->v.v_int = 0;
427  break;
428  case VAR2_STRING:
429  case VAR2_DATA:
430  g_free (v->v.v_str.s_val);
431  v->v.v_str.s_val = NULL;
432  v->v.v_str.s_siz = 0;
433  break;
434  case VAR2_ARRAY:
435  free_array (&v->v.v_arr);
436  break;
437  }
438  v->var_type = VAR2_UNDEF;
439  }
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
int var_type
Definition: nasl_var.h:52
union st_a_nasl_var::@4 v
unsigned char * s_val
Definition: nasl_var.h:37
void free_array(nasl_array *a)
Definition: nasl_var.c:354
long int v_int
Definition: nasl_var.h:59
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 442 of file nasl_var.c.

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

443  {
444  /* TBD: free variable if necessary? */
445  v1->var_type = v2->var_type;
446  switch (v2->var_type)
447  {
448  case VAR2_STRING:
449  case VAR2_DATA:
450  if (v2->v.v_str.s_val != NULL)
451  {
452  v1->v.v_str.s_val = g_malloc0 (v2->v.v_str.s_siz + 1);
453  memcpy (v1->v.v_str.s_val, v2->v.v_str.s_val, v2->v.v_str.s_siz);
454  v1->v.v_str.s_siz = v2->v.v_str.s_siz;
455  }
456  else
457  {
458  v1->v.v_str.s_val = NULL;
459  v1->v.v_str.s_siz = 0;
460  }
461  break;
462 
463  case VAR2_UNDEF:
464  break;
465 
466  case VAR2_INT:
467  v1->v.v_int = v2->v.v_int;
468  break;
469 
470  case VAR2_ARRAY:
471  copy_array (&v1->v.v_arr, &v2->v.v_arr, 1);
472  break;
473 
474  default:
475  nasl_perror (NULL, "copy_anon_var: unhandled type 0x%x\n", v2->var_type);
476  clear_anon_var (v1);
477  }
478  }
void clear_anon_var(anon_nasl_var *v)
Definition: nasl_var.c:418
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
int var_type
Definition: nasl_var.h:52
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
union st_a_nasl_var::@4 v
unsigned char * s_val
Definition: nasl_var.h:37
long int v_int
Definition: nasl_var.h:59
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 508 of file nasl_var.c.

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

509  {
510  int i;
511  named_nasl_var *v1, *v2, *v;
512 
513  if (a1 == a2)
514  return;
515 
516  if (a1 == NULL || a2 == NULL)
517  {
518  nasl_perror (NULL, "Internal inconsistency - null array\n");
519  abort ();
520  }
521 
522  free_array (a1);
523 
524  if (a2->num_elt != NULL)
525  {
526  a1->max_idx = a2->max_idx;
527  a1->num_elt = g_malloc0 (sizeof (anon_nasl_var *) * a2->max_idx);
528  for (i = 0; i < a2->max_idx; i++)
529  a1->num_elt[i] = dup_anon_var (a2->num_elt[i]);
530  }
531  if (copy_named && a2->hash_elt != NULL)
532  {
533  a1->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
534  for (i = 0; i < VAR_NAME_HASH; i++)
535  {
536  v1 = NULL;
537  for (v2 = a2->hash_elt[i]; v2 != NULL; v2 = v2->next_var)
538  {
539  v = dup_named_var (v2);
540  v->next_var = v1;
541  a1->hash_elt[i] = v;
542  v1 = v;
543  }
544  }
545  }
546  }
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
#define VAR_NAME_HASH
Definition: nasl_var.h:33
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
static named_nasl_var * dup_named_var(const named_nasl_var *v)
Definition: nasl_var.c:494
static anon_nasl_var * dup_anon_var(const anon_nasl_var *v)
Definition: nasl_var.c:481
void free_array(nasl_array *a)
Definition: nasl_var.c:354
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 549 of file nasl_var.c.

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

Referenced by nasl_return().

550  {
551  tree_cell *c2;
552  nasl_array *a2;
553 
554  if (c1 == NULL || c1 == FAKE_CELL || c1->type != REF_ARRAY)
555  return NULL;
556 
558  c2->x.ref_val = a2 = g_malloc0 (sizeof (nasl_array));
559  copy_array (a2, c1->x.ref_val, 1);
560  return c2;
561  }
#define FAKE_CELL
Definition: nasl_tree.h:119
short type
Definition: nasl_tree.h:106
void * ref_val
Definition: nasl_tree.h:114
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
Definition: nasl_tree.h:104
union TC::@2 x
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 755 of file nasl_var.c.

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

756  {
757  anon_nasl_var *v = g_malloc0 (sizeof (anon_nasl_var));
758  tree_cell *tc;
759 
760  if (val == NULL || val == FAKE_CELL)
761  {
762  v->var_type = VAR2_UNDEF;
763  return v;
764  }
765 
766  tc = affect_to_anon_var (v, val);
767  /* Here we might test the return value */
768  deref_cell (tc);
769  return v;
770  }
#define FAKE_CELL
Definition: nasl_tree.h:119
const char * val
Definition: nasl_init.c:378
void deref_cell(tree_cell *c)
Definition: nasl_tree.c:192
static tree_cell * affect_to_anon_var(anon_nasl_var *v1, tree_cell *rval)
Definition: nasl_var.c:566
int var_type
Definition: nasl_var.h:52
Definition: nasl_tree.h:104
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 734 of file nasl_var.c.

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

735  {
736  named_nasl_var *v = g_malloc0 (sizeof (named_nasl_var));
737  tree_cell *tc;
738 
739  if (name != NULL)
740  v->var_name = g_strdup (name);
741 
742  if (val == NULL || val == FAKE_CELL)
743  {
744  v->u.var_type = VAR2_UNDEF;
745  return v;
746  }
747 
748  tc = affect_to_anon_var (&v->u, val);
749  /* Here we might test the return value */
750  deref_cell (tc);
751  return v;
752  }
#define FAKE_CELL
Definition: nasl_tree.h:119
char * var_name
Definition: nasl_var.h:69
const char * val
Definition: nasl_init.c:378
struct st_a_nasl_var u
Definition: nasl_var.h:67
void deref_cell(tree_cell *c)
Definition: nasl_tree.c:192
static tree_cell * affect_to_anon_var(anon_nasl_var *v1, tree_cell *rval)
Definition: nasl_var.c:566
int var_type
Definition: nasl_var.h:52
Definition: nasl_tree.h:104
const char * name
Definition: nasl_init.c:377
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 786 of file nasl_var.c.

References decl_local_variables(), and struct_lex_ctxt::up_ctxt.

Referenced by nasl_exec().

787  {
788  lex_ctxt *c = lexic;
789 
790  while (c->up_ctxt != NULL)
791  c = c->up_ctxt;
792  return decl_local_variables (c, vars);
793  }
tree_cell * decl_local_variables(lex_ctxt *lexic, tree_cell *vars)
Definition: nasl_var.c:773
struct struct_lex_ctxt * up_ctxt
Definition: nasl_lex_ctxt.h:35
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 773 of file nasl_var.c.

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

774  {
775  tree_cell *t;
776 
777  for (t = vars; t != NULL; t = t->link[0])
778  if (t->x.str_val == NULL)
779  nasl_perror (lexic, "decl_local_variables: null name!\n");
780  else
781  add_named_var_to_ctxt (lexic, t->x.str_val, NULL);
782  return FAKE_CELL;
783  }
#define FAKE_CELL
Definition: nasl_tree.h:119
struct TC * link[4]
Definition: nasl_tree.h:116
char * str_val
Definition: nasl_tree.h:112
named_nasl_var * add_named_var_to_ctxt(lex_ctxt *lexic, const char *name, tree_cell *val)
Definition: nasl_var.c:825
Definition: nasl_tree.h:104
union TC::@2 x
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
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 481 of file nasl_var.c.

References copy_anon_var().

Referenced by add_var_to_list(), and copy_array().

482  {
483  anon_nasl_var *v1;
484 
485  if (v == NULL)
486  return NULL;
487 
488  v1 = g_malloc0 (sizeof (anon_nasl_var));
489  copy_anon_var (v1, v);
490  return v1;
491  }
static void copy_anon_var(anon_nasl_var *v1, const anon_nasl_var *v2)
Definition: nasl_var.c:442
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 494 of file nasl_var.c.

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

Referenced by copy_array().

495  {
496  named_nasl_var *v1;
497 
498  if (v == NULL)
499  return NULL;
500 
501  v1 = g_malloc0 (sizeof (named_nasl_var));
502  copy_anon_var (&v1->u, &v->u);
503  v1->var_name = g_strdup (v->var_name);
504  return v1;
505  }
char * var_name
Definition: nasl_var.h:69
static void copy_anon_var(anon_nasl_var *v1, const anon_nasl_var *v2)
Definition: nasl_var.c:442
struct st_a_nasl_var u
Definition: nasl_var.h:67
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 399 of file nasl_var.c.

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

400  {
401  if (v == NULL)
402  return;
403  switch (v->var_type)
404  {
405  case VAR2_STRING:
406  case VAR2_DATA:
407  g_free (v->v.v_str.s_val);
408  break;
409  case VAR2_ARRAY:
410  free_array (&v->v.v_arr);
411  break;
412  }
413  g_free (v->string_form);
414  g_free (v);
415  }
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
int var_type
Definition: nasl_var.h:52
char * string_form
Definition: nasl_var.h:62
union st_a_nasl_var::@4 v
unsigned char * s_val
Definition: nasl_var.h:37
void free_array(nasl_array *a)
Definition: nasl_var.c:354
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 354 of file nasl_var.c.

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

355  {
356  int i;
357 
358  if (a == NULL)
359  return;
360  if (a->num_elt != NULL)
361  {
362  for (i = 0; i < a->max_idx; i++)
363  free_anon_var (a->num_elt[i]);
364  g_free (a->num_elt);
365  a->num_elt = NULL;
366  }
367  a->max_idx = 0;
368  if (a->hash_elt != NULL)
369  {
370  for (i = 0; i < VAR_NAME_HASH; i++)
371  free_var_chain (a->hash_elt[i]);
372  g_free (a->hash_elt);
373  a->hash_elt = NULL;
374  }
375  }
static void free_anon_var(anon_nasl_var *)
Definition: nasl_var.c:399
static void free_var_chain(named_nasl_var *)
Definition: nasl_var.c:378
#define VAR_NAME_HASH
Definition: nasl_var.h:33
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
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 378 of file nasl_var.c.

References free_array(), 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().

379  {
380  if (v == NULL)
381  return;
383  g_free (v->var_name);
384  switch (v->u.var_type)
385  {
386  case VAR2_STRING:
387  case VAR2_DATA:
388  g_free (v->u.v.v_str.s_val);
389  break;
390  case VAR2_ARRAY:
391  free_array (&v->u.v.v_arr);
392  break;
393  }
394  g_free (v->u.string_form);
395  g_free (v);
396  }
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
char * var_name
Definition: nasl_var.h:69
static void free_var_chain(named_nasl_var *)
Definition: nasl_var.c:378
struct st_a_nasl_var u
Definition: nasl_var.h:67
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
int var_type
Definition: nasl_var.h:52
char * string_form
Definition: nasl_var.h:62
union st_a_nasl_var::@4 v
unsigned char * s_val
Definition: nasl_var.h:37
void free_array(nasl_array *a)
Definition: nasl_var.c:354
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 223 of file nasl_var.c.

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

224  {
225  named_nasl_var *nv;
226  anon_nasl_var *u, *av, fake_var;
227  tree_cell *tc, idx0;
228 
229  /* Fake variable */
230  if (strcmp (name, "_FCT_ANON_ARGS") == 0)
231  {
232  lex_ctxt *c;
233  for (c = ctxt; c != NULL && !c->fct_ctxt; c = c->up_ctxt)
234  ;
235  if (c == NULL)
236  return NULL;
237  fake_var.var_type = VAR2_ARRAY;
238  fake_var.v.v_arr = c->ctx_vars;
239  fake_var.v.v_arr.hash_elt = NULL; /* mask named elements */
240  u = &fake_var;
241  }
242  else
243  {
244  named_nasl_var *v = get_var_ref_by_name (ctxt, name, 1);
245  u = &v->u;
246  }
247 
248  if (idx == NULL)
249  {
250  /* Treat it as zero */
251  memset (&idx0, '\0', sizeof (idx0));
252  idx = &idx0;
253  idx->type = CONST_INT;
254  }
255 
256  switch (u->var_type)
257  {
258  case VAR2_UNDEF:
259  /* We define the array here */
260  u->var_type = VAR2_ARRAY;
261  /* fallthrough */
262  case VAR2_ARRAY:
263  switch (idx->type)
264  {
265  case CONST_INT:
266  av = nasl_get_var_by_num (ctxt, &u->v.v_arr, idx->x.i_val,
267  /* avoid dangling pointers */
268  strcmp (name, "_FCT_ANON_ARGS"));
269  return var2cell (av);
270 
271  case CONST_STR:
272  case CONST_DATA:
273  nv = get_var_by_name (&u->v.v_arr, idx->x.str_val);
274  return var2cell (nv != NULL ? &nv->u : NULL);
275 
276  default:
277  nasl_perror (ctxt,
278  "get_array_elem: unhandled index type 0x%x for "
279  "variable %s\n",
280  idx->type, name);
281  return NULL;
282  }
283  /*NOTREACHED*/ break;
284 
285  case VAR2_INT:
286  nasl_perror (ctxt, "get_array_elem: variable %s is an integer\n", name);
287  return NULL;
288 
289  case VAR2_STRING:
290  case VAR2_DATA:
291  if (idx->type == CONST_INT)
292  {
293  int l = u->v.v_str.s_siz;
294 
295  if (idx->x.i_val >= l)
296  {
297  nasl_perror (ctxt,
298  "get_array_elem: requesting character after end "
299  "of string %s (%d >= %d)\n",
300  name, idx->x.i_val, l);
301  tc = alloc_expr_cell (idx->line_nb, CONST_DATA /*CONST_STR */,
302  NULL, NULL);
303  tc->x.str_val = g_strdup ("");
304  tc->size = 0;
305  return tc;
306  }
307  else
308  {
309  if (idx->x.i_val < 0)
310  {
311  nasl_perror (ctxt,
312  "get_array_elem: Negative index (%d) passed to "
313  "\"%s\"!\n",
314  idx->x.i_val, name);
315  return NULL;
316  }
317  tc = alloc_expr_cell (idx->line_nb, CONST_DATA /*CONST_STR */,
318  NULL, NULL);
319  tc->x.str_val = g_malloc0 (2);
320  tc->x.str_val[0] = u->v.v_str.s_val[idx->x.i_val];
321  tc->x.str_val[1] = '\0';
322  tc->size = 1;
323  return tc;
324  }
325  }
326  else
327  {
328  nasl_perror (ctxt,
329  "get_array_elem: Cannot use a non integer index"
330  " (type 0x%x) in string. Variable: %s\n",
331  idx->type, name);
332  return NULL;
333  }
334  /*NOTREACHED*/ break;
335 
336  default:
337  nasl_perror (ctxt, "Severe bug: unknown variable type 0x%x %s\n",
338  u->var_type, get_line_nb (idx));
339  return NULL;
340  }
341  /*NOTREACHED*/ return NULL;
342  }
anon_nasl_var * nasl_get_var_by_num(void *ctxt, nasl_array *a, int num, int create)
Definition: nasl_var.c:58
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
short type
Definition: nasl_tree.h:106
char * str_val
Definition: nasl_tree.h:112
struct st_a_nasl_var u
Definition: nasl_var.h:67
short line_nb
Definition: nasl_tree.h:107
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
int var_type
Definition: nasl_var.h:52
static named_nasl_var * get_var_by_name(nasl_array *a, const char *s)
Definition: nasl_var.c:90
Definition: nasl_tree.h:104
union TC::@2 x
unsigned fct_ctxt
Definition: nasl_lex_ctxt.h:37
const char * name
Definition: nasl_init.c:377
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
tree_cell * var2cell(anon_nasl_var *v)
Definition: nasl_var.c:183
union st_a_nasl_var::@4 v
long int i_val
Definition: nasl_tree.h:113
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
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.
Definition: nasl_var.c:115
unsigned char * s_val
Definition: nasl_var.h:37
char * get_line_nb(const tree_cell *c)
Definition: nasl_tree.c:390
tree_cell * alloc_expr_cell(int lnb, int t, tree_cell *l, tree_cell *r)
Definition: nasl_tree.c:74
struct struct_lex_ctxt * up_ctxt
Definition: nasl_lex_ctxt.h:35
int size
Definition: nasl_tree.h:109
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 1113 of file nasl_var.c.

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

Referenced by _http_req(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ipv6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_port_transport(), insert_ip_options(), insert_ipv6_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_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_capture(), nasl_send_packet(), nasl_send_v6packet(), nasl_smb_close(), nasl_smb_file_group_sid(), nasl_smb_file_owner_sid(), nasl_smb_file_SDDL(), nasl_smb_file_trustee_rights(), nasl_socket_cert_verify(), 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_split(), nasl_ssh_connect(), nasl_ssh_request_exec(), 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_ipv6_elements(), set_kb_item(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

1114  {
1115  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1116  return var2int (&v->u, defval);
1117  }
struct st_a_nasl_var u
Definition: nasl_var.h:67
const char * name
Definition: nasl_init.c:377
static long int var2int(anon_nasl_var *v, int defval)
Definition: nasl_var.c:982
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.
Definition: nasl_var.c:115
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 
)

◆ get_str_var_by_name()

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

Definition at line 1127 of file nasl_var.c.

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

Referenced by _http_req(), add_hostname(), encrypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ipv6_packet(), forge_tcp_packet(), forge_tcp_v6_packet(), forge_udp_packet(), forge_udp_v6_packet(), get_hostname_source(), get_icmp_element(), get_icmp_v6_element(), get_ip_element(), get_ipv6_element(), get_tcp_element(), get_tcp_v6_element(), get_udp_element(), get_udp_v6_element(), insert_ip_options(), insert_ipv6_options(), mpi_from_named_parameter(), nasl_bf_cbc(), nasl_crap(), nasl_egrep(), nasl_ereg(), nasl_ereg_replace(), nasl_eregmatch(), nasl_file_open(), nasl_file_write(), nasl_ftp_log_in(), nasl_fwrite(), nasl_get_sign(), nasl_get_smb2_sign(), nasl_gunzip(), nasl_gzip(), nasl_hmac(), nasl_hmac_sha256(), nasl_insert_hexzeros(), nasl_keyexchg(), nasl_load_privkey_param(), nasl_match(), nasl_ntlm2_response(), nasl_ntlm_response(), nasl_ntlmv1_hash(), nasl_ntlmv2_hash(), nasl_ntlmv2_response(), nasl_ntv2_owf_gen(), nasl_open_sock_tcp_bufsz(), nasl_open_stream_cipher(), nasl_pcap_next(), nasl_pread(), nasl_prf(), nasl_rsa_private_decrypt(), nasl_rsa_public_encrypt(), nasl_rsa_sign(), nasl_scanner_add_port(), nasl_send(), nasl_send_capture(), nasl_send_packet(), nasl_send_v6packet(), nasl_smb_connect(), nasl_smb_file_group_sid(), nasl_smb_file_owner_sid(), nasl_smb_file_SDDL(), nasl_smb_file_trustee_rights(), nasl_split(), nasl_ssh_connect(), nasl_ssh_login_interactive_pass(), nasl_ssh_request_exec(), nasl_ssh_set_login(), nasl_ssh_shell_write(), nasl_ssh_userauth(), nasl_str_replace(), 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(), resolve_hostname(), script_add_preference(), script_mandatory_keys(), script_tag(), script_xref(), security_something(), set_ip_elements(), set_ipv6_elements(), set_kb_item(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

1128  {
1129  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1130  return (char *) var2str (&v->u);
1131  }
struct st_a_nasl_var u
Definition: nasl_var.h:67
const char * name
Definition: nasl_init.c:377
const char * var2str(anon_nasl_var *v)
Definition: nasl_var.c:1076
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.
Definition: nasl_var.c:115
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 1120 of file nasl_var.c.

References get_var_ref_by_num(), and var2str().

Referenced by dump_ip_packet(), dump_ipv6_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_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_bugtraq_id(), 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().

1121  {
1122  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1123  return (char *) var2str (v);
1124  }
static anon_nasl_var * get_var_ref_by_num(lex_ctxt *ctxt, int num)
Definition: nasl_var.c:153
const char * var2str(anon_nasl_var *v)
Definition: nasl_var.c:1076
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 90 of file nasl_var.c.

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

91 {
92  int h = hash_str (s);
93  named_nasl_var *v;
94 
95  if (a->hash_elt == NULL)
96  a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
97 
98  for (v = a->hash_elt[h]; v != NULL; v = v->next_var)
99  if (v->var_name != NULL && strcmp (s, v->var_name) == 0)
100  return v;
101 
102  v = g_malloc0 (sizeof (named_nasl_var));
103  v->var_name = g_strdup (s);
104  v->u.var_type = VAR2_UNDEF;
105  v->next_var = a->hash_elt[h];
106 
107  a->hash_elt[h] = v;
108  return v;
109 }
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
char * var_name
Definition: nasl_var.h:69
struct st_a_nasl_var u
Definition: nasl_var.h:67
int var_type
Definition: nasl_var.h:52
#define VAR_NAME_HASH
Definition: nasl_var.h:33
static int hash_str(const char *s)
Definition: nasl_var.c:52
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
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 211 of file nasl_var.c.

Referenced by affect_to_anon_var(), and nasl_read_var_ref().

212  {
213  static char str[16];
214 #ifdef ALL_VARIABLES_NAMED
215  if (v->av_name != NULL)
216  return v->av_name;
217 #endif
218  snprintf (str, sizeof (str), "[%p]", v);
219  return str;
220  }
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 115 of file nasl_var.c.

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

116 {
117  named_nasl_var *v;
118  int h = hash_str (name);
119  lex_ctxt *c;
120 
121  if (!ctxt)
122  return NULL;
123  if (climb != 0)
124  {
125  for (c = ctxt; c != NULL; c = c->up_ctxt)
126  if (c->ctx_vars.hash_elt != NULL)
127  for (v = c->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
128  if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
129  return v;
130  }
131  else
132  {
133  if (ctxt->ctx_vars.hash_elt != NULL)
134  for (v = ctxt->ctx_vars.hash_elt[h]; v != NULL; v = v->next_var)
135  if (v->var_name != NULL && strcmp (name, v->var_name) == 0)
136  return v;
137  }
138 
139  if (ctxt->ctx_vars.hash_elt == NULL)
140  ctxt->ctx_vars.hash_elt =
141  g_malloc0 (sizeof (named_nasl_var *) * VAR_NAME_HASH);
142 
143  v = g_malloc0 (sizeof (named_nasl_var));
144  v->var_name = g_strdup (name);
145  v->u.var_type = VAR2_UNDEF;
146  v->next_var = ctxt->ctx_vars.hash_elt[h];
147  ctxt->ctx_vars.hash_elt[h] = v;
148 
149  return v;
150 }
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
char * var_name
Definition: nasl_var.h:69
struct st_a_nasl_var u
Definition: nasl_var.h:67
int var_type
Definition: nasl_var.h:52
#define VAR_NAME_HASH
Definition: nasl_var.h:33
static int hash_str(const char *s)
Definition: nasl_var.c:52
const char * name
Definition: nasl_init.c:377
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
struct struct_lex_ctxt * up_ctxt
Definition: nasl_lex_ctxt.h:35
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 153 of file nasl_var.c.

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

154 {
155  anon_nasl_var *v;
156 
157  if (num < 0) /* safer */
158  {
159  nasl_perror (ctxt, "Negative index %d is invalid for array\n", num);
160  return NULL;
161  }
162 
163  if (ctxt->ctx_vars.max_idx <= num)
164  {
165  ctxt->ctx_vars.num_elt = g_realloc (ctxt->ctx_vars.num_elt,
166  sizeof (anon_nasl_var *) * (num + 1));
167  bzero (ctxt->ctx_vars.num_elt + ctxt->ctx_vars.max_idx,
168  sizeof (anon_nasl_var *) * (num + 1 - ctxt->ctx_vars.max_idx));
169  ctxt->ctx_vars.max_idx = num + 1;
170  }
171 
172  v = ctxt->ctx_vars.num_elt[num];
173  if (v != NULL)
174  return v;
175 
176  v = g_malloc0 (sizeof (anon_nasl_var));
177  v->var_type = VAR2_UNDEF;
178  ctxt->ctx_vars.num_elt[num] = v;
179  return v;
180 }
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
int var_type
Definition: nasl_var.h:52
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
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 1133 of file nasl_var.c.

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

1134  {
1135  if (v == NULL)
1136  return 0;
1137  switch (v->var_type)
1138  {
1139  case VAR2_DATA:
1140  case VAR2_STRING:
1141  return v->v.v_str.s_siz;
1142  }
1143  return 0;
1144  }
nasl_string_t v_str
Definition: nasl_var.h:58
int var_type
Definition: nasl_var.h:52
union st_a_nasl_var::@4 v
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 1147 of file nasl_var.c.

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

Referenced by encrypt_data(), encrypt_stream_data(), forge_icmp_packet(), forge_icmp_v6_packet(), forge_igmp_packet(), forge_igmp_v6_packet(), forge_ip_packet(), forge_ipv6_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_v6_element(), get_udp_element(), get_udp_v6_element(), insert_ip_options(), insert_ipv6_options(), mpi_from_named_parameter(), nasl_bf_cbc(), nasl_crap(), nasl_egrep(), nasl_file_write(), nasl_fwrite(), nasl_get_smb2_sign(), nasl_gunzip(), nasl_gzip(), nasl_hmac(), nasl_hmac_sha256(), nasl_insert_hexzeros(), nasl_load_privkey_param(), 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_split(), nasl_str_replace(), replace_kb_item(), security_something(), set_ip_elements(), set_ipv6_elements(), set_kb_item(), set_tcp_elements(), set_tcp_v6_elements(), set_udp_elements(), and set_udp_v6_elements().

1148  {
1149  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1150  return get_var_size (&v->u);
1151  }
struct st_a_nasl_var u
Definition: nasl_var.h:67
const char * name
Definition: nasl_init.c:377
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.
Definition: nasl_var.c:115
static int get_var_size(const anon_nasl_var *v)
Definition: nasl_var.c:1133
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 1154 of file nasl_var.c.

References get_var_ref_by_num(), and get_var_size().

Referenced by 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().

1155  {
1156  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1157  return get_var_size (v);
1158  }
static anon_nasl_var * get_var_ref_by_num(lex_ctxt *ctxt, int num)
Definition: nasl_var.c:153
static int get_var_size(const anon_nasl_var *v)
Definition: nasl_var.c:1133
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 1171 of file nasl_var.c.

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(), and set_kb_item().

1172  {
1173  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1174  return v == NULL ? VAR2_UNDEF : v->u.var_type;
1175  }
struct st_a_nasl_var u
Definition: nasl_var.h:67
int var_type
Definition: nasl_var.h:52
const char * name
Definition: nasl_init.c:377
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.
Definition: nasl_var.c:115
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 1164 of file nasl_var.c.

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

1165  {
1166  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1167  return v == NULL ? VAR2_UNDEF : v->var_type;
1168  }
static anon_nasl_var * get_var_ref_by_num(lex_ctxt *ctxt, int num)
Definition: nasl_var.c:153
int var_type
Definition: nasl_var.h:52
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 191 of file nasl_var.c.

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

192 {
193  if (name == NULL)
194  return NULL;
195  /* Broken: Need also code in get_array_elem */
196  if (strcmp (name, "_FCT_ANON_ARGS") == 0)
197  {
199  nasl_array *a = retc->x.ref_val = g_malloc0 (sizeof (nasl_array));
200  copy_array (a, &ctxt->ctx_vars, 0);
201  return retc;
202  }
203  else
204  {
205  named_nasl_var *v = get_var_ref_by_name (ctxt, name, 1);
206  return var2cell (&v->u);
207  }
208  /*NOTREACHED*/}
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
struct st_a_nasl_var u
Definition: nasl_var.h:67
void * ref_val
Definition: nasl_tree.h:114
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
Definition: nasl_tree.h:104
union TC::@2 x
const char * name
Definition: nasl_init.c:377
tree_cell * var2cell(anon_nasl_var *v)
Definition: nasl_var.c:183
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.
Definition: nasl_var.c:115
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 52 of file nasl_var.c.

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

53 {
54  return hash_str2 (s, VAR_NAME_HASH);
55 }
#define VAR_NAME_HASH
Definition: nasl_var.h:33
int hash_str2(const char *s, int n)
Definition: nasl_var.c:38
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 38 of file nasl_var.c.

Referenced by hash_str().

39 {
40  unsigned long h = 0;
41  const char *p;
42 
43  if (s == NULL)
44  return 0;
45 
46  for (p = s; *p != '\0'; p++)
47  h = (h << 3) + (unsigned char) *p;
48  return h % n;
49 }
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 1332 of file nasl_var.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().

1333  {
1334  int n;
1335  tree_cell *c, *c2;
1336  nasl_array *a;
1337  anon_nasl_var *v;
1338 
1339  v = g_malloc0 (sizeof (anon_nasl_var));
1340  a = g_malloc0 (sizeof (nasl_array));
1341  /* Either the elements are all "named", or they are "numbered". No mix! */
1342  if (el->x.str_val == NULL) /* numbered */
1343  {
1344  for (n = 0, c = el; c != NULL; c = c->link[1])
1345  n++;
1346  a->max_idx = n;
1347  a->num_elt = g_malloc0 (sizeof (anon_nasl_var *) * n);
1348  a->hash_elt = NULL;
1349  }
1350  else
1351  {
1352  a->num_elt = NULL;
1353  a->hash_elt = g_malloc0 (VAR_NAME_HASH * sizeof (named_nasl_var *));
1354  }
1355 
1356  for (n = 0, c = el; c != NULL; c = c->link[1])
1357  {
1358  c2 = c->link[0];
1359  if (c2 != NULL && c2 != FAKE_CELL)
1360  {
1361  switch (c2->type)
1362  {
1363  case CONST_INT:
1364  v->var_type = VAR2_INT;
1365  v->v.v_int = c2->x.i_val;
1366  break;
1367  case CONST_STR:
1368  case CONST_DATA:
1369  v->var_type = c2->type == CONST_STR ? VAR2_STRING : VAR2_DATA;
1370  if (c2->x.str_val == NULL)
1371  {
1372  v->v.v_str.s_val = NULL;
1373  v->v.v_str.s_siz = 0;
1374  }
1375  else
1376  {
1377  v->v.v_str.s_siz = c2->size;
1378  v->v.v_str.s_val = (unsigned char *) c2->x.str_val;
1379  }
1380  break;
1381  default:
1382  nasl_perror (NULL,
1383  "make_array_from_list: unhandled cell type %s at "
1384  "position %d\n",
1385  nasl_type_name (c2->type), n);
1386  v->var_type = VAR2_UNDEF;
1387  break;
1388  }
1389  }
1390 
1391  if (c->x.str_val == NULL)
1392  add_var_to_list (a, n++, v);
1393  else
1394  add_var_to_array (a, c->x.str_val, v);
1395  }
1396 
1397  g_free (v);
1399  c->x.ref_val = a;
1400  deref_cell (el);
1401  return c;
1402  }
#define FAKE_CELL
Definition: nasl_tree.h:119
struct TC * link[4]
Definition: nasl_tree.h:116
short type
Definition: nasl_tree.h:106
char * str_val
Definition: nasl_tree.h:112
void deref_cell(tree_cell *c)
Definition: nasl_tree.c:192
int add_var_to_array(nasl_array *a, char *name, const anon_nasl_var *v)
Definition: nasl_var.c:1286
void * ref_val
Definition: nasl_tree.h:114
nasl_string_t v_str
Definition: nasl_var.h:58
int add_var_to_list(nasl_array *a, int i, const anon_nasl_var *v)
Definition: nasl_var.c:1254
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
int var_type
Definition: nasl_var.h:52
Definition: nasl_tree.h:104
union TC::@2 x
#define VAR_NAME_HASH
Definition: nasl_var.h:33
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
union st_a_nasl_var::@4 v
long int i_val
Definition: nasl_tree.h:113
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
const char * nasl_type_name(int t)
Definition: nasl_tree.c:357
unsigned char * s_val
Definition: nasl_var.h:37
long int v_int
Definition: nasl_var.h:59
int size
Definition: nasl_tree.h:109
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 712 of file nasl_var.c.

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

Referenced by nasl_exec().

713  {
714  anon_nasl_var *v1 = NULL;
715 
716  if (lval == NULL)
717  {
718  nasl_perror (NULL, "nasl_effect: invalid lvalue\n");
719  return NULL;
720  }
721 
722  if (lval->type != REF_VAR)
723  {
724  nasl_perror (NULL, "nasl_affect: cannot affect to non variable %s\n",
725  nasl_type_name (lval->type));
726  return NULL;
727  }
728 
729  v1 = lval->x.ref_val;
730  return affect_to_anon_var (v1, rval);
731  }
short type
Definition: nasl_tree.h:106
void * ref_val
Definition: nasl_tree.h:114
static tree_cell * affect_to_anon_var(anon_nasl_var *v1, tree_cell *rval)
Definition: nasl_var.c:566
union TC::@2 x
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
const char * nasl_type_name(int t)
Definition: nasl_tree.c:357
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 1178 of file nasl_var.c.

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

1179  {
1180  nasl_iterator it;
1181  anon_nasl_var *v;
1182 
1183  it.a = NULL;
1184  it.v = NULL;
1185  it.i1 = 0;
1186  it.iH = 0;
1187 
1188  if (c == NULL || c == FAKE_CELL)
1189  return it;
1190 
1191  if (c->type == REF_VAR)
1192  {
1193  v = c->x.ref_val;
1194  if (v == NULL || v->var_type != VAR2_ARRAY)
1195  return it;
1196  it.a = g_malloc0 (sizeof (nasl_array));
1197  copy_array (it.a, &v->v.v_arr, 1);
1198  }
1199  else if (c->type == REF_ARRAY || c->type == DYN_ARRAY)
1200  {
1201  it.a = g_malloc0 (sizeof (nasl_array));
1202  copy_array (it.a, c->x.ref_val, 1);
1203  }
1204  else
1205  {
1206  nasl_perror (ctxt, "nasl_array_iterator: unhandled type %d (0x%x)\n",
1207  c->type, c->type);
1208  }
1209 
1210  return it;
1211  }
#define FAKE_CELL
Definition: nasl_tree.h:119
short type
Definition: nasl_tree.h:106
named_nasl_var * v
Definition: nasl_var.h:81
void * ref_val
Definition: nasl_tree.h:114
nasl_array v_arr
Definition: nasl_var.h:60
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
int var_type
Definition: nasl_var.h:52
union TC::@2 x
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
union st_a_nasl_var::@4 v
nasl_array * a
Definition: nasl_var.h:78
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 58 of file nasl_var.c.

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

59 {
60  anon_nasl_var *v = NULL;
61 
62  if (num < 0)
63  {
64  /* TBD: implement a min_index field, just like $[ in Perl */
65  nasl_perror (ctxt, "Negative integer index %d are not supported yet!\n",
66  num);
67  return NULL;
68  }
69 
70  if (num < a->max_idx)
71  v = a->num_elt[num];
72  if (v != NULL || !create)
73  return v;
74 
75  if (num >= a->max_idx)
76  {
77  a->num_elt = g_realloc (a->num_elt, sizeof (anon_nasl_var *) * (num + 1));
78  bzero (a->num_elt + a->max_idx,
79  sizeof (anon_nasl_var *) * (num + 1 - a->max_idx));
80  a->max_idx = num + 1;
81  }
82  v = g_malloc0 (sizeof (anon_nasl_var));
83  v->var_type = VAR2_UNDEF;
84 
85  a->num_elt[num] = v;
86  return v;
87 }
int var_type
Definition: nasl_var.h:52
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
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 933 of file nasl_var.c.

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

934  {
935  anon_nasl_var *v;
936  int old_val = 0, new_val;
937  tree_cell *retc;
938 
939  if (tc->type != REF_VAR)
940  {
941  nasl_perror (
942  lexic, "nasl_incr_variable: argument (type=%d) is not REF_VAR %s\n",
943  tc->type, get_line_nb (tc));
944  return NULL;
945  }
946 
947  v = tc->x.ref_val;
948 
949  switch (v->var_type)
950  {
951  case VAR2_INT:
952  old_val = v->v.v_int;
953  break;
954  case VAR2_STRING:
955  case VAR2_DATA:
956  old_val =
957  v->v.v_str.s_val == NULL ? 0 : atoi ((char *) v->v.v_str.s_val);
958  break;
959  case VAR2_UNDEF:
960  old_val = 0;
961  break;
962 
963  default:
964  nasl_perror (lexic,
965  "nasl_incr_variable: variable %s has bad type %d %s\n",
966  /*get_var_name(v) */ "", get_line_nb (tc));
967  return NULL;
968  }
969  new_val = old_val + val;
970 
971  clear_anon_var (v);
972  v->var_type = VAR2_INT;
973  v->v.v_int = new_val;
974 
975  retc = alloc_typed_cell (CONST_INT);
976  retc->x.i_val = pre ? new_val : old_val;
977 
978  return retc;
979  }
const char * val
Definition: nasl_init.c:378
short type
Definition: nasl_tree.h:106
void * ref_val
Definition: nasl_tree.h:114
void clear_anon_var(anon_nasl_var *v)
Definition: nasl_var.c:418
nasl_string_t v_str
Definition: nasl_var.h:58
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
int var_type
Definition: nasl_var.h:52
Definition: nasl_tree.h:104
union TC::@2 x
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
union st_a_nasl_var::@4 v
long int i_val
Definition: nasl_tree.h:113
unsigned char * s_val
Definition: nasl_var.h:37
char * get_line_nb(const tree_cell *c)
Definition: nasl_tree.c:390
long int v_int
Definition: nasl_var.h:59
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 1214 of file nasl_var.c.

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

1215  {
1216  anon_nasl_var *av;
1217 
1218  if (it == NULL || it->a == NULL)
1219  return NULL;
1220 
1221  if (it->i1 >= 0)
1222  {
1223  while (it->i1 < it->a->max_idx)
1224  {
1225  av = it->a->num_elt[it->i1++];
1226  if (av != NULL && av->var_type != VAR2_UNDEF)
1227  return var2cell (av);
1228  }
1229  it->i1 = -1;
1230  }
1231 
1232  if (it->a->hash_elt == NULL)
1233  return NULL;
1234 
1235  if (it->v != NULL)
1236  it->v = it->v->next_var;
1237  do
1238  {
1239  while (it->v == NULL)
1240  if (it->iH >= VAR_NAME_HASH)
1241  return NULL;
1242  else
1243  it->v = it->a->hash_elt[it->iH++];
1244 
1245  while (it->v != NULL && it->v->u.var_type == VAR2_UNDEF)
1246  it->v = it->v->next_var;
1247  }
1248  while (it->v == NULL);
1249 
1250  return var2cell (&it->v->u);
1251  }
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
named_nasl_var * v
Definition: nasl_var.h:81
struct st_a_nasl_var u
Definition: nasl_var.h:67
int var_type
Definition: nasl_var.h:52
#define VAR_NAME_HASH
Definition: nasl_var.h:33
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46
tree_cell * var2cell(anon_nasl_var *v)
Definition: nasl_var.c:183
nasl_array * a
Definition: nasl_var.h:78
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
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 847 of file nasl_var.c.

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

848  {
849  tree_cell *ret;
850  anon_nasl_var *v;
851 
852  if (tc == NULL || tc == FAKE_CELL)
853  {
854  nasl_perror (lexic,
855  "nasl_read_var_ref: cannot read NULL or FAKE cell\n");
856  return NULL;
857  }
858  if (tc->type != REF_VAR)
859  {
860  nasl_perror (lexic,
861  "nasl_read_var_ref: argument (type=%d) is not REF_VAR %s\n",
862  tc->type, get_line_nb (tc));
863  return NULL;
864  }
865 
866  v = tc->x.ref_val;
867  if (v == NULL)
868  return NULL;
869 
871  ret->line_nb = tc->line_nb;
872 
873  switch (v->var_type)
874  {
875  case VAR2_INT:
876  ret->type = CONST_INT;
877  ret->x.i_val = v->v.v_int;
878  if (nasl_trace_enabled ())
879  nasl_trace (lexic, "NASL> %s -> %d\n", get_var_name (v), ret->x.i_val);
880  return ret;
881 
882  case VAR2_STRING:
883  ret->type = CONST_STR;
884  /* Fix bad string length */
885  if (v->v.v_str.s_siz <= 0 && v->v.v_str.s_val[0] != '\0')
886  {
887  v->v.v_str.s_siz = strlen ((char *) v->v.v_str.s_val);
888  nasl_perror (lexic, "nasl_read_var_ref: Bad string length fixed\n");
889  }
890  /* fallthrough */
891  case VAR2_DATA:
892  ret->type = v->var_type == VAR2_STRING ? CONST_STR : CONST_DATA;
893  if (v->v.v_str.s_val == NULL)
894  {
895  ret->x.str_val = NULL;
896  ret->size = 0;
897  }
898  else
899  {
900  ret->x.str_val = g_malloc0 (v->v.v_str.s_siz + 1);
901  memcpy (ret->x.str_val, v->v.v_str.s_val, v->v.v_str.s_siz);
902  ret->size = v->v.v_str.s_siz;
903  }
904  if (nasl_trace_enabled ())
905  nasl_trace (lexic, "NASL> %s -> \"%s\"\n", get_var_name (v),
906  ret->x.str_val);
907  return ret;
908 
909  case VAR2_ARRAY:
910  ret->type = REF_ARRAY;
911  ret->x.ref_val = &v->v.v_arr;
912  return ret;
913 
914  case VAR2_UNDEF:
915  if (nasl_trace_enabled ())
916  nasl_trace (lexic, "NASL> %s -> undef\n", get_var_name (v),
917  v->var_type);
918  break;
919 
920  default:
921  nasl_perror (lexic, "nasl_read_var_ref: unhandled variable type %d\n",
922  v->var_type);
923  if (nasl_trace_enabled ())
924  nasl_trace (lexic, "NASL> %s -> ???? (Var type %d)\n",
925  get_var_name (v), v->var_type);
926  break;
927  }
928  deref_cell (ret);
929  return NULL;
930  }
int nasl_trace_enabled(void)
Checks if the nasl_trace_fp is set.
Definition: nasl_debug.c:170
#define FAKE_CELL
Definition: nasl_tree.h:119
static const char * get_var_name(anon_nasl_var *v)
Definition: nasl_var.c:211
short type
Definition: nasl_tree.h:106
char * str_val
Definition: nasl_tree.h:112
void deref_cell(tree_cell *c)
Definition: nasl_tree.c:192
short line_nb
Definition: nasl_tree.h:107
void * ref_val
Definition: nasl_tree.h:114
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
void nasl_trace(lex_ctxt *lexic, char *msg,...)
Prints debug message in printf fashion to nasl_trace_fp if it exists.
Definition: nasl_debug.c:184
int var_type
Definition: nasl_var.h:52
Definition: nasl_tree.h:104
union TC::@2 x
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
union st_a_nasl_var::@4 v
long int i_val
Definition: nasl_tree.h:113
unsigned char * s_val
Definition: nasl_var.h:37
char * get_line_nb(const tree_cell *c)
Definition: nasl_tree.c:390
long int v_int
Definition: nasl_var.h:59
int size
Definition: nasl_tree.h:109
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 183 of file nasl_var.c.

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

184 {
186  tc->x.ref_val = v; /* No need to free this later! */
187  return tc;
188 }
void * ref_val
Definition: nasl_tree.h:114
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
Definition: nasl_tree.h:104
union TC::@2 x
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 982 of file nasl_var.c.

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

983  {
984  if (v == NULL)
985  return defval;
986 
987  switch (v->var_type)
988  {
989  case VAR2_INT:
990  return v->v.v_int;
991 
992  case VAR2_STRING:
993  case VAR2_DATA:
994  return atol ((char *) v->v.v_str.s_val);
995 
996  case VAR2_UNDEF:
997  case VAR2_ARRAY:
998  default:
999  return defval;
1000  }
1001  /*NOTREACHED*/}
nasl_string_t v_str
Definition: nasl_var.h:58
int var_type
Definition: nasl_var.h:52
union st_a_nasl_var::@4 v
unsigned char * s_val
Definition: nasl_var.h:37
long int v_int
Definition: nasl_var.h:59
Here is the caller graph for this function:

◆ var2str()

const char* var2str ( anon_nasl_var v)

Definition at line 1076 of file nasl_var.c.

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

1077  {
1078  if (v == NULL)
1079  return NULL;
1080 
1081  if (v->string_form)
1082  return v->string_form;
1083  switch (v->var_type)
1084  {
1085  case VAR2_INT:
1086  v->string_form = g_strdup_printf ("%ld", v->v.v_int);
1087  break;
1088  case VAR2_STRING:
1089  case VAR2_DATA:
1090  v->string_form =
1091  g_memdup ((char *) v->v.v_str.s_val ?: "", v->v.v_str.s_siz + 1);
1092  break;
1093  case VAR2_UNDEF:
1094  break;
1095  case VAR2_ARRAY:
1096  v->string_form = array2str (&v->v.v_arr);
1097  break;
1098  default:
1099  v->string_form = g_strdup ("");
1100  break;
1101  }
1102  return v->string_form;
1103  }
nasl_string_t v_str
Definition: nasl_var.h:58
nasl_array v_arr
Definition: nasl_var.h:60
int var_type
Definition: nasl_var.h:52
char * array2str(const nasl_array *a)
Definition: nasl_var.c:1004
char * string_form
Definition: nasl_var.h:62
union st_a_nasl_var::@4 v
unsigned char * s_val
Definition: nasl_var.h:37
long int v_int
Definition: nasl_var.h:59
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

Definition at line 368 of file exec.c.

Referenced by affect_to_anon_var(), and nasl_exec().