nasl_scanner_glue.c File Reference

glue between openvas and nasl scripts. More...

#include "nasl_scanner_glue.h"
#include "../misc/network.h"
#include "../misc/plugutils.h"
#include "../misc/support.h"
#include "../misc/vendorversion.h"
#include "nasl_debug.h"
#include "nasl_func.h"
#include "nasl_global_ctxt.h"
#include "nasl_lex_ctxt.h"
#include "nasl_tree.h"
#include "nasl_var.h"
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <glib.h>
#include <gvm/base/logging.h>
#include <gvm/base/prefs.h>
#include <gvm/util/kb.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

Include dependency graph for nasl_scanner_glue.c:

Go to the source code of this file.

Macros
#define	G_LOG_DOMAIN   "lib nasl"
	GLib logging domain. More...

Typedefs
typedef void(*	proto_post_something_t) (const char *, struct script_infos *, int, const char *, const char *, const char *)
typedef void(*	post_something_t) (const char *, struct script_infos *, int, const char *, const char *)

Functions
static int	isalldigit (char *str, int len)
tree_cell *	script_timeout (lex_ctxt *lexic)
	Add timeout preference to VT preferences. More...
tree_cell *	script_oid (lex_ctxt *lexic)
tree_cell *	script_cve_id (lex_ctxt *lexic)
tree_cell *	script_xref (lex_ctxt *lexic)
	Add a cross reference to the meta data. More...
tree_cell *	script_tag (lex_ctxt *lexic)
tree_cell *	script_name (lex_ctxt *lexic)
tree_cell *	script_version (lex_ctxt *lexic)
tree_cell *	script_copyright (lex_ctxt *lexic)
tree_cell *	script_category (lex_ctxt *lexic)
tree_cell *	script_family (lex_ctxt *lexic)
tree_cell *	script_dependencies (lex_ctxt *lexic)
tree_cell *	script_require_keys (lex_ctxt *lexic)
tree_cell *	script_mandatory_keys (lex_ctxt *lexic)
tree_cell *	script_exclude_keys (lex_ctxt *lexic)
tree_cell *	script_require_ports (lex_ctxt *lexic)
tree_cell *	script_require_udp_ports (lex_ctxt *lexic)
tree_cell *	script_add_preference (lex_ctxt *lexic)
tree_cell *	script_get_preference (lex_ctxt *lexic)
	Get a preferences of the current script. More...
tree_cell *	script_get_preference_file_content (lex_ctxt *lexic)
tree_cell *	script_get_preference_file_location (lex_ctxt *lexic)
tree_cell *	safe_checks (lex_ctxt *lexic)
tree_cell *	get_script_oid (lex_ctxt *lexic)
	Return the OID of the current script. More...
tree_cell *	get_kb_list (lex_ctxt *lexic)
tree_cell *	get_kb_item (lex_ctxt *lexic)
tree_cell *	get_host_kb_index (lex_ctxt *lexic)
	Get the kb index of the host running the current script. More...
tree_cell *	replace_kb_item (lex_ctxt *lexic)
static tree_cell *	set_kb_item_volatile (lex_ctxt *lexic)
	Set a volate kb item. More...
tree_cell *	set_kb_item (lex_ctxt *lexic)
	Set a kb item. More...
static tree_cell *	security_something (lex_ctxt *lexic, proto_post_something_t proto_post_func, post_something_t post_func)
tree_cell *	security_message (lex_ctxt *lexic)
	Send a security message to the client. More...
tree_cell *	log_message (lex_ctxt *lexic)
tree_cell *	error_message (lex_ctxt *lexic)
tree_cell *	nasl_get_preference (lex_ctxt *lexic)
tree_cell *	nasl_vendor_version (lex_ctxt *lexic)
tree_cell *	nasl_scanner_get_port (lex_ctxt *lexic)
tree_cell *	nasl_scanner_add_port (lex_ctxt *lexic)
tree_cell *	nasl_scanner_status (lex_ctxt *lexic)

Detailed Description

glue between openvas and nasl scripts.

This file contains all the functions that make the "glue" between as NASL script and openvas. (script_*(), kb(), scanner_*())

Definition in file nasl_scanner_glue.c.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "lib nasl"

GLib logging domain.

Definition at line 45 of file nasl_scanner_glue.c.

Typedef Documentation

post_something_t

typedef void(* post_something_t) (const char *, struct script_infos *, int, const char *, const char *)

Function is used when the script wants to report a problem back to openvas.

Definition at line 946 of file nasl_scanner_glue.c.

proto_post_something_t

typedef void(* proto_post_something_t) (const char *, struct script_infos *, int, const char *, const char *, const char *)

Function is used when the script wants to report a problem back to openvas.

Definition at line 940 of file nasl_scanner_glue.c.

Function Documentation

error_message()

tree_cell* error_message

(

lex_ctxt *

lexic

)

Definition at line 1027 of file nasl_scanner_glue.c.

{
  return security_something (lexic, proto_post_error, post_error);
}

References post_error(), proto_post_error(), and security_something().

Here is the call graph for this function:

get_host_kb_index()

tree_cell* get_host_kb_index

(

lex_ctxt *

lexic

)

Get the kb index of the host running the current script.

Parameters

[in]

lexic

NASL lexer.

Returns

lex cell containing the host kb index value as positive integer. NULL otherwise

Definition at line 761 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  int val;
  tree_cell *retc;
 
  val = kb_get_kb_index (script_infos->key);
  if (val >= 0)
    {
      retc = alloc_typed_cell (CONST_INT);
      retc->x.i_val = val;
    }
  else
    return NULL;
 
  return retc;
}

References alloc_typed_cell(), CONST_INT, TC::i_val, script_infos::key, struct_lex_ctxt::script_infos, val, and TC::x.

Here is the call graph for this function:

get_kb_item()

tree_cell* get_kb_item

(

lex_ctxt *

lexic

)

Definition at line 709 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
 
  char *kb_entry = get_str_var_by_num (lexic, 0);
  char *val;
  tree_cell *retc;
  int type, single = get_int_var_by_num (lexic, 1, 0);
  size_t len;
 
  if (kb_entry == NULL)
    return NULL;
 
  val = plug_get_key (script_infos, kb_entry, &type, &len, !!single);
 
  if (val == NULL && type == -1)
    return NULL;
 
  retc = alloc_typed_cell (CONST_INT);
  if (type == KB_TYPE_INT)
    {
      retc->x.i_val = GPOINTER_TO_SIZE (val);
      g_free (val);
      return retc;
    }
  else
    {
      retc->type = CONST_DATA;
      if (val != NULL)
        {
          retc->size = len;
          retc->x.str_val = val;
        }
      else
        {
          retc->size = 0;
          retc->x.str_val = NULL;
        }
    }
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, CONST_INT, get_int_var_by_num(), get_str_var_by_num(), TC::i_val, len, plug_get_key(), struct_lex_ctxt::script_infos, TC::size, TC::str_val, TC::type, val, and TC::x.

Here is the call graph for this function:

get_kb_list()

tree_cell* get_kb_list

(

lex_ctxt *

lexic

)

Definition at line 648 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  kb_t kb = plug_get_kb (script_infos);
  char *kb_mask = get_str_var_by_num (lexic, 0);
  tree_cell *retc;
  int num_elems = 0;
  nasl_array *a;
  struct kb_item *res, *top;
 
  if (kb_mask == NULL)
    {
      nasl_perror (lexic, "get_kb_list() usage : get_kb_list(<NameOfItem>)\n");
      return NULL;
    }
 
  if (kb == NULL)
    return NULL;
 
  retc = alloc_typed_cell (DYN_ARRAY);
  retc->x.ref_val = a = g_malloc0 (sizeof (nasl_array));
 
  if (strchr (kb_mask, '*'))
    top = res = kb_item_get_pattern (kb, kb_mask);
  else
    top = res = kb_item_get_all (kb, kb_mask);
 
  while (res != NULL)
    {
      anon_nasl_var v;
      bzero (&v, sizeof (v));
 
      if (res->type == KB_TYPE_INT)
        {
          v.var_type = VAR2_INT;
          v.v.v_int = res->v_int;
          add_var_to_array (a, res->name, &v);
          num_elems++;
        }
      else if (res->type == KB_TYPE_STR)
        {
          v.var_type = VAR2_DATA;
          v.v.v_str.s_val = (unsigned char *) res->v_str;
          v.v.v_str.s_siz = strlen (res->v_str);
          add_var_to_array (a, res->name, &v);
          num_elems++;
        }
      res = res->next;
    }
 
  kb_item_free (top);
 
  if (num_elems == 0)
    {
      deref_cell (retc);
      return FAKE_CELL;
    }
  return retc;
}

References add_var_to_array(), alloc_typed_cell(), deref_cell(), DYN_ARRAY, FAKE_CELL, get_str_var_by_num(), nasl_perror(), plug_get_kb(), TC::ref_val, st_nasl_string::s_siz, st_nasl_string::s_val, struct_lex_ctxt::script_infos, st_a_nasl_var::v, st_a_nasl_var::v_int, st_a_nasl_var::v_str, VAR2_DATA, VAR2_INT, st_a_nasl_var::var_type, and TC::x.

Here is the call graph for this function:

get_script_oid()

tree_cell* get_script_oid

(

lex_ctxt *

lexic

)

Return the OID of the current script.

Parameters

[in]

lexic

NASL lexer.

Returns

lex cell containing the OID as a string.

Definition at line 630 of file nasl_scanner_glue.c.

{
  const char *oid = lexic->oid;
  tree_cell *retc = NULL;
 
  if (oid)
    {
      retc = alloc_typed_cell (CONST_DATA);
      retc->x.str_val = g_strdup (oid);
      retc->size = strlen (oid);
    }
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, oid, struct_lex_ctxt::oid, TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

isalldigit()

static int isalldigit ( char *  str, int  len  )

static

Definition at line 50 of file nasl_scanner_glue.c.

{
  int i;
  char buf[1024];
  for (i = 0; i < len; i++)
    {
      if (!isdigit (str[i]))
        return 0;
    }
 
  snprintf (buf, sizeof (buf), "%d", atoi (str));
  if (strcmp (buf, str) != 0)
    return 0;
  else
    return 1;
}

References len.

Referenced by script_get_preference().

Here is the caller graph for this function:

log_message()

tree_cell* log_message

(

lex_ctxt *

lexic

)

Definition at line 1021 of file nasl_scanner_glue.c.

{
  return security_something (lexic, proto_post_log, post_log_with_uri);
}

References post_log_with_uri(), proto_post_log(), and security_something().

Here is the call graph for this function:

nasl_get_preference()

tree_cell* nasl_get_preference

(

lex_ctxt *

lexic

)

Definition at line 1033 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  char *name;
  const char *value;
 
  name = get_str_var_by_num (lexic, 0);
  if (name == NULL)
    {
      nasl_perror (lexic, "get_preference: no name\n");
      return NULL;
    }
  value = prefs_get (name);
  if (value == NULL)
    return NULL;
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->x.str_val = strdup (value);
  retc->size = strlen (value);
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_str_var_by_num(), name, nasl_perror(), TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_scanner_add_port()

tree_cell* nasl_scanner_add_port

(

lex_ctxt *

lexic

)

Definition at line 1117 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
 
  int port = get_int_var_by_name (lexic, "port", -1);
  char *proto = get_str_var_by_name (lexic, "proto");
 
  if (port >= 0)
    {
      scanner_add_port (script_infos, port, proto ? proto : "tcp");
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_int_var_by_name(), get_str_var_by_name(), scanner_add_port(), and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

nasl_scanner_get_port()

tree_cell* nasl_scanner_get_port

(

lex_ctxt *

lexic

)

If the plugin is a port scanner, it needs to report the list of open ports back to openvas scanner, and it also needs to know which ports are to be scanned.

Definition at line 1077 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  int idx = get_int_var_by_num (lexic, 0, -1);
  const char *prange = prefs_get ("port_range");
  static int num = 0;
  static u_short *ports = NULL;
 
  if (prange == NULL)
    return NULL;
 
  if (idx < 0)
    {
      nasl_perror (lexic, "Argument error in scanner_get_port()\n");
      nasl_perror (lexic, "Correct usage is : num = scanner_get_port(<num>)\n");
      nasl_perror (lexic,
                   "Where <num> should be 0 the first time you call it\n");
      return NULL;
    }
 
  if (ports == NULL)
    {
      ports = (u_short *) getpts ((char *) prange, &num);
      if (ports == NULL)
        {
          return NULL;
        }
    }
 
  if (idx >= num)
    {
      return NULL;
    }
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = ports[idx];
  return retc;
}

References alloc_typed_cell(), CONST_INT, get_int_var_by_num(), getpts(), TC::i_val, nasl_perror(), and TC::x.

Here is the call graph for this function:

nasl_scanner_status()

tree_cell* nasl_scanner_status

(

lex_ctxt *

lexic

)

Definition at line 1133 of file nasl_scanner_glue.c.

{
  /* Kept for backward compatibility. */
  (void) lexic;
  return FAKE_CELL;
}

References FAKE_CELL.

nasl_vendor_version()

tree_cell* nasl_vendor_version

(

lex_ctxt *

lexic

)

Definition at line 1056 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  gchar *version = g_strdup (vendor_version_get ());
  (void) lexic;
  retc = alloc_typed_cell (CONST_DATA);
  retc->x.str_val = strdup (version);
  retc->size = strlen (version);
  g_free (version);
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, TC::size, TC::str_val, vendor_version_get(), and TC::x.

Here is the call graph for this function:

replace_kb_item()

tree_cell* replace_kb_item

(

lex_ctxt *

lexic

)

Definition at line 780 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *name = get_str_var_by_name (lexic, "name");
  int type = get_var_type_by_name (lexic, "value");
 
  if (name == NULL)
    {
      nasl_perror (lexic, "Syntax error with replace_kb_item() [null name]\n",
                   name);
      return FAKE_CELL;
    }
 
  if (type == VAR2_INT)
    {
      int value = get_int_var_by_name (lexic, "value", -1);
      if (value != -1)
        plug_replace_key (script_infos, name, ARG_INT,
                          GSIZE_TO_POINTER (value));
      else
        nasl_perror (
          lexic, "Syntax error with replace_kb_item(%s) [value=-1]\n", name);
    }
  else
    {
      char *value = get_str_var_by_name (lexic, "value");
      int len = get_var_size_by_name (lexic, "value");
 
      if (value == NULL)
        {
          nasl_perror (lexic,
                       "Syntax error with replace_kb_item(%s) [null value]\n",
                       name);
          return FAKE_CELL;
        }
      plug_replace_key_len (script_infos, name, ARG_STRING, value, len);
    }
 
  return FAKE_CELL;
}

References ARG_INT, ARG_STRING, FAKE_CELL, get_int_var_by_name(), get_str_var_by_name(), get_var_size_by_name(), get_var_type_by_name(), len, name, nasl_perror(), plug_replace_key(), plug_replace_key_len(), struct_lex_ctxt::script_infos, and VAR2_INT.

Here is the call graph for this function:

safe_checks()

tree_cell* safe_checks

(

lex_ctxt *

lexic

)

Definition at line 612 of file nasl_scanner_glue.c.

{
  (void) lexic;
  tree_cell *retc = alloc_typed_cell (CONST_INT);
 
  retc->x.i_val = prefs_get_bool ("safe_checks");
 
  return retc;
}

References alloc_typed_cell(), CONST_INT, TC::i_val, and TC::x.

Referenced by plugin_run_openvas_tcp_scanner().

Here is the call graph for this function:

Here is the caller graph for this function:

script_add_preference()

tree_cell* script_add_preference

(

lex_ctxt *

lexic

)

Definition at line 435 of file nasl_scanner_glue.c.

{
  int id = get_int_var_by_name (lexic, "id", -1);
  char *name = get_str_var_by_name (lexic, "name");
  char *type = get_str_var_by_name (lexic, "type");
  char *value = get_str_var_by_name (lexic, "value");
  struct script_infos *script_infos = lexic->script_infos;
  nvtpref_t *np;
  unsigned int i;
 
  if (!script_infos->nvti)
    return FAKE_CELL;
  if (id < 0)
    id = nvti_pref_len (script_infos->nvti) + 1;
  if (id == 0)
    {
      nasl_perror (lexic,
                   "Invalid id or not allowed id value in the call to %s()\n",
                   __func__);
      return FAKE_CELL;
    }
  if (!name || !type || !value)
    {
      nasl_perror (lexic,
                   "Argument error in the call to script_add_preference()\n");
      return FAKE_CELL;
    }
  for (i = 0; i < nvti_pref_len (script_infos->nvti); i++)
    {
      if (!strcmp (name, nvtpref_name (nvti_pref (script_infos->nvti, i))))
        {
          nasl_perror (lexic, "Preference '%s' already exists\n", name);
          return FAKE_CELL;
        }
      if (id == nvtpref_id (nvti_pref (script_infos->nvti, i)))
        {
          nasl_perror (lexic, "Invalid or already existent preference id\n");
          return FAKE_CELL;
        }
    }
 
  np = nvtpref_new (id, name, type, value);
  nvti_add_pref (script_infos->nvti, np);
  return FAKE_CELL;
}

References FAKE_CELL, get_int_var_by_name(), get_str_var_by_name(), name, nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_category()

tree_cell* script_category

(

lex_ctxt *

lexic

)

Definition at line 255 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
 
  int category = get_int_var_by_num (lexic, 0, -1);
 
  if (category < 0)
    {
      nasl_perror (lexic, "Argument error in function script_category()\n");
      nasl_perror (lexic, "Function usage is : script_category(<category>)\n");
      return FAKE_CELL;
    }
  nvti_set_category (script_infos->nvti, category);
  return FAKE_CELL;
}

References FAKE_CELL, get_int_var_by_num(), nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_copyright()

tree_cell* script_copyright

(

lex_ctxt *

lexic

)

Definition at line 248 of file nasl_scanner_glue.c.

{
  (void) lexic;
  return FAKE_CELL;
}

References FAKE_CELL.

script_cve_id()

tree_cell* script_cve_id

(

lex_ctxt *

lexic

)

Definition at line 112 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *cve = get_str_var_by_num (lexic, 0);
  int i;
 
  for (i = 0; cve != NULL; i++)
    {
      nvti_add_vtref (script_infos->nvti, vtref_new ("cve", cve, ""));
      cve = get_str_var_by_num (lexic, i + 1);
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_dependencies()

tree_cell* script_dependencies

(

lex_ctxt *

lexic

)

Definition at line 279 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *dep = get_str_var_by_num (lexic, 0);
  int i;
 
  if (dep == NULL)
    {
      nasl_perror (lexic, "Argument error in function script_dependencies()\n");
      nasl_perror (lexic, "Function usage is : script_dependencies(<name>)\n");
      nasl_perror (lexic, "Where <name> is the name of another script\n");
 
      return FAKE_CELL;
    }
 
  for (i = 0; dep != NULL; i++)
    {
      dep = get_str_var_by_num (lexic, i);
      if (dep != NULL)
        plug_set_dep (script_infos, dep);
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), nasl_perror(), plug_set_dep(), and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_exclude_keys()

tree_cell* script_exclude_keys

(

lex_ctxt *

lexic

)

Definition at line 376 of file nasl_scanner_glue.c.

{
  char *keys = get_str_var_by_num (lexic, 0);
  int i;
 
  if (keys == NULL)
    {
      nasl_perror (lexic, "Argument error in function script_exclude_keys()\n");
      nasl_perror (lexic, "Function usage is : script_exclude_keys(<name>)\n");
      nasl_perror (lexic, "Where <name> is the name of a key\n");
      return FAKE_CELL;
    }
 
  for (i = 0; keys != NULL; i++)
    {
      keys = get_str_var_by_num (lexic, i);
      nvti_add_excluded_keys (lexic->script_infos->nvti, keys);
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_family()

tree_cell* script_family

(

lex_ctxt *

lexic

)

Definition at line 272 of file nasl_scanner_glue.c.

{
  nvti_set_family (lexic->script_infos->nvti, get_str_var_by_num (lexic, 0));
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_get_preference()

tree_cell* script_get_preference

(

lex_ctxt *

lexic

)

Get a preferences of the current script.

Search the preference by preference name or by preferences id.

Parameters

[in]

lexic

NASL lexer.

Returns

lex cell containing the preferences value as a string. Fake cell otherwise

Definition at line 492 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  int id = get_int_var_by_name (lexic, "id", -1);
  char *pref = get_str_var_by_num (lexic, 0);
  char *value;
 
  if (pref == NULL && id == -1)
    {
      nasl_perror (lexic,
                   "Argument error in the function script_get_preference()\n");
      nasl_perror (lexic,
                   "Function usage is : pref = script_get_preference(<name>, "
                   "id:<id>)\n");
      return FAKE_CELL;
    }
 
  value = get_plugin_preference (lexic->oid, pref, id);
  if (value != NULL)
    {
      retc = alloc_typed_cell (CONST_INT);
      if (isalldigit (value, strlen (value)))
        retc->x.i_val = atoi (value);
      else
        {
          retc->type = CONST_DATA;
          retc->size = strlen (value);
          retc->x.str_val = g_strdup (value);
        }
      g_free (value);
      return retc;
    }
  else
    return FAKE_CELL;
}

References alloc_typed_cell(), CONST_DATA, CONST_INT, FAKE_CELL, get_int_var_by_name(), get_plugin_preference(), get_str_var_by_num(), TC::i_val, isalldigit(), nasl_perror(), struct_lex_ctxt::oid, TC::size, TC::str_val, TC::type, and TC::x.

Here is the call graph for this function:

script_get_preference_file_content()

tree_cell* script_get_preference_file_content

(

lex_ctxt *

lexic

)

Definition at line 529 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  tree_cell *retc;
  char *pref = get_str_var_by_num (lexic, 0);
  char *value;
  char *content;
  int contentsize = 0;
 
  if (pref == NULL)
    {
      nasl_perror (lexic,
                   "Argument error in the function script_get_preference()\n");
      nasl_perror (lexic, "Function usage is : pref = "
                          "script_get_preference_file_content(<name>)\n");
      return NULL;
    }
 
  value = get_plugin_preference (lexic->oid, pref, -1);
  if (value == NULL)
    return NULL;
 
  content = get_plugin_preference_file_content (script_infos, value);
  contentsize = get_plugin_preference_file_size (script_infos, value);
  g_free (value);
  if (content == NULL)
    return FAKE_CELL;
  if (contentsize <= 0)
    {
      nasl_perror (lexic,
                   "script_get_preference_file_content: could not get "
                   " size of file from preference %s\n",
                   pref);
      return NULL;
    }
 
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = contentsize;
  retc->x.str_val = content;
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, FAKE_CELL, get_plugin_preference(), get_plugin_preference_file_content(), get_plugin_preference_file_size(), get_str_var_by_num(), nasl_perror(), struct_lex_ctxt::oid, struct_lex_ctxt::script_infos, TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

script_get_preference_file_location()

tree_cell* script_get_preference_file_location

(

lex_ctxt *

lexic

)

Definition at line 573 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  tree_cell *retc;
  char *pref = get_str_var_by_num (lexic, 0);
  const char *value, *local;
  int len;
 
  if (pref == NULL)
    {
      nasl_perror (
        lexic, "script_get_preference_file_location: no preference name!\n");
      return NULL;
    }
 
  value = get_plugin_preference (lexic->oid, pref, -1);
  if (value == NULL)
    {
      nasl_perror (
        lexic,
        "script_get_preference_file_location: could not get preference %s\n",
        pref);
      return NULL;
    }
  local = get_plugin_preference_fname (script_infos, value);
  if (local == NULL)
    return NULL;
 
  len = strlen (local);
  retc = alloc_typed_cell (CONST_DATA);
  retc->size = len;
  retc->x.str_val = g_malloc0 (len + 1);
  memcpy (retc->x.str_val, local, len + 1);
 
  return retc;
}

References alloc_typed_cell(), CONST_DATA, get_plugin_preference(), get_plugin_preference_fname(), get_str_var_by_num(), len, nasl_perror(), struct_lex_ctxt::oid, struct_lex_ctxt::script_infos, TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

script_mandatory_keys()

tree_cell* script_mandatory_keys

(

lex_ctxt *

lexic

)

Definition at line 329 of file nasl_scanner_glue.c.

{
  char *keys = get_str_var_by_num (lexic, 0);
  char **splits = NULL, *re = get_str_var_by_name (lexic, "re");
  int i;
 
  if (keys == NULL)
    {
      nasl_perror (lexic,
                   "Argument error in function script_mandatory_keys()\n");
      nasl_perror (lexic, "Function usage is: script_mandatory_keys(<name>... "
                          "[, re: '<name>=<regex>'])\n");
      nasl_perror (lexic, "Where <name> is the name of a key and <regex> is a "
                          "regular expression for a value of a key.\n");
      return FAKE_CELL;
    }
 
  if (re)
    {
      splits = g_strsplit (re, "=", 0);
 
      if (!splits[0] || !splits[1] || !*splits[1] || splits[2])
        {
          nasl_perror (lexic, "Erroneous re argument");
          return FAKE_CELL;
        }
    }
  for (i = 0; keys != NULL; i++)
    {
      keys = get_str_var_by_num (lexic, i);
 
      if (splits && keys && !strcmp (keys, splits[0]))
        {
          nvti_add_mandatory_keys (lexic->script_infos->nvti, re);
          re = NULL;
        }
      else
        nvti_add_mandatory_keys (lexic->script_infos->nvti, keys);
    }
  if (re)
    nvti_add_mandatory_keys (lexic->script_infos->nvti, re);
 
  g_strfreev (splits);
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_name(), get_str_var_by_num(), nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_name()

tree_cell* script_name

(

lex_ctxt *

lexic

)

Definition at line 234 of file nasl_scanner_glue.c.

{
  nvti_set_name (lexic->script_infos->nvti, get_str_var_by_num (lexic, 0));
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Referenced by nasl_perror(), and nasl_trace().

Here is the call graph for this function:

Here is the caller graph for this function:

script_oid()

tree_cell* script_oid

(

lex_ctxt *

lexic

)

Definition at line 105 of file nasl_scanner_glue.c.

{
  nvti_set_oid (lexic->script_infos->nvti, get_str_var_by_num (lexic, 0));
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_require_keys()

tree_cell* script_require_keys

(

lex_ctxt *

lexic

)

Definition at line 305 of file nasl_scanner_glue.c.

{
  char *keys = get_str_var_by_num (lexic, 0);
  int i;
 
  if (keys == NULL)
    {
      nasl_perror (lexic, "Argument error in function script_require_keys()\n");
      nasl_perror (lexic,
                   "Function usage is : script_require_keys(<name>...)\n");
      nasl_perror (lexic, "Where <name> is the name of a key\n");
      return FAKE_CELL;
    }
 
  for (i = 0; keys != NULL; i++)
    {
      keys = get_str_var_by_num (lexic, i);
      nvti_add_required_keys (lexic->script_infos->nvti, keys);
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_require_ports()

tree_cell* script_require_ports

(

lex_ctxt *

lexic

)

Definition at line 399 of file nasl_scanner_glue.c.

{
  char *port;
  int i;
 
  for (i = 0;; i++)
    {
      port = get_str_var_by_num (lexic, i);
      if (port != NULL)
        nvti_add_required_ports (lexic->script_infos->nvti, port);
      else
        break;
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_require_udp_ports()

tree_cell* script_require_udp_ports

(

lex_ctxt *

lexic

)

Definition at line 417 of file nasl_scanner_glue.c.

{
  int i;
  char *port;
 
  for (i = 0;; i++)
    {
      port = get_str_var_by_num (lexic, i);
      if (port != NULL)
        nvti_add_required_udp_ports (lexic->script_infos->nvti, port);
      else
        break;
    }
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_tag()

tree_cell* script_tag

(

lex_ctxt *

lexic

)

Definition at line 194 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *name = get_str_var_by_name (lexic, "name");
  char *value = get_str_var_by_name (lexic, "value");
 
  if (value == NULL || name == NULL)
    {
      nasl_perror (lexic, "script_tag() syntax error - should be"
                          " script_tag(name:<name>, value:<value>)\n");
      if (name == NULL)
        {
          nasl_perror (lexic, "  <name> is empty\n");
        }
      else
        {
          nasl_perror (lexic, "  <name> is %s\n", name);
        }
      if (value == NULL)
        {
          nasl_perror (lexic, "  <value> is empty)\n");
        }
      else
        {
          nasl_perror (lexic, "  <value> is %s\n)", value);
        }
      return FAKE_CELL;
    }
 
  if (strchr (value, '|'))
    {
      nasl_perror (lexic, "%s tag contains | separator", name);
      return FAKE_CELL;
    }
  nvti_add_tag (script_infos->nvti, name, value);
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_name(), name, nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_timeout()

tree_cell* script_timeout

(

lex_ctxt *

lexic

)

Add timeout preference to VT preferences.

VT timeout is handled as normal VT preference. Because of backward compatibility issues the timeout preference is always located at the VT pref location with id NVTPREF_TIMEOUT_ID.

Parameters

[in]	lexic	lexic
[in]	to	script timeout

Returns

FAKE_CELL

Definition at line 87 of file nasl_scanner_glue.c.

{
  nvti_t *nvti = lexic->script_infos->nvti;
  int to = get_int_var_by_num (lexic, 0, -65535);
  nvtpref_t *np;
  gchar *timeout;
 
  if (to == -65535)
    return FAKE_CELL;
 
  timeout = g_strdup_printf ("%d", to);
 
  np = nvtpref_new (NVTPREF_TIMEOUT_ID, "timeout", "entry", timeout);
  nvti_add_pref (nvti, np);
  return FAKE_CELL;
}

References FAKE_CELL, get_int_var_by_num(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

script_version()

tree_cell* script_version

(

lex_ctxt *

lexic

)

Definition at line 241 of file nasl_scanner_glue.c.

{
  (void) lexic;
  return FAKE_CELL;
}

References FAKE_CELL.

script_xref()

tree_cell* script_xref

(

lex_ctxt *

lexic

)

Add a cross reference to the meta data.

The parameter "name" of the command defines actually the type, for example "URL" or "OSVDB". The parameter "value" is the actual reference. Alternative to "value", "csv" can be used with a list of comma-separated values.

In fact, if name is "cve", it is equivalent to call script_cve_id(), for example script_cve_id ("CVE-2019-12345"); is identical to script_xref (name: "cve", value: "CVE-2019-12345");

This even works with multiple comma-separated elements like script_xref (name: "cve", csv: "CVE-2019-12345,CVE-2019-54321");

Parameters

lexic

The parser context.

Returns

Always FAKE_CELL.

Definition at line 150 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *name = get_str_var_by_name (lexic, "name");
  char *value = get_str_var_by_name (lexic, "value");
  char *csv = get_str_var_by_name (lexic, "csv");
 
  if (((value == NULL) && (csv == NULL)) || name == NULL)
    {
      nasl_perror (lexic,
                   "script_xref() syntax error - should be"
                   " script_xref(name:<name>, value:<value>) or"
                   " script_xref(name:<name>, value:<value>, csv:<CSVs>) or"
                   " script_xref(name:<name>, csv:<CSVs>)\n");
      if (name == NULL)
        {
          nasl_perror (lexic, "  <name> is empty\n");
        }
      else
        {
          nasl_perror (lexic, "  <name> is %s\n", name);
        }
      if ((value == NULL) && (csv == NULL))
        {
          nasl_perror (lexic, "  <value> and <csv> is empty)\n");
        }
      else
        {
          nasl_perror (lexic, "  <value> is %s\n)", value);
          nasl_perror (lexic, "  <csv> is %s\n)", csv);
        }
      return FAKE_CELL;
    }
 
  if (csv)
    nvti_add_refs (script_infos->nvti, name, csv, "");
 
  if (value)
    nvti_add_vtref (script_infos->nvti, vtref_new (name, value, ""));
 
  return FAKE_CELL;
}

References FAKE_CELL, get_str_var_by_name(), name, nasl_perror(), script_infos::nvti, and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

security_message()

tree_cell* security_message

(

lex_ctxt *

lexic

)

Send a security message to the client.

Parameters

[in]

lexic

NASL lexer.

Returns

FAKE_CELL.

Definition at line 1015 of file nasl_scanner_glue.c.

{
  return security_something (lexic, proto_post_alarm, post_alarm);
}

References post_alarm(), proto_post_alarm(), and security_something().

Here is the call graph for this function:

security_something()

static tree_cell* security_something ( lex_ctxt *  lexic, proto_post_something_t  proto_post_func, post_something_t  post_func  )

static

Definition at line 950 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
 
  char *proto = get_str_var_by_name (lexic, "protocol");
  char *data = get_str_var_by_name (lexic, "data");
  char *uri = get_str_var_by_name (lexic, "uri");
  int port = get_int_var_by_name (lexic, "port", -1);
  char *dup = NULL;
 
  if (data != NULL)
    {
      int len = get_var_size_by_name (lexic, "data");
      int i;
 
      dup = g_malloc0 ((len + 1) * sizeof (char *));
      memcpy (dup, data, len + 1);
 
      for (i = 0; i < len; i++)
        if (dup[i] == '\0')
          dup[i] = ' ';
    }
 
  if (script_infos->standalone)
    {
      if (data != NULL)
        fprintf (stdout, "%s\n", dup);
      else
        fprintf (stdout, "Success\n");
    }
 
  if (proto == NULL)
    proto = get_str_var_by_name (lexic, "proto");
 
  if (port < 0)
    port = get_int_var_by_num (lexic, 0, -1);
 
  if (dup != NULL)
    {
      if (proto == NULL)
        post_func (lexic->oid, script_infos, port, dup, uri);
      else
        proto_post_func (lexic->oid, script_infos, port, proto, dup, uri);
 
      g_free (dup);
      return FAKE_CELL;
    }
 
  if (proto == NULL)
    post_func (lexic->oid, script_infos, port, NULL, uri);
  else
    proto_post_func (lexic->oid, script_infos, port, proto, NULL, uri);
 
  return FAKE_CELL;
}

References FAKE_CELL, get_int_var_by_name(), get_int_var_by_num(), get_str_var_by_name(), get_var_size_by_name(), len, struct_lex_ctxt::oid, struct_lex_ctxt::script_infos, and script_infos::standalone.

Referenced by error_message(), log_message(), and security_message().

Here is the call graph for this function:

Here is the caller graph for this function:

set_kb_item()

tree_cell* set_kb_item

(

lex_ctxt *

lexic

)

Set a kb item.

If expire is set the key will be removed after it expired.

Parameters

[in]	lexic	NASL lexer.
[in]	name	Name of Item.
[in]	value	Value of Item.
[in]	expire	Optional expire for item in seconds.

Returns

FAKE_CELL

Definition at line 890 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *name = get_str_var_by_name (lexic, "name");
  int type = get_var_type_by_name (lexic, "value");
  int expire = get_int_var_by_name (lexic, "expire", -1);
 
  if (expire != -1)
    return set_kb_item_volatile (lexic);
 
  if (name == NULL)
    {
      nasl_perror (lexic, "Syntax error with set_kb_item() [null name]\n",
                   name);
      return FAKE_CELL;
    }
 
  if (type == VAR2_INT)
    {
      int value = get_int_var_by_name (lexic, "value", -1);
      if (value != -1)
        plug_set_key (script_infos, name, ARG_INT, GSIZE_TO_POINTER (value));
      else
        nasl_perror (
          lexic, "Syntax error with set_kb_item() [value=-1 for name '%s']\n",
          name);
    }
  else
    {
      char *value = get_str_var_by_name (lexic, "value");
      int len = get_var_size_by_name (lexic, "value");
      if (value == NULL)
        {
          nasl_perror (
            lexic,
            "Syntax error with set_kb_item() [null value for name '%s']\n",
            name);
          return FAKE_CELL;
        }
      plug_set_key_len (script_infos, name, ARG_STRING, value, len);
    }
 
  return FAKE_CELL;
}

References ARG_INT, ARG_STRING, FAKE_CELL, get_int_var_by_name(), get_str_var_by_name(), get_var_size_by_name(), get_var_type_by_name(), len, name, nasl_perror(), plug_set_key(), plug_set_key_len(), struct_lex_ctxt::script_infos, set_kb_item_volatile(), and VAR2_INT.

Here is the call graph for this function:

set_kb_item_volatile()

static tree_cell* set_kb_item_volatile ( lex_ctxt *  lexic )

static

Set a volate kb item.

Parameters

[in]	lexic	NASL lexer.
[in]	name	Name of Item.
[in]	value	Value of Item.
[in]	expire	Optional expire for item in seconds.

Returns

FAKE_CELL

Definition at line 832 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  char *name = get_str_var_by_name (lexic, "name");
  int type = get_var_type_by_name (lexic, "value");
  int expire = get_int_var_by_name (lexic, "expire", -1);
 
  if (name == NULL)
    {
      nasl_perror (lexic, "Syntax error with set_kb_item() [null name]\n",
                   name);
      return FAKE_CELL;
    }
 
  if (type == VAR2_INT)
    {
      int value = get_int_var_by_name (lexic, "value", -1);
      if (value != -1 && expire != -1)
        plug_set_key_volatile (script_infos, name, ARG_INT,
                               GSIZE_TO_POINTER (value), expire);
      else
        nasl_perror (lexic,
                     "Syntax error with set_kb_item() [value=-1 or expire=-1 "
                     "for name '%s']\n",
                     name);
    }
  else
    {
      char *value = get_str_var_by_name (lexic, "value");
      int len = get_var_size_by_name (lexic, "value");
      if (value == NULL || expire == -1)
        {
          nasl_perror (lexic,
                       "Syntax error with set_kb_item() [null value or "
                       "expire=-1 for name '%s']\n",
                       name);
          return FAKE_CELL;
        }
      plug_set_key_len_volatile (script_infos, name, ARG_STRING, value, expire,
                                 len);
    }
 
  return FAKE_CELL;
}

References ARG_INT, ARG_STRING, FAKE_CELL, get_int_var_by_name(), get_str_var_by_name(), get_var_size_by_name(), get_var_type_by_name(), len, name, nasl_perror(), plug_set_key_len_volatile(), plug_set_key_volatile(), struct_lex_ctxt::script_infos, and VAR2_INT.

Referenced by set_kb_item().

Here is the call graph for this function:

Here is the caller graph for this function: