OpenVAS Scanner  7.0.1~git
nasl_scanner_glue.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 
28 #include "nasl_scanner_glue.h"
29 
30 #include "../misc/network.h" /* for getpts */
31 #include "../misc/plugutils.h" /* for plug_set_id */
32 #include "../misc/vendorversion.h" /* for vendor_version_get */
33 #include "nasl_debug.h"
34 #include "nasl_func.h"
35 #include "nasl_global_ctxt.h"
36 #include "nasl_lex_ctxt.h"
37 #include "nasl_tree.h"
38 #include "nasl_var.h"
39 
40 #include <ctype.h> /* for isdigit */
41 #include <errno.h> /* for errno */
42 #include <fcntl.h> /* for open */
43 #include <glib.h>
44 #include <gvm/base/logging.h>
45 #include <gvm/base/prefs.h> /* for prefs_get */
46 #include <gvm/util/kb.h> /* for KB_TYPE_INT */
47 #include <stdlib.h> /* for atoi */
48 #include <string.h> /* for strcmp */
49 #include <sys/stat.h> /* for stat */
50 #include <unistd.h> /* for close */
51 
52 #undef G_LOG_DOMAIN
53 
56 #define G_LOG_DOMAIN "lib nasl"
57 
58 /*------------------- Private utilities ---------------------------------*/
59 
60 static int
61 isalldigit (char *str, int len)
62 {
63  int i;
64  char buf[1024];
65  for (i = 0; i < len; i++)
66  {
67  if (!isdigit (str[i]))
68  return 0;
69  }
70 
71  snprintf (buf, sizeof (buf), "%d", atoi (str));
72  if (strcmp (buf, str) != 0)
73  return 0;
74  else
75  return 1;
76 }
77 
78 /*-------------------[ script_*() functions ]----------------------------*/
79 
80 /*
81  * These functions are used when the script registers itself to openvas
82  * scanner.
83  */
84 
85 tree_cell *
87 {
88  nvti_t *nvti = lexic->script_infos->nvti;
89  int to = get_int_var_by_num (lexic, 0, -65535);
90 
91  if (to == -65535)
92  return FAKE_CELL;
93 
94  nvti_set_timeout (nvti, to ? to : -1);
95  return FAKE_CELL;
96 }
97 
98 tree_cell *
100 {
101  nvti_set_oid (lexic->script_infos->nvti, get_str_var_by_num (lexic, 0));
102  return FAKE_CELL;
103 }
104 
105 tree_cell *
107 {
108  struct script_infos *script_infos = lexic->script_infos;
109  char *cve = get_str_var_by_num (lexic, 0);
110  int i;
111 
112  for (i = 0; cve != NULL; i++)
113  {
114  nvti_add_vtref (script_infos->nvti, vtref_new ("cve", cve, ""));
115  cve = get_str_var_by_num (lexic, i + 1);
116  }
117 
118  return FAKE_CELL;
119 }
120 
121 tree_cell *
123 {
124  struct script_infos *script_infos = lexic->script_infos;
125  char *bid = get_str_var_by_num (lexic, 0);
126  int i;
127 
128  for (i = 0; bid != NULL; i++)
129  {
130  nvti_add_vtref (script_infos->nvti, vtref_new ("bid", bid, ""));
131  bid = get_str_var_by_num (lexic, i + 1);
132  }
133 
134  return FAKE_CELL;
135 }
136 
165 tree_cell *
167 {
168  struct script_infos *script_infos = lexic->script_infos;
169  char *name = get_str_var_by_name (lexic, "name");
170  char *value = get_str_var_by_name (lexic, "value");
171  char *csv = get_str_var_by_name (lexic, "csv");
172 
173  if (((value == NULL) && (csv == NULL)) || name == NULL)
174  {
175  nasl_perror (lexic,
176  "script_xref() syntax error - should be"
177  " script_xref(name:<name>, value:<value>) or"
178  " script_xref(name:<name>, value:<value>, csv:<CSVs>) or"
179  " script_xref(name:<name>, csv:<CSVs>)\n");
180  if (name == NULL)
181  {
182  nasl_perror (lexic, " <name> is empty\n");
183  }
184  else
185  {
186  nasl_perror (lexic, " <name> is %s\n", name);
187  }
188  if ((value == NULL) && (csv == NULL))
189  {
190  nasl_perror (lexic, " <value> and <csv> is empty)\n");
191  }
192  else
193  {
194  nasl_perror (lexic, " <value> is %s\n)", value);
195  nasl_perror (lexic, " <csv> is %s\n)", csv);
196  }
197  return FAKE_CELL;
198  }
199 
200  if (csv)
201  nvti_add_refs (script_infos->nvti, name, csv, "");
202 
203  if (value)
204  nvti_add_vtref (script_infos->nvti, vtref_new (name, value, ""));
205 
206  return FAKE_CELL;
207 }
208 
209 tree_cell *
211 {
212  struct script_infos *script_infos = lexic->script_infos;
213  char *name = get_str_var_by_name (lexic, "name");
214  char *value = get_str_var_by_name (lexic, "value");
215 
216  if (value == NULL || name == NULL)
217  {
218  nasl_perror (lexic, "script_tag() syntax error - should be"
219  " script_tag(name:<name>, value:<value>)\n");
220  if (name == NULL)
221  {
222  nasl_perror (lexic, " <name> is empty\n");
223  }
224  else
225  {
226  nasl_perror (lexic, " <name> is %s\n", name);
227  }
228  if (value == NULL)
229  {
230  nasl_perror (lexic, " <value> is empty)\n");
231  }
232  else
233  {
234  nasl_perror (lexic, " <value> is %s\n)", value);
235  }
236  return FAKE_CELL;
237  }
238 
239  if (strchr (value, '|'))
240  {
241  nasl_perror (lexic, "%s tag contains | separator", name);
242  return FAKE_CELL;
243  }
244  nvti_add_tag (script_infos->nvti, name, value);
245 
246  return FAKE_CELL;
247 }
248 
249 tree_cell *
251 {
252  nvti_set_name (lexic->script_infos->nvti, get_str_var_by_num (lexic, 0));
253  return FAKE_CELL;
254 }
255 
256 tree_cell *
258 {
259  (void) lexic;
260  return FAKE_CELL;
261 }
262 
263 tree_cell *
265 {
266  (void) lexic;
267  return FAKE_CELL;
268 }
269 
270 tree_cell *
272 {
273  struct script_infos *script_infos = lexic->script_infos;
274 
275  int category = get_int_var_by_num (lexic, 0, -1);
276 
277  if (category < 0)
278  {
279  nasl_perror (lexic, "Argument error in function script_category()\n");
280  nasl_perror (lexic, "Function usage is : script_category(<category>)\n");
281  return FAKE_CELL;
282  }
283  nvti_set_category (script_infos->nvti, category);
284  return FAKE_CELL;
285 }
286 
287 tree_cell *
289 {
290  nvti_set_family (lexic->script_infos->nvti, get_str_var_by_num (lexic, 0));
291  return FAKE_CELL;
292 }
293 
294 tree_cell *
296 {
297  struct script_infos *script_infos = lexic->script_infos;
298  char *dep = get_str_var_by_num (lexic, 0);
299  int i;
300 
301  if (dep == NULL)
302  {
303  nasl_perror (lexic, "Argument error in function script_dependencies()\n");
304  nasl_perror (lexic, "Function usage is : script_dependencies(<name>)\n");
305  nasl_perror (lexic, "Where <name> is the name of another script\n");
306 
307  return FAKE_CELL;
308  }
309 
310  for (i = 0; dep != NULL; i++)
311  {
312  dep = get_str_var_by_num (lexic, i);
313  if (dep != NULL)
314  plug_set_dep (script_infos, dep);
315  }
316 
317  return FAKE_CELL;
318 }
319 
320 tree_cell *
322 {
323  char *keys = get_str_var_by_num (lexic, 0);
324  int i;
325 
326  if (keys == NULL)
327  {
328  nasl_perror (lexic, "Argument error in function script_require_keys()\n");
329  nasl_perror (lexic, "Function usage is : script_require_keys(<name>)\n");
330  nasl_perror (lexic, "Where <name> is the name of a key\n");
331  return FAKE_CELL;
332  }
333 
334  for (i = 0; keys != NULL; i++)
335  {
336  keys = get_str_var_by_num (lexic, i);
337  nvti_add_required_keys (lexic->script_infos->nvti, keys);
338  }
339 
340  return FAKE_CELL;
341 }
342 
343 tree_cell *
345 {
346  char *keys = get_str_var_by_num (lexic, 0);
347  char **splits = NULL, *re = get_str_var_by_name (lexic, "re");
348  int i;
349 
350  if (keys == NULL)
351  {
352  nasl_perror (lexic,
353  "Argument error in function script_mandatory_keys()\n");
354  nasl_perror (lexic,
355  "Function usage is : script_mandatory_keys(<name>)\n");
356  nasl_perror (lexic, "Where <name> is the name of a key\n");
357  return FAKE_CELL;
358  }
359 
360  if (re)
361  {
362  splits = g_strsplit (re, "=", 0);
363 
364  if (!splits[0] || !splits[1] || !*splits[1] || splits[2])
365  {
366  nasl_perror (lexic, "Erroneous re argument");
367  return FAKE_CELL;
368  }
369  }
370  for (i = 0; keys != NULL; i++)
371  {
372  keys = get_str_var_by_num (lexic, i);
373 
374  if (splits && keys && !strcmp (keys, splits[0]))
375  {
376  nvti_add_mandatory_keys (lexic->script_infos->nvti, re);
377  re = NULL;
378  }
379  else
380  nvti_add_mandatory_keys (lexic->script_infos->nvti, keys);
381  }
382  if (re)
383  nvti_add_mandatory_keys (lexic->script_infos->nvti, re);
384 
385  g_strfreev (splits);
386  return FAKE_CELL;
387 }
388 
389 tree_cell *
391 {
392  char *keys = get_str_var_by_num (lexic, 0);
393  int i;
394 
395  if (keys == NULL)
396  {
397  nasl_perror (lexic, "Argument error in function script_exclude_keys()\n");
398  nasl_perror (lexic, "Function usage is : script_exclude_keys(<name>)\n");
399  nasl_perror (lexic, "Where <name> is the name of a key\n");
400  return FAKE_CELL;
401  }
402 
403  for (i = 0; keys != NULL; i++)
404  {
405  keys = get_str_var_by_num (lexic, i);
406  nvti_add_excluded_keys (lexic->script_infos->nvti, keys);
407  }
408 
409  return FAKE_CELL;
410 }
411 
412 tree_cell *
414 {
415  char *port;
416  int i;
417 
418  for (i = 0;; i++)
419  {
420  port = get_str_var_by_num (lexic, i);
421  if (port != NULL)
422  nvti_add_required_ports (lexic->script_infos->nvti, port);
423  else
424  break;
425  }
426 
427  return FAKE_CELL;
428 }
429 
430 tree_cell *
432 {
433  int i;
434  char *port;
435 
436  for (i = 0;; i++)
437  {
438  port = get_str_var_by_num (lexic, i);
439  if (port != NULL)
440  nvti_add_required_udp_ports (lexic->script_infos->nvti, port);
441  else
442  break;
443  }
444 
445  return FAKE_CELL;
446 }
447 
448 tree_cell *
450 {
451  int id = get_int_var_by_name (lexic, "id", -1);
452  char *name = get_str_var_by_name (lexic, "name");
453  char *type = get_str_var_by_name (lexic, "type");
454  char *value = get_str_var_by_name (lexic, "value");
455  struct script_infos *script_infos = lexic->script_infos;
456  nvtpref_t *np;
457  unsigned int i;
458 
459  if (!script_infos->nvti)
460  return FAKE_CELL;
461  if (id < 0)
462  id = nvti_pref_len (script_infos->nvti) + 1;
463  if (id == 0)
464  {
465  nasl_perror (lexic,
466  "Invalid id or not allowed id value in the call to %s()\n",
467  __func__);
468  return FAKE_CELL;
469  }
470  if (!name || !type || !value)
471  {
472  nasl_perror (lexic,
473  "Argument error in the call to script_add_preference()\n");
474  return FAKE_CELL;
475  }
476  for (i = 0; i < nvti_pref_len (script_infos->nvti); i++)
477  {
478  if (!strcmp (name, nvtpref_name (nvti_pref (script_infos->nvti, i))))
479  {
480  nasl_perror (lexic, "Preference '%s' already exists\n", name);
481  return FAKE_CELL;
482  }
483  if (id == nvtpref_id (nvti_pref (script_infos->nvti, i)))
484  {
485  nasl_perror (lexic, "Invalid or already existent preference id\n");
486  return FAKE_CELL;
487  }
488  }
489 
490  np = nvtpref_new (id, name, type, value);
491  nvti_add_pref (script_infos->nvti, np);
492  return FAKE_CELL;
493 }
494 
505 tree_cell *
507 {
508  tree_cell *retc;
509  int id = get_int_var_by_name (lexic, "id", -1);
510  char *pref = get_str_var_by_num (lexic, 0);
511  char *value;
512 
513  if (pref == NULL && id == -1)
514  {
515  nasl_perror (lexic,
516  "Argument error in the function script_get_preference()\n");
517  nasl_perror (lexic,
518  "Function usage is : pref = script_get_preference(<name>, "
519  "id:<id>)\n");
520  return FAKE_CELL;
521  }
522 
523  value = get_plugin_preference (lexic->oid, pref, id);
524  if (value != NULL)
525  {
526  retc = alloc_typed_cell (CONST_INT);
527  if (isalldigit (value, strlen (value)))
528  retc->x.i_val = atoi (value);
529  else
530  {
531  retc->type = CONST_DATA;
532  retc->size = strlen (value);
533  retc->x.str_val = g_strdup (value);
534  }
535  g_free (value);
536  return retc;
537  }
538  else
539  return FAKE_CELL;
540 }
541 
542 tree_cell *
544 {
545  struct script_infos *script_infos = lexic->script_infos;
546  tree_cell *retc;
547  char *pref = get_str_var_by_num (lexic, 0);
548  char *value;
549  char *content;
550  int contentsize = 0;
551 
552  if (pref == NULL)
553  {
554  nasl_perror (lexic,
555  "Argument error in the function script_get_preference()\n");
556  nasl_perror (lexic, "Function usage is : pref = "
557  "script_get_preference_file_content(<name>)\n");
558  return NULL;
559  }
560 
561  value = get_plugin_preference (lexic->oid, pref, -1);
562  if (value == NULL)
563  return NULL;
564 
566  contentsize = get_plugin_preference_file_size (script_infos, value);
567  g_free (value);
568  if (content == NULL)
569  return FAKE_CELL;
570  if (contentsize <= 0)
571  {
572  nasl_perror (lexic,
573  "script_get_preference_file_content: could not get "
574  " size of file from preference %s\n",
575  pref);
576  return NULL;
577  }
578 
579  retc = alloc_typed_cell (CONST_DATA);
580  retc->size = contentsize;
581  retc->x.str_val = content;
582 
583  return retc;
584 }
585 
586 tree_cell *
588 {
589  struct script_infos *script_infos = lexic->script_infos;
590  tree_cell *retc;
591  char *pref = get_str_var_by_num (lexic, 0);
592  const char *value, *local;
593  int len;
594 
595  if (pref == NULL)
596  {
597  nasl_perror (
598  lexic, "script_get_preference_file_location: no preference name!\n");
599  return NULL;
600  }
601 
602  value = get_plugin_preference (lexic->oid, pref, -1);
603  if (value == NULL)
604  {
605  nasl_perror (
606  lexic,
607  "script_get_preference_file_location: could not get preference %s\n",
608  pref);
609  return NULL;
610  }
611  local = get_plugin_preference_fname (script_infos, value);
612  if (local == NULL)
613  return NULL;
614 
615  len = strlen (local);
616  retc = alloc_typed_cell (CONST_DATA);
617  retc->size = len;
618  retc->x.str_val = g_malloc0 (len + 1);
619  memcpy (retc->x.str_val, local, len + 1);
620 
621  return retc;
622 }
623 
624 /* Are safe checks enabled ? */
625 tree_cell *
627 {
628  (void) lexic;
630 
631  retc->x.i_val = prefs_get_bool ("safe_checks");
632 
633  return retc;
634 }
635 
636 tree_cell *
638 {
639  struct script_infos *script_infos = lexic->script_infos;
640  struct scan_globals *globals = script_infos->globals;
641  char *value;
643 
644  value = globals->network_scan_status;
645  if (value)
646  {
647  if (strcmp (value, "busy") == 0)
648  retc->x.i_val = 1;
649  else
650  retc->x.i_val = 2;
651  }
652  else
653  retc->x.i_val = 0;
654 
655  return retc;
656 }
657 
658 tree_cell *
660 {
661  struct script_infos *script_infos = lexic->script_infos;
662  struct scan_globals *globals = script_infos->globals;
663  char *value;
664  tree_cell *retc;
665 
666  value = globals->network_targets;
667  retc = alloc_typed_cell (CONST_DATA);
668  if (value)
669  {
670  retc->x.str_val = strdup (value);
671  retc->size = strlen (value);
672  }
673  else
674  return NULL;
675 
676  return retc;
677 }
678 
686 tree_cell *
688 {
689  const char *oid = lexic->oid;
690  tree_cell *retc = NULL;
691 
692  if (oid)
693  {
694  retc = alloc_typed_cell (CONST_DATA);
695  retc->x.str_val = g_strdup (oid);
696  retc->size = strlen (oid);
697  }
698 
699  return retc;
700 }
701 
702 /*--------------------[ KB ]---------------------------------------*/
703 
704 tree_cell *
706 {
707  struct script_infos *script_infos = lexic->script_infos;
708  kb_t kb = plug_get_kb (script_infos);
709  char *kb_mask = get_str_var_by_num (lexic, 0);
710  tree_cell *retc;
711  int num_elems = 0;
712  nasl_array *a;
713  struct kb_item *res, *top;
714 
715  if (kb_mask == NULL)
716  {
717  nasl_perror (lexic, "get_kb_list() usage : get_kb_list(<NameOfItem>)\n");
718  return NULL;
719  }
720 
721  if (kb == NULL)
722  return NULL;
723 
724  retc = alloc_typed_cell (DYN_ARRAY);
725  retc->x.ref_val = a = g_malloc0 (sizeof (nasl_array));
726 
727  if (strchr (kb_mask, '*'))
728  top = res = kb_item_get_pattern (kb, kb_mask);
729  else
730  top = res = kb_item_get_all (kb, kb_mask);
731 
732  while (res != NULL)
733  {
734  anon_nasl_var v;
735  bzero (&v, sizeof (v));
736 
737  if (res->type == KB_TYPE_INT)
738  {
739  v.var_type = VAR2_INT;
740  v.v.v_int = res->v_int;
741  add_var_to_array (a, res->name, &v);
742  num_elems++;
743  }
744  else if (res->type == KB_TYPE_STR)
745  {
746  v.var_type = VAR2_DATA;
747  v.v.v_str.s_val = (unsigned char *) res->v_str;
748  v.v.v_str.s_siz = strlen (res->v_str);
749  add_var_to_array (a, res->name, &v);
750  num_elems++;
751  }
752  res = res->next;
753  }
754 
755  kb_item_free (top);
756 
757  if (num_elems == 0)
758  {
759  deref_cell (retc);
760  return FAKE_CELL;
761  }
762  return retc;
763 }
764 
765 tree_cell *
767 {
768  struct script_infos *script_infos = lexic->script_infos;
769 
770  char *kb_entry = get_str_var_by_num (lexic, 0);
771  char *val;
772  tree_cell *retc;
773  int type, single = get_int_var_by_num (lexic, 1, 0);
774  size_t len;
775 
776  if (kb_entry == NULL)
777  return NULL;
778 
779  val = plug_get_key (script_infos, kb_entry, &type, &len, !!single);
780 
781  if (val == NULL && type == -1)
782  return NULL;
783 
784  retc = alloc_typed_cell (CONST_INT);
785  if (type == KB_TYPE_INT)
786  {
787  retc->x.i_val = GPOINTER_TO_SIZE (val);
788  g_free (val);
789  return retc;
790  }
791  else
792  {
793  retc->type = CONST_DATA;
794  if (val != NULL)
795  {
796  retc->size = len;
797  retc->x.str_val = val;
798  }
799  else
800  {
801  retc->size = 0;
802  retc->x.str_val = NULL;
803  }
804  }
805 
806  return retc;
807 }
808 
809 tree_cell *
811 {
812  struct script_infos *script_infos = lexic->script_infos;
813  char *name = get_str_var_by_name (lexic, "name");
814  int type = get_var_type_by_name (lexic, "value");
815 
816  if (name == NULL)
817  {
818  nasl_perror (lexic, "Syntax error with replace_kb_item() [null name]\n",
819  name);
820  return FAKE_CELL;
821  }
822 
823  if (type == VAR2_INT)
824  {
825  int value = get_int_var_by_name (lexic, "value", -1);
826  if (value != -1)
828  GSIZE_TO_POINTER (value));
829  else
830  nasl_perror (
831  lexic, "Syntax error with replace_kb_item(%s) [value=-1]\n", name);
832  }
833  else
834  {
835  char *value = get_str_var_by_name (lexic, "value");
836  int len = get_var_size_by_name (lexic, "value");
837 
838  if (value == NULL)
839  {
840  nasl_perror (lexic,
841  "Syntax error with replace_kb_item(%s) [null value]\n",
842  name);
843  return FAKE_CELL;
844  }
846  }
847 
848  return FAKE_CELL;
849 }
850 
851 tree_cell *
853 {
854  struct script_infos *script_infos = lexic->script_infos;
855  char *name = get_str_var_by_name (lexic, "name");
856  int type = get_var_type_by_name (lexic, "value");
857 
858  if (name == NULL)
859  {
860  nasl_perror (lexic, "Syntax error with set_kb_item() [null name]\n",
861  name);
862  return FAKE_CELL;
863  }
864 
865  if (type == VAR2_INT)
866  {
867  int value = get_int_var_by_name (lexic, "value", -1);
868  if (value != -1)
869  plug_set_key (script_infos, name, ARG_INT, GSIZE_TO_POINTER (value));
870  else
871  nasl_perror (
872  lexic, "Syntax error with set_kb_item() [value=-1 for name '%s']\n",
873  name);
874  }
875  else
876  {
877  char *value = get_str_var_by_name (lexic, "value");
878  int len = get_var_size_by_name (lexic, "value");
879  if (value == NULL)
880  {
881  nasl_perror (
882  lexic,
883  "Syntax error with set_kb_item() [null value for name '%s']\n",
884  name);
885  return FAKE_CELL;
886  }
888  }
889 
890  return FAKE_CELL;
891 }
892 
893 /*------------------------[ Reporting a problem ]---------------------------*/
894 
898 typedef void (*proto_post_something_t) (const char *, struct script_infos *,
899  int, const char *, const char *);
903 typedef void (*post_something_t) (const char *, struct script_infos *, int,
904  const char *);
905 
906 static tree_cell *
908  post_something_t post_func)
909 {
910  struct script_infos *script_infos = lexic->script_infos;
911 
912  char *proto = get_str_var_by_name (lexic, "protocol");
913  char *data = get_str_var_by_name (lexic, "data");
914  int port = get_int_var_by_name (lexic, "port", -1);
915  char *dup = NULL;
916 
917  if (data != NULL)
918  {
919  int len = get_var_size_by_name (lexic, "data");
920  int i;
921 
922  dup = g_memdup (data, len + 1);
923  for (i = 0; i < len; i++)
924  if (dup[i] == 0)
925  dup[i] = ' ';
926  }
927 
929  {
930  if (data != NULL)
931  fprintf (stdout, "%s\n", dup);
932  else
933  fprintf (stdout, "Success\n");
934  }
935 
936  if (proto == NULL)
937  proto = get_str_var_by_name (lexic, "proto");
938 
939  if (port < 0)
940  port = get_int_var_by_num (lexic, 0, -1);
941 
942  if (dup != NULL)
943  {
944  if (proto == NULL)
945  post_func (lexic->oid, script_infos, port, dup);
946  else
947  proto_post_func (lexic->oid, script_infos, port, proto, dup);
948 
949  g_free (dup);
950  return FAKE_CELL;
951  }
952 
953  if (proto == NULL)
954  post_func (lexic->oid, script_infos, port, NULL);
955  else
956  proto_post_func (lexic->oid, script_infos, port, proto, NULL);
957 
958  return FAKE_CELL;
959 }
960 
968 tree_cell *
970 {
972 }
973 
974 tree_cell *
976 {
977  return security_something (lexic, proto_post_log, post_log);
978 }
979 
980 tree_cell *
982 {
984 }
985 
986 tree_cell *
988 {
989  tree_cell *retc;
990  char *name;
991  const char *value;
992 
993  name = get_str_var_by_num (lexic, 0);
994  if (name == NULL)
995  {
996  nasl_perror (lexic, "get_preference: no name\n");
997  return NULL;
998  }
999  value = prefs_get (name);
1000  if (value == NULL)
1001  return NULL;
1002 
1003  retc = alloc_typed_cell (CONST_DATA);
1004  retc->x.str_val = strdup (value);
1005  retc->size = strlen (value);
1006  return retc;
1007 }
1008 
1009 tree_cell *
1011 {
1012  tree_cell *retc;
1013  gchar *version = g_strdup (vendor_version_get ());
1014  (void) lexic;
1015  retc = alloc_typed_cell (CONST_DATA);
1016  retc->x.str_val = strdup (version);
1017  retc->size = strlen (version);
1018  g_free (version);
1019 
1020  return retc;
1021 }
1022 
1023 /*-------------------------[ Reporting an open port ]---------------------*/
1024 
1030 tree_cell *
1032 {
1033  tree_cell *retc;
1034  int idx = get_int_var_by_num (lexic, 0, -1);
1035  const char *prange = prefs_get ("port_range");
1036  static int num = 0;
1037  static u_short *ports = NULL;
1038 
1039  if (prange == NULL)
1040  return NULL;
1041 
1042  if (idx < 0)
1043  {
1044  nasl_perror (lexic, "Argument error in scanner_get_port()\n");
1045  nasl_perror (lexic, "Correct usage is : num = scanner_get_port(<num>)\n");
1046  nasl_perror (lexic,
1047  "Where <num> should be 0 the first time you call it\n");
1048  return NULL;
1049  }
1050 
1051  if (ports == NULL)
1052  {
1053  ports = (u_short *) getpts ((char *) prange, &num);
1054  if (ports == NULL)
1055  {
1056  return NULL;
1057  }
1058  }
1059 
1060  if (idx >= num)
1061  {
1062  return NULL;
1063  }
1064 
1065  retc = alloc_typed_cell (CONST_INT);
1066  retc->x.i_val = ports[idx];
1067  return retc;
1068 }
1069 
1070 tree_cell *
1072 {
1073  struct script_infos *script_infos = lexic->script_infos;
1074 
1075  int port = get_int_var_by_name (lexic, "port", -1);
1076  char *proto = get_str_var_by_name (lexic, "proto");
1077 
1078  if (port >= 0)
1079  {
1080  scanner_add_port (script_infos, port, proto ? proto : "tcp");
1081  }
1082 
1083  return FAKE_CELL;
1084 }
1085 
1086 tree_cell *
1088 {
1089  /* Kept for backward compatibility. */
1090  (void) lexic;
1091  return FAKE_CELL;
1092 }
script_infos::standalone
int standalone
Definition: scanneraux.h:53
security_message
tree_cell * security_message(lex_ctxt *lexic)
Send a security message to the client.
Definition: nasl_scanner_glue.c:969
script_copyright
tree_cell * script_copyright(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:264
st_a_nasl_var
Definition: nasl_var.h:50
scan_globals::network_targets
char * network_targets
Definition: scanneraux.h:34
plug_set_dep
void plug_set_dep(struct script_infos *args, const char *depname)
Definition: plugutils.c:65
script_infos
Definition: scanneraux.h:43
script_require_ports
tree_cell * script_require_ports(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:413
script_require_udp_ports
tree_cell * script_require_udp_ports(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:431
CONST_DATA
@ CONST_DATA
Definition: nasl_tree.h:93
plug_replace_key
void plug_replace_key(struct script_infos *args, char *name, int type, void *value)
Definition: plugutils.c:646
vendor_version_get
const gchar * vendor_version_get()
Get vendor version.
Definition: vendorversion.c:52
post_alarm
void post_alarm(const char *oid, struct script_infos *desc, int port, const char *action)
Definition: plugutils.c:355
plug_get_key
void * plug_get_key(struct script_infos *args, char *name, int *type, size_t *len, int single)
Get values from a kb under the given key name.
Definition: plugutils.c:730
get_var_size_by_name
int get_var_size_by_name(lex_ctxt *, const char *)
Definition: nasl_var.c:1147
plug_get_kb
kb_t plug_get_kb(struct script_infos *args)
Definition: plugutils.c:658
TC::str_val
char * str_val
Definition: nasl_tree.h:112
get_kb_item
tree_cell * get_kb_item(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:766
scan_phase
tree_cell * scan_phase(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:637
isalldigit
static int isalldigit(char *str, int len)
Definition: nasl_scanner_glue.c:61
nasl_scanner_get_port
tree_cell * nasl_scanner_get_port(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:1031
script_exclude_keys
tree_cell * script_exclude_keys(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:390
script_infos::nvti
nvti_t * nvti
Definition: scanneraux.h:47
DYN_ARRAY
@ DYN_ARRAY
Definition: nasl_tree.h:101
script_cve_id
tree_cell * script_cve_id(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:106
script_family
tree_cell * script_family(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:288
FAKE_CELL
#define FAKE_CELL
Definition: nasl_tree.h:119
post_error
void post_error(const char *oid, struct script_infos *desc, int port, const char *action)
Definition: plugutils.c:389
TC::x
union TC::@2 x
get_str_var_by_name
char * get_str_var_by_name(lex_ctxt *, const char *)
Definition: nasl_var.c:1127
st_a_nasl_var::v_str
nasl_string_t v_str
Definition: nasl_var.h:58
proto_post_error
void proto_post_error(const char *oid, struct script_infos *desc, int port, const char *proto, const char *action)
Definition: plugutils.c:382
get_plugin_preference_file_content
char * get_plugin_preference_file_content(struct script_infos *desc, const char *identifier)
Get the file contents of a plugins preference that is of type "file".
Definition: plugutils.c:541
plug_replace_key_len
void plug_replace_key_len(struct script_infos *args, char *name, int type, void *value, size_t len)
Definition: plugutils.c:623
post_log
void post_log(const char *oid, struct script_infos *desc, int port, const char *action)
Post a log message about a tcp port.
Definition: plugutils.c:375
nasl_scanner_add_port
tree_cell * nasl_scanner_add_port(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:1071
script_dependencies
tree_cell * script_dependencies(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:295
st_nasl_string::s_siz
int s_siz
Definition: nasl_var.h:38
name
const char * name
Definition: nasl_init.c:377
set_kb_item
tree_cell * set_kb_item(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:852
st_nasl_array
Definition: nasl_var.h:43
plug_set_key_len
void plug_set_key_len(struct script_infos *args, char *name, int type, const void *value, size_t len)
Definition: plugutils.c:594
log_message
tree_cell * log_message(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:975
script_bugtraq_id
tree_cell * script_bugtraq_id(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:122
oid
const char * oid
Definition: nasl_builtin_find_service.c:57
getpts
unsigned short * getpts(char *origexpr, int *len)
Converts a string like "-100,200-1024,3000-4000,60000-" into an array.
Definition: network.c:2103
nasl_debug.h
script_add_preference
tree_cell * script_add_preference(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:449
nasl_scanner_status
tree_cell * nasl_scanner_status(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:1087
script_infos::globals
struct scan_globals * globals
Definition: scanneraux.h:45
nasl_perror
void nasl_perror(lex_ctxt *lexic, char *msg,...)
Definition: nasl_debug.c:120
get_var_type_by_name
int get_var_type_by_name(lex_ctxt *, const char *)
Definition: nasl_var.c:1171
script_version
tree_cell * script_version(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:257
add_var_to_array
int add_var_to_array(nasl_array *a, char *name, const anon_nasl_var *v)
Definition: nasl_var.c:1286
TC::size
int size
Definition: nasl_tree.h:109
script_require_keys
tree_cell * script_require_keys(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:321
nasl_scanner_glue.h
script_tag
tree_cell * script_tag(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:210
post_something_t
void(* post_something_t)(const char *, struct script_infos *, int, const char *)
Definition: nasl_scanner_glue.c:903
nasl_lex_ctxt.h
script_timeout
tree_cell * script_timeout(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:86
get_plugin_preference
char * get_plugin_preference(const char *oid, const char *name, int pref_id)
Get the a plugins preference.
Definition: plugutils.c:408
struct_lex_ctxt::oid
const char * oid
Definition: nasl_lex_ctxt.h:42
get_int_var_by_name
long int get_int_var_by_name(lex_ctxt *, const char *, int)
Definition: nasl_var.c:1113
VAR2_DATA
@ VAR2_DATA
Definition: nasl_var.h:29
scanner_add_port
void scanner_add_port(struct script_infos *args, int port, char *proto)
Definition: plugutils.c:652
nasl_func.h
TC::ref_val
void * ref_val
Definition: nasl_tree.h:114
get_int_var_by_num
long int get_int_var_by_num(lex_ctxt *, int, int)
Definition: nasl_var.c:1106
scan_globals
Definition: scanneraux.h:32
get_str_var_by_num
char * get_str_var_by_num(lex_ctxt *, int)
Definition: nasl_var.c:1120
st_a_nasl_var::var_type
int var_type
Definition: nasl_var.h:52
script_name
tree_cell * script_name(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:250
get_kb_list
tree_cell * get_kb_list(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:705
struct_lex_ctxt::script_infos
struct script_infos * script_infos
Definition: nasl_lex_ctxt.h:41
safe_checks
tree_cell * safe_checks(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:626
TC
Definition: nasl_tree.h:104
struct_lex_ctxt
Definition: nasl_lex_ctxt.h:33
TC::type
short type
Definition: nasl_tree.h:106
scan_globals::network_scan_status
char * network_scan_status
Definition: scanneraux.h:35
get_plugin_preference_fname
const char * get_plugin_preference_fname(struct script_infos *desc, const char *filename)
Get the file name of a plugins preference that is of type "file".
Definition: plugutils.c:486
nasl_var.h
script_mandatory_keys
tree_cell * script_mandatory_keys(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:344
ARG_INT
#define ARG_INT
Definition: plugutils.h:34
nasl_global_ctxt.h
CONST_INT
@ CONST_INT
Definition: nasl_tree.h:90
nasl_get_preference
tree_cell * nasl_get_preference(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:987
val
const char * val
Definition: nasl_init.c:378
replace_kb_item
tree_cell * replace_kb_item(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:810
script_get_preference_file_location
tree_cell * script_get_preference_file_location(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:587
st_a_nasl_var::v
union st_a_nasl_var::@4 v
plug_set_key
void plug_set_key(struct script_infos *args, char *name, int type, const void *value)
Definition: plugutils.c:616
script_xref
tree_cell * script_xref(lex_ctxt *lexic)
Add a cross reference to the meta data.
Definition: nasl_scanner_glue.c:166
script_get_preference_file_content
tree_cell * script_get_preference_file_content(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:543
nasl_vendor_version
tree_cell * nasl_vendor_version(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:1010
st_a_nasl_var::v_int
long int v_int
Definition: nasl_var.h:59
error_message
tree_cell * error_message(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:981
get_plugin_preference_file_size
long get_plugin_preference_file_size(struct script_infos *desc, const char *identifier)
Get the file size of a plugins preference that is of type "file".
Definition: plugutils.c:572
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
proto_post_something_t
void(* proto_post_something_t)(const char *, struct script_infos *, int, const char *, const char *)
Definition: nasl_scanner_glue.c:898
VAR2_INT
@ VAR2_INT
Definition: nasl_var.h:27
script_oid
tree_cell * script_oid(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:99
network_targets
tree_cell * network_targets(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:659
nasl_tree.h
ARG_STRING
#define ARG_STRING
Definition: plugutils.h:33
script_category
tree_cell * script_category(lex_ctxt *lexic)
Definition: nasl_scanner_glue.c:271
script_get_preference
tree_cell * script_get_preference(lex_ctxt *lexic)
Get a preferences of the current script.
Definition: nasl_scanner_glue.c:506
proto_post_log
void proto_post_log(const char *oid, struct script_infos *desc, int port, const char *proto, const char *action)
Post a log message.
Definition: plugutils.c:365
security_something
static tree_cell * security_something(lex_ctxt *lexic, proto_post_something_t proto_post_func, post_something_t post_func)
Definition: nasl_scanner_glue.c:907
proto_post_alarm
void proto_post_alarm(const char *oid, struct script_infos *desc, int port, const char *proto, const char *action)
Definition: plugutils.c:348
st_nasl_string::s_val
unsigned char * s_val
Definition: nasl_var.h:37
get_script_oid
tree_cell * get_script_oid(lex_ctxt *lexic)
Return the OID of the current script.
Definition: nasl_scanner_glue.c:687
TC::i_val
long int i_val
Definition: nasl_tree.h:113