28 #include <glib/gstdio.h> 31 #include "../misc/openvas_logging.h" 32 #include "../misc/prefs.h" 33 #include "../misc/plugutils.h" 34 #include "../base/nvticache.h" 53 #include <sys/resource.h> 87 flag = cell2bool (lexic, c2);
111 if (*p !=
'\0' && warn)
116 "Converting the non numeric string '%s' in variable " 117 "'%s' to integer does not make sense in this " 122 "Converting the non numeric string '%s' to " 123 "integer does not make sense in this context",
134 x = cell2int3 (lexic, c2, warn, v);
143 return cell2int3 (lexic, c, 0, NULL);
149 return cell2int3 (lexic, c, 1, NULL);
153 int2cell (
long int x)
163 return int2cell (x != 0);
176 nasl_perror (lexic,
"Cannot convert NULL or FAKE cell to string\n");
184 return g_strdup_printf (
"%ld", c->
x.
i_val);
192 p = g_malloc0 (c->
size + 1);
204 p = cell2str (lexic, c2);
242 int flag, typ, typ1, typ2;
245 int len_s1, len_s2, len_min;
273 if (typ1 == 0 && typ2 == 0)
290 nasl_perror (lexic,
"cell_cmp: converting integer to string\n");
316 n1 = cell2str (lexic, c1);
317 n2 = cell2str (lexic, c2);
318 nasl_perror (lexic,
"cell_cmp: comparing '%s' of type %s and '%s' of " 319 "type %s does not make sense\n",
332 x1 = cell2int (lexic, c1);
333 x2 = cell2int (lexic, c2);
340 s1 = cell2str (lexic, c1);
346 len_s1 = strlen (s1);
348 s2 = cell2str (lexic, c2);
354 len_s2 = strlen (s2);
356 len_min = len_s1 < len_s2 ? len_s1 : len_s2;
360 flag = memcmp (s1, s2, len_min);
362 flag = len_s1 - len_s2;
391 nasl_dump_expr (FILE * fp,
const tree_cell * c)
394 fprintf (fp,
"NULL");
396 fprintf (fp,
"FAKE");
405 nasl_dump_expr (fp, c->
link[0]);
406 fprintf (fp,
") && (");
407 nasl_dump_expr (fp, c->
link[1]);
412 nasl_dump_expr (fp, c->
link[0]);
413 fprintf (fp,
") || (");
414 nasl_dump_expr (fp, c->
link[1]);
419 nasl_dump_expr (fp, c->
link[0]);
424 nasl_dump_expr (fp, c->
link[0]);
425 fprintf (fp,
") + (");
426 nasl_dump_expr (fp, c->
link[1]);
431 nasl_dump_expr (fp, c->
link[0]);
432 fprintf (fp,
") - (");
433 nasl_dump_expr (fp, c->
link[1]);
438 if (c->
link[0] == NULL)
441 nasl_dump_expr (fp, c->
link[1]);
445 nasl_dump_expr (fp, c->
link[0]);
450 if (c->
link[0] == NULL)
453 nasl_dump_expr (fp, c->
link[1]);
457 nasl_dump_expr (fp, c->
link[0]);
465 nasl_dump_expr (fp, c->
link[0]);
466 fprintf (fp,
") ** (");
467 nasl_dump_expr (fp, c->
link[1]);
472 fprintf (fp,
" - (");
473 nasl_dump_expr (fp, c->
link[0]);
479 nasl_dump_expr (fp, c->
link[0]);
480 fprintf (fp,
") * (");
481 nasl_dump_expr (fp, c->
link[1]);
486 nasl_dump_expr (fp, c->
link[0]);
487 fprintf (fp,
") / (");
488 nasl_dump_expr (fp, c->
link[1]);
493 nasl_dump_expr (fp, c->
link[0]);
494 fprintf (fp,
") %% (");
495 nasl_dump_expr (fp, c->
link[1]);
500 nasl_dump_expr (fp, c->
link[0]);
501 fprintf (fp,
") & (");
502 nasl_dump_expr (fp, c->
link[1]);
507 nasl_dump_expr (fp, c->
link[0]);
508 fprintf (fp,
") | (");
509 nasl_dump_expr (fp, c->
link[1]);
514 nasl_dump_expr (fp, c->
link[0]);
515 fprintf (fp,
") ^ (");
516 nasl_dump_expr (fp, c->
link[1]);
521 nasl_dump_expr (fp, c->
link[0]);
526 nasl_dump_expr (fp, c->
link[0]);
527 fprintf (fp,
") << (");
528 nasl_dump_expr (fp, c->
link[1]);
533 nasl_dump_expr (fp, c->
link[0]);
534 fprintf (fp,
") >> (");
535 nasl_dump_expr (fp, c->
link[1]);
540 nasl_dump_expr (fp, c->
link[0]);
541 fprintf (fp,
") >>> (");
542 nasl_dump_expr (fp, c->
link[1]);
546 nasl_dump_expr (fp, c->
link[0]);
547 fprintf (fp,
" >< ");
548 nasl_dump_expr (fp, c->
link[1]);
551 nasl_dump_expr (fp, c->
link[0]);
552 fprintf (fp,
" >!< ");
553 nasl_dump_expr (fp, c->
link[1]);
557 nasl_dump_expr (fp, c->
link[0]);
558 fprintf (fp,
" =~ ");
559 nasl_dump_expr (fp, c->
link[1]);
563 nasl_dump_expr (fp, c->
link[0]);
564 fprintf (fp,
" !~ ");
565 nasl_dump_expr (fp, c->
link[1]);
569 nasl_dump_expr (fp, c->
link[0]);
571 nasl_dump_expr (fp, c->
link[1]);
574 nasl_dump_expr (fp, c->
link[0]);
575 fprintf (fp,
" <= ");
576 nasl_dump_expr (fp, c->
link[1]);
579 nasl_dump_expr (fp, c->
link[0]);
581 nasl_dump_expr (fp, c->
link[1]);
584 nasl_dump_expr (fp, c->
link[0]);
585 fprintf (fp,
" >= ");
586 nasl_dump_expr (fp, c->
link[1]);
589 nasl_dump_expr (fp, c->
link[0]);
590 fprintf (fp,
" == ");
591 nasl_dump_expr (fp, c->
link[1]);
594 fprintf (fp,
"%ld", c->
x.
i_val);
598 fprintf (fp,
"\"%s\"", c->
x.
str_val);
603 nasl_dump_expr (fp, c->
link[0]);
608 fprintf (fp,
"%s(...)", c->
x.
str_val);
612 nasl_dump_expr (fp, c->
link[0]);
614 nasl_dump_expr (fp, c->
link[1]);
618 nasl_dump_expr (fp, c->
link[0]);
619 fprintf (fp,
"+= (");
620 nasl_dump_expr (fp, c->
link[1]);
625 nasl_dump_expr (fp, c->
link[0]);
626 fprintf (fp,
"-= (");
627 nasl_dump_expr (fp, c->
link[1]);
632 nasl_dump_expr (fp, c->
link[0]);
633 fprintf (fp,
"*= (");
634 nasl_dump_expr (fp, c->
link[1]);
639 nasl_dump_expr (fp, c->
link[0]);
640 fprintf (fp,
"/= (");
641 nasl_dump_expr (fp, c->
link[1]);
646 nasl_dump_expr (fp, c->
link[0]);
647 fprintf (fp,
"%%= (");
648 nasl_dump_expr (fp, c->
link[1]);
653 nasl_dump_expr (fp, c->
link[0]);
654 fprintf (fp,
" <<= (");
655 nasl_dump_expr (fp, c->
link[1]);
660 nasl_dump_expr (fp, c->
link[0]);
661 fprintf (fp,
" >>= (");
662 nasl_dump_expr (fp, c->
link[1]);
667 nasl_dump_expr (fp, c->
link[0]);
668 fprintf (fp,
" >>>= (");
669 nasl_dump_expr (fp, c->
link[1]);
674 fprintf (fp,
"*%d*", c->
type);
680 nasl_short_dump (FILE * fp,
const tree_cell * c)
688 fprintf (fp,
"NASL:%04d> if (", c->
line_nb);
689 nasl_dump_expr (fp, c->
link[0]);
690 fprintf (fp,
") { ... }");
691 if (c->
link[2] != NULL)
692 fprintf (fp,
" else { ... }");
697 fprintf (fp,
"NASL:%04d> for (", c->
line_nb);
698 nasl_dump_expr (fp, c->
link[0]);
700 nasl_dump_expr (fp, c->
link[1]);
702 nasl_dump_expr (fp, c->
link[2]);
703 fprintf (fp,
") { ... }\n");
707 fprintf (fp,
"NASL:%04d> while (", c->
line_nb);
708 nasl_dump_expr (fp, c->
link[0]);
709 fprintf (fp,
") { ... }\n");
714 nasl_dump_expr (fp, c->
link[0]);
715 fprintf (fp,
") { ... }\n");
719 fprintf (fp,
"NASL:%04d> repeat { ... } until (", c->
line_nb);
720 nasl_dump_expr (fp, c->
link[0]);
725 fprintf (fp,
"NASL:%04d> ... x ", c->
line_nb);
726 nasl_dump_expr (fp, c->
link[1]);
731 fprintf (fp,
"NASL:%04d> return ", c->
line_nb);
732 nasl_dump_expr (fp, c->
link[0]);
737 fprintf (fp,
"NASL:%04d> break\n", c->
line_nb);
741 fprintf (fp,
"NASL:%04d> continue\n", c->
line_nb);
753 fprintf (fp,
"NASL:%04d> ", c->
line_nb);
754 nasl_dump_expr (fp, c);
763 fprintf (fp,
"NASL:%04d> local_var ...\n", c->
line_nb);
767 fprintf (fp,
"NASL:%04d> global_var ...\n", c->
line_nb);
802 tree_cell *ret = NULL, *ret2 = NULL, *tc1 = NULL, *tc2 = NULL, *tc3 =
803 NULL, *idx = NULL, *args;
805 char *s1 = NULL, *s2 = NULL, *s3 = NULL, *p = NULL;
849 #ifdef STOP_AT_FIRST_ERROR 853 if (cell2bool (lexic, ret))
855 else if (st->
link[2] != NULL)
866 nasl_perror (lexic,
"Instruction failed. Going on in block\n");
877 #ifdef STOP_AT_FIRST_ERROR 894 flag = cell2bool (lexic, ret);
900 #ifdef STOP_AT_FIRST_ERROR 917 #ifdef STOP_AT_FIRST_ERROR 938 flag = cell2bool (lexic, ret);
944 #ifdef STOP_AT_FIRST_ERROR 972 #ifdef STOP_AT_FIRST_ERROR 988 #ifdef STOP_AT_FIRST_ERROR 992 flag = cell2bool (lexic, ret);
1016 #ifdef STOP_AT_FIRST_ERROR 1052 printf (
"****************\n");
1054 printf (
"****************\n");
1060 n = cell2intW (lexic, st->
link[1]);
1064 #ifdef STOP_AT_FIRST_ERROR 1065 for (tc1 = NULL, i = 1; i <= n; i++)
1073 for (i = 1; i <= n; i++)
1218 x = cell2bool (lexic, st->
link[0]);
1220 return bool2cell (0);
1222 y = cell2bool (lexic, st->
link[1]);
1223 return bool2cell (y);
1227 x = cell2bool (lexic, st->
link[0]);
1229 return bool2cell (x);
1230 y = cell2bool (lexic, st->
link[1]);
1231 return bool2cell (y);
1234 x = cell2bool (lexic, st->
link[0]);
1235 return bool2cell (!x);
1240 if (st->
link[0] == NULL)
1257 if (st->
link[0] == NULL)
1266 #ifdef STOP_AT_FIRST_ERROR 1273 #ifdef STOP_AT_FIRST_ERROR 1300 "Horrible type conversion (int -> str) for operator + %s\n",
1308 y = cell2int (lexic, tc2);
1309 ret = int2cell (x + y);
1319 s1 = cell2str (lexic, tc1);
1320 len1 = (s1 == NULL ? 0 : strlen (s1));
1327 s2 = cell2str (lexic, tc2);
1328 len2 = (s2 == NULL ? 0 : strlen (s2));
1332 s3 = g_malloc0 (sz + 1);
1334 memcpy (s3, s1 != NULL ? s1 : tc1->x.str_val, len1);
1336 memcpy (s3 + len1, s2 != NULL ? s2 : tc2->x.str_val, len2);
1355 #ifdef STOP_AT_FIRST_ERROR 1362 #ifdef STOP_AT_FIRST_ERROR 1374 y = cell2int (lexic, tc2);
1375 ret = int2cell (-y);
1400 "Horrible type conversion (int -> str) for operator - %s\n",
1406 x = cell2int (lexic, tc1);
1407 y = cell2int (lexic, tc2);
1408 ret = int2cell (x - y);
1415 p1 = tc1->x.str_val;
1420 p1 = s1 = cell2str (lexic, tc1);
1421 len1 = (s1 == NULL ? 0 : strlen (s1));
1426 p2 = tc2->x.str_val;
1431 p2 = s2 = cell2str (lexic, tc2);
1432 len2 = (s2 == NULL ? 0 : strlen (s2));
1435 if (len2 == 0 || len1 < len2
1436 || (p = memmem (p1, len1, p2, len2)) == NULL)
1438 s3 = g_malloc0 (len1 + 1);
1439 memcpy (s3, p1, len1);
1446 long sz = len1 - len2;
1454 s3 = g_malloc0 (sz + 1);
1456 memcpy (s3, p1, p - p1);
1458 memcpy (s3 + (p - p1), p + len2, sz - (p - p1));
1478 x = cell2intW (lexic, st->
link[0]);
1479 y = cell2intW (lexic, st->
link[1]);
1480 return int2cell (x * y);
1483 x = cell2intW (lexic, st->
link[0]);
1484 y = cell2intW (lexic, st->
link[1]);
1486 return int2cell (x / y);
1488 return int2cell (0);
1491 x = cell2intW (lexic, st->
link[0]);
1492 y = cell2intW (lexic, st->
link[1]);
1493 return int2cell (expo (x, y));
1496 x = cell2intW (lexic, st->
link[0]);
1497 y = cell2intW (lexic, st->
link[1]);
1499 return int2cell (x % y);
1501 return int2cell (0);
1504 x = cell2intW (lexic, st->
link[0]);
1505 y = cell2intW (lexic, st->
link[1]);
1506 return int2cell (x & y);
1509 x = cell2intW (lexic, st->
link[0]);
1510 y = cell2intW (lexic, st->
link[1]);
1511 return int2cell (x | y);
1514 x = cell2intW (lexic, st->
link[0]);
1515 y = cell2intW (lexic, st->
link[1]);
1516 return int2cell (x ^ y);
1519 x = cell2intW (lexic, st->
link[0]);
1520 return int2cell (~x);
1523 x = cell2intW (lexic, st->
link[0]);
1524 return int2cell (-x);
1528 x = cell2intW (lexic, st->
link[0]);
1529 y = cell2intW (lexic, st->
link[1]);
1530 return int2cell (x << y);
1533 x = cell2intW (lexic, st->
link[0]);
1534 y = cell2intW (lexic, st->
link[1]);
1537 nasl_perror (lexic,
"Warning: Negative count in right shift!\n");
1541 if (x < 0 && z >= 0)
1545 "Warning: arithmetic right shift is buggy! Fixing...\n");
1547 z |= (~0) << (
sizeof (x) * 8 - y);
1550 return int2cell (z);
1553 x = cell2intW (lexic, st->
link[0]);
1554 y = cell2intW (lexic, st->
link[1]);
1557 nasl_perror (lexic,
"Warning: Negative count in right shift!\n");
1559 z = (unsigned) x >> (
unsigned) y;
1561 if (x < 0 && z <= 0)
1565 "Warning: Logical right shift is buggy! Fixing...\n");
1567 z &= ~((~0) << (
sizeof (x) * 8 - y));
1570 return int2cell (z);
1585 p1 = tc1->x.str_val;
1592 "Horrible type conversion (%s -> str) for operator >< or >!< %s\n",
1595 p1 = s1 = cell2str (lexic, tc1);
1606 p2 = tc2->x.str_val;
1613 "Horrible type conversion (%s -> str) for operator >< or >!< %s\n",
1616 p2 = s2 = cell2str (lexic, tc2);
1621 flag = (memmem (p2, len2, p1, len1) != NULL);
1630 return bool2cell (flag);
1632 return bool2cell (!flag);
1638 nasl_perror (lexic,
"nasl_exec: bad regex at or near line %d\n",
1642 s1 = cell2str (lexic, st->
link[0]);
1645 flag = regexec (st->
x.
ref_val, s1, 0, NULL, 0);
1648 return bool2cell (flag != REG_NOMATCH);
1650 return bool2cell (flag == REG_NOMATCH);
1712 const char *
oid,
int mode)
1716 int err = 0, to, process_id;
1725 srand48 (getpid () + getppid () + (
long) time (NULL));
1727 old_dir = g_get_current_dir ();
1732 if ((old =
arg_get_value (script_infos,
"script_name")) == NULL)
1740 newdir = g_path_get_dirname (
name);
1742 if (g_chdir (newdir) != 0)
1750 bzero (&ctx,
sizeof (ctx));
1786 str =
prefs_get (
"checks_read_timeout");
1803 process_id = getpid ();
1813 bzero (&tc,
sizeof (tc));
1818 bzero (&tc,
sizeof (tc));
1824 p = strrchr (
name,
'/');
1830 tc.
size = strlen (p);
1847 if (getrusage (RUSAGE_SELF, &ru) < 0)
1848 perror (
"getrusage");
1852 "rusage: utime=%d.%03d stime=%d.%03d minflt=%d majflt=%d nswap=%d\n",
1853 ru.ru_utime.tv_sec, ru.ru_utime.tv_usec / 1000,
1854 ru.ru_stime.tv_sec, ru.ru_stime.tv_usec / 1000,
1855 ru.ru_minflt, ru.ru_majflt, ru.ru_nswap);
1864 if (g_chdir (old_dir) != 0)
1873 if (process_id != getpid ())
tree_cell * nasl_return(lex_ctxt *ctxt, tree_cell *retv)
void ref_cell(tree_cell *c)
int arg_set_value(struct arglist *arglst, const char *name, void *value)
#define NASL_EXEC_PARSE_ONLY
void nasl_clean_ctx(naslctxt *)
void nasl_dump_tree(const tree_cell *c)
tree_cell * cell2atom(lex_ctxt *lexic, tree_cell *c1)
void deref_cell(tree_cell *c)
void nasl_set_filename(const char *filename)
void log_legacy_write(const char *format,...)
Legacy function to write a log message.
int init_nasl_ctx(naslctxt *, const char *)
Initialize a NASL context for a NASL file.
const gchar * prefs_get(const gchar *key)
Get a string preference value via a key.
tree_cell * nasl_lint(lex_ctxt *, tree_cell *)
void free_lex_ctxt(lex_ctxt *c)
tree_cell * nasl_incr_variable(lex_ctxt *, tree_cell *, int, int)
int exec_nasl_script(struct arglist *script_infos, const char *name, const char *oid, int mode)
Execute a NASL script.
kb_t plug_get_kb(struct arglist *args)
#define NASL_COMMAND_LINE
tree_cell * decl_local_variables(lex_ctxt *, tree_cell *)
lex_ctxt * init_empty_lex_ctxt()
tree_cell * get_variable_by_name(lex_ctxt *, const char *)
void arg_add_value(struct arglist *arglst, const char *name, int type, void *value)
named_nasl_var * add_named_var_to_ctxt(lex_ctxt *, const char *, tree_cell *)
char * array2str(const nasl_array *a)
int nvticache_initialized(void)
Return whether the nvt cache is initialized.
long int cell_cmp(lex_ctxt *lexic, tree_cell *c1, tree_cell *c2)
void nasl_perror(lex_ctxt *lexic, char *msg,...)
kb_t nvticache_get_kb(void)
Return the nvticache kb.
#define NASL_ALWAYS_SIGNED
int init_nasl_library(lex_ctxt *lexic)
Adds "built-in" variable and function definitions to a context.
tree_cell * nasl_func_call(lex_ctxt *lexic, const nasl_func *f, tree_cell *arg_list)
tree_cell * get_array_elem(lex_ctxt *, const char *, tree_cell *)
int naslparse(naslctxt *)
nasl_iterator nasl_array_iterator(void *ctxt, tree_cell *c)
tree_cell * nasl_iterate_array(nasl_iterator *it)
tree_cell * alloc_tree_cell(int lnb, char *s)
const char * nasl_type_name(int t)
tree_cell * nasl_read_var_ref(lex_ctxt *, tree_cell *)
int cell_type(const tree_cell *c)
struct arglist * script_infos
char * get_line_nb(const tree_cell *c)
void * arg_get_value(struct arglist *args, const char *name)
tree_cell * alloc_expr_cell(int lnb, int t, tree_cell *l, tree_cell *r)
tree_cell * decl_global_variables(lex_ctxt *, tree_cell *)
tree_cell * nasl_affect(tree_cell *lval, tree_cell *rval)
nasl_func * get_func_ref_by_name(lex_ctxt *ctxt, const char *name)
tree_cell * nasl_exec(lex_ctxt *lexic, tree_cell *st)
Execute a parse tree.
tree_cell * decl_nasl_func(lex_ctxt *lexic, tree_cell *decl_node)