OpenVAS Scanner  7.0.0~git
nasl_var.c
Go to the documentation of this file.
1 /* Based on work Copyright (C) 2002 - 2004 Tenable Network Security
2  *
3  * SPDX-License-Identifier: GPL-2.0-only
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * version 2 as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18 
19 #include "nasl_var.h"
20 
21 #include "exec.h"
22 #include "nasl_debug.h"
23 #include "nasl_func.h"
24 #include "nasl_global_ctxt.h"
25 #include "nasl_lex_ctxt.h"
26 #include "nasl_tree.h"
27 
28 #include <glib.h> /* for g_free */
29 #include <stdlib.h> /* for abort */
30 #include <string.h> /* for strlen */
31 
32 /* Local prototypes */
33 static void
34 copy_array (nasl_array *, const nasl_array *, int);
35 
37 int
38 hash_str2 (const char *s, int n)
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 }
50 
51 static int
52 hash_str (const char *s)
53 {
54  return hash_str2 (s, VAR_NAME_HASH);
55 }
56 
58 nasl_get_var_by_num (void *ctxt, nasl_array *a, int num, int create)
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 }
88 
89 static named_nasl_var *
90 get_var_by_name (nasl_array *a, const char *s)
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 }
110 
114 static named_nasl_var *
115 get_var_ref_by_name (lex_ctxt *ctxt, const char *name, int climb)
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 }
151 
152 static anon_nasl_var *
153 get_var_ref_by_num (lex_ctxt *ctxt, int 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 }
181 
182 tree_cell *
184 {
186  tc->x.ref_val = v; /* No need to free this later! */
187  return tc;
188 }
189 
190 tree_cell *
191 get_variable_by_name (lex_ctxt *ctxt, const char *name)
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*/}
209 
210  static const char *
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  }
221 
222  tree_cell *
223  get_array_elem (lex_ctxt *ctxt, const char *name, tree_cell *idx)
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  }
343 
344  static void
346  static void
348 
353  void
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  }
376 
377  static void
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  }
397 
398  static void
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  }
416 
417  void
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  }
440 
441  static void
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  }
479 
480  static anon_nasl_var *
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  }
492 
493  static named_nasl_var *
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  }
506 
507  static void
508  copy_array (nasl_array *a1, const nasl_array *a2, int copy_named)
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  }
547 
548  tree_cell *
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  }
562 
563  extern FILE *nasl_trace_fp;
564 
565  static tree_cell *
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  }
710 
711  tree_cell *
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  }
732 
733  static named_nasl_var *
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  }
753 
754  static anon_nasl_var *
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  }
771 
772  tree_cell *
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  }
784 
785  tree_cell *
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  }
794 
795  anon_nasl_var *
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  }
823 
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  }
845 
846  tree_cell *
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  }
931 
932  tree_cell *
933  nasl_incr_variable (lex_ctxt *lexic, tree_cell *tc, int pre, int val)
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  }
980 
981  static long int
982  var2int (anon_nasl_var *v, int defval)
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*/}
1002 
1003  char *
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  }
1074 
1075  const char *
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  }
1104 
1105  long int
1106  get_int_var_by_num (lex_ctxt *lexic, int num, int defval)
1107  {
1108  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1109  return var2int (v, defval);
1110  }
1111 
1112  long int
1113  get_int_var_by_name (lex_ctxt *lexic, const char *name, int defval)
1114  {
1115  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1116  return var2int (&v->u, defval);
1117  }
1118 
1119  char *
1120  get_str_var_by_num (lex_ctxt *lexic, int num)
1121  {
1122  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1123  return (char *) var2str (v);
1124  }
1125 
1126  char *
1127  get_str_var_by_name (lex_ctxt *lexic, const char *name)
1128  {
1129  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1130  return (char *) var2str (&v->u);
1131  }
1132  static int
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  }
1145 
1146  int
1147  get_var_size_by_name (lex_ctxt *lexic, const char *name)
1148  {
1149  named_nasl_var *v = get_var_ref_by_name (lexic, name, 0);
1150  return get_var_size (&v->u);
1151  }
1152 
1153  int
1154  get_var_size_by_num (lex_ctxt *lexic, int num)
1155  {
1156  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1157  return get_var_size (v);
1158  }
1159 
1163  int
1164  get_var_type_by_num (lex_ctxt *lexic, int num)
1165  {
1166  anon_nasl_var *v = get_var_ref_by_num (lexic, num);
1167  return v == NULL ? VAR2_UNDEF : v->var_type;
1168  }
1169 
1170  int
1171  get_var_type_by_name (lex_ctxt *lexic, const char *name)
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  }
1176 
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  }
1212 
1213  tree_cell *
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  }
1252 
1253  int
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  }
1284 
1285  int
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  }
1305 
1310  int
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  }
1326 
1331  tree_cell *
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  }
nasl_iterator::i1
int i1
Definition: nasl_var.h:79
st_a_nasl_var
Definition: nasl_var.h:50
get_var_name
static const char * get_var_name(anon_nasl_var *v)
Definition: nasl_var.c:211
nasl_type_name
const char * nasl_type_name(int t)
Definition: nasl_tree.c:357
free_array
void free_array(nasl_array *a)
Definition: nasl_var.c:354
VAR2_ARRAY
@ VAR2_ARRAY
Definition: nasl_var.h:30
struct_lex_ctxt::ctx_vars
nasl_array ctx_vars
Definition: nasl_lex_ctxt.h:46
dup_anon_var
static anon_nasl_var * dup_anon_var(const anon_nasl_var *v)
Definition: nasl_var.c:481
CONST_DATA
@ CONST_DATA
Definition: nasl_tree.h:93
nasl_trace
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
nasl_trace_fp
FILE * nasl_trace_fp
Definition: exec.c:368
nasl_incr_variable
tree_cell * nasl_incr_variable(lex_ctxt *lexic, tree_cell *tc, int pre, int val)
Definition: nasl_var.c:933
TC::str_val
char * str_val
Definition: nasl_tree.h:112
create_named_var
static named_nasl_var * create_named_var(const char *name, tree_cell *val)
Definition: nasl_var.c:734
get_var_ref_by_num
static anon_nasl_var * get_var_ref_by_num(lex_ctxt *ctxt, int num)
Definition: nasl_var.c:153
nasl_iterate_array
tree_cell * nasl_iterate_array(nasl_iterator *it)
Definition: nasl_var.c:1214
copy_array
static void copy_array(nasl_array *, const nasl_array *, int)
Definition: nasl_var.c:508
CONST_STR
@ CONST_STR
Definition: nasl_tree.h:91
st_n_nasl_var
Definition: nasl_var.h:65
var2str
const char * var2str(anon_nasl_var *v)
Definition: nasl_var.c:1076
get_str_var_by_num
char * get_str_var_by_num(lex_ctxt *lexic, int num)
Definition: nasl_var.c:1120
decl_global_variables
tree_cell * decl_global_variables(lex_ctxt *lexic, tree_cell *vars)
Definition: nasl_var.c:786
array2str
char * array2str(const nasl_array *a)
Definition: nasl_var.c:1004
st_nasl_array::max_idx
int max_idx
Definition: nasl_var.h:45
st_a_nasl_var::v_arr
nasl_array v_arr
Definition: nasl_var.h:60
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: nasl_var.c:1164
st_nasl_array::hash_elt
struct st_n_nasl_var ** hash_elt
Definition: nasl_var.h:47
hash_str2
int hash_str2(const char *s, int n)
Definition: nasl_var.c:38
DYN_ARRAY
@ DYN_ARRAY
Definition: nasl_tree.h:101
FAKE_CELL
#define FAKE_CELL
Definition: nasl_tree.h:119
TC::x
union TC::@2 x
st_n_nasl_var::var_name
char * var_name
Definition: nasl_var.h:69
create_anon_var
static anon_nasl_var * create_anon_var(tree_cell *val)
Definition: nasl_var.c:755
st_a_nasl_var::v_str
nasl_string_t v_str
Definition: nasl_var.h:58
clear_anon_var
void clear_anon_var(anon_nasl_var *v)
Definition: nasl_var.c:418
exec.h
st_nasl_string::s_siz
int s_siz
Definition: nasl_var.h:38
name
const char * name
Definition: nasl_init.c:377
st_nasl_array
Definition: nasl_var.h:43
free_var_chain
static void free_var_chain(named_nasl_var *)
Definition: nasl_var.c:378
nasl_read_var_ref
tree_cell * nasl_read_var_ref(lex_ctxt *lexic, tree_cell *tc)
Definition: nasl_var.c:847
nasl_affect
tree_cell * nasl_affect(tree_cell *lval, tree_cell *rval)
Definition: nasl_var.c:712
struct_lex_ctxt::up_ctxt
struct struct_lex_ctxt * up_ctxt
Definition: nasl_lex_ctxt.h:35
get_var_size_by_num
int get_var_size_by_num(lex_ctxt *lexic, int num)
Definition: nasl_var.c:1154
nasl_iterator::v
named_nasl_var * v
Definition: nasl_var.h:81
nasl_debug.h
get_var_by_name
static named_nasl_var * get_var_by_name(nasl_array *a, const char *s)
Definition: nasl_var.c:90
get_str_var_by_name
char * get_str_var_by_name(lex_ctxt *lexic, const char *name)
Definition: nasl_var.c:1127
st_n_nasl_var::next_var
struct st_n_nasl_var * next_var
Definition: nasl_var.h:73
affect_to_anon_var
static tree_cell * affect_to_anon_var(anon_nasl_var *v1, tree_cell *rval)
Definition: nasl_var.c:566
nasl_iterator::iH
int iH
Definition: nasl_var.h:80
nasl_perror
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
copy_anon_var
static void copy_anon_var(anon_nasl_var *v1, const anon_nasl_var *v2)
Definition: nasl_var.c:442
nasl_trace_enabled
int nasl_trace_enabled(void)
Checks if the nasl_trace_fp is set.
Definition: nasl_debug.c:170
add_var_to_array
int add_var_to_array(nasl_array *a, char *name, const anon_nasl_var *v)
Definition: nasl_var.c:1286
get_var_size
static int get_var_size(const anon_nasl_var *v)
Definition: nasl_var.c:1133
VAR2_UNDEF
@ VAR2_UNDEF
Definition: nasl_var.h:26
TC::size
int size
Definition: nasl_tree.h:109
nasl_lex_ctxt.h
nasl_array_iterator
nasl_iterator nasl_array_iterator(void *ctxt, tree_cell *c)
Definition: nasl_var.c:1178
var2cell
tree_cell * var2cell(anon_nasl_var *v)
Definition: nasl_var.c:183
TC::line_nb
short line_nb
Definition: nasl_tree.h:107
get_int_var_by_num
long int get_int_var_by_num(lex_ctxt *lexic, int num, int defval)
Definition: nasl_var.c:1106
get_array_elem
tree_cell * get_array_elem(lex_ctxt *ctxt, const char *name, tree_cell *idx)
Definition: nasl_var.c:223
VAR2_DATA
@ VAR2_DATA
Definition: nasl_var.h:29
struct_lex_ctxt::fct_ctxt
unsigned fct_ctxt
Definition: nasl_lex_ctxt.h:37
nasl_func.h
TC::ref_val
void * ref_val
Definition: nasl_tree.h:114
dup_named_var
static named_nasl_var * dup_named_var(const named_nasl_var *v)
Definition: nasl_var.c:494
st_a_nasl_var::var_type
int var_type
Definition: nasl_var.h:52
get_line_nb
char * get_line_nb(const tree_cell *c)
Definition: nasl_tree.c:390
alloc_expr_cell
tree_cell * alloc_expr_cell(int lnb, int t, tree_cell *l, tree_cell *r)
Definition: nasl_tree.c:74
make_array_from_elems
tree_cell * make_array_from_elems(tree_cell *el)
Definition: nasl_var.c:1332
TC
Definition: nasl_tree.h:104
struct_lex_ctxt
Definition: nasl_lex_ctxt.h:33
get_variable_by_name
tree_cell * get_variable_by_name(lex_ctxt *ctxt, const char *name)
Definition: nasl_var.c:191
TC::type
short type
Definition: nasl_tree.h:106
TC::link
struct TC * link[4]
Definition: nasl_tree.h:116
nasl_var.h
decl_local_variables
tree_cell * decl_local_variables(lex_ctxt *lexic, tree_cell *vars)
Definition: nasl_var.c:773
st_a_nasl_var::string_form
char * string_form
Definition: nasl_var.h:62
REF_VAR
@ REF_VAR
Definition: nasl_tree.h:99
nasl_global_ctxt.h
CONST_INT
@ CONST_INT
Definition: nasl_tree.h:90
val
const char * val
Definition: nasl_init.c:378
var2int
static long int var2int(anon_nasl_var *v, int defval)
Definition: nasl_var.c:982
add_named_var_to_ctxt
named_nasl_var * add_named_var_to_ctxt(lex_ctxt *lexic, const char *name, tree_cell *val)
Definition: nasl_var.c:825
nasl_iterator::a
nasl_array * a
Definition: nasl_var.h:78
hash_str
static int hash_str(const char *s)
Definition: nasl_var.c:52
nasl_iterator
Definition: nasl_var.h:76
copy_ref_array
tree_cell * copy_ref_array(const tree_cell *c1)
Definition: nasl_var.c:549
add_var_to_list
int add_var_to_list(nasl_array *a, int i, const anon_nasl_var *v)
Definition: nasl_var.c:1254
st_a_nasl_var::v
union st_a_nasl_var::@4 v
VAR2_STRING
@ VAR2_STRING
Definition: nasl_var.h:28
get_var_size_by_name
int get_var_size_by_name(lex_ctxt *lexic, const char *name)
Definition: nasl_var.c:1147
get_var_type_by_name
int get_var_type_by_name(lex_ctxt *lexic, const char *name)
Definition: nasl_var.c:1171
get_var_ref_by_name
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
st_a_nasl_var::v_int
long int v_int
Definition: nasl_var.h:59
REF_ARRAY
@ REF_ARRAY
Definition: nasl_tree.h:100
free_anon_var
static void free_anon_var(anon_nasl_var *)
Definition: nasl_var.c:399
deref_cell
void deref_cell(tree_cell *c)
Definition: nasl_tree.c:192
alloc_typed_cell
tree_cell * alloc_typed_cell(int typ)
Definition: nasl_tree.c:40
add_numbered_var_to_ctxt
anon_nasl_var * add_numbered_var_to_ctxt(lex_ctxt *lexic, int num, tree_cell *val)
Definition: nasl_var.c:796
st_n_nasl_var::u
struct st_a_nasl_var u
Definition: nasl_var.h:67
VAR2_INT
@ VAR2_INT
Definition: nasl_var.h:27
get_int_var_by_name
long int get_int_var_by_name(lex_ctxt *lexic, const char *name, int defval)
Definition: nasl_var.c:1113
NODE_EMPTY
@ NODE_EMPTY
Definition: nasl_tree.h:24
nasl_tree.h
VAR_NAME_HASH
#define VAR_NAME_HASH
Definition: nasl_var.h:33
nasl_get_var_by_num
anon_nasl_var * nasl_get_var_by_num(void *ctxt, nasl_array *a, int num, int create)
Definition: nasl_var.c:58
st_nasl_string::s_val
unsigned char * s_val
Definition: nasl_var.h:37
TC::i_val
long int i_val
Definition: nasl_tree.h:113
array_max_index
int array_max_index(nasl_array *a)
Definition: nasl_var.c:1311
st_nasl_array::num_elt
struct st_a_nasl_var ** num_elt
Definition: nasl_var.h:46