nasl_scanner_glue.c File Reference

glue between openvas and nasl scripts. More...

#include "nasl_scanner_glue.h"
#include "../misc/ipc_openvas.h"
#include "../misc/kb_cache.h"
#include "../misc/network.h"
#include "../misc/plugutils.h"
#include "../misc/support.h"
#include "../misc/table_driven_lsc.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/networking.h>
#include <gvm/base/prefs.h>
#include <gvm/util/kb.h>
#include <stddef.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.

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.
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.
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.
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.
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.
tree_cell *	replace_kb_item (lex_ctxt *lexic)
static tree_cell *	set_kb_item_volatile (lex_ctxt *lexic)
	Set a volatile kb item.
tree_cell *	set_kb_item (lex_ctxt *lexic)
	Set a kb item.
static tree_cell *	security_something (lex_ctxt *lexic, proto_post_something_t proto_post_func, post_something_t post_func)
static unsigned char *	get_notus_result_message (lex_ctxt *lexic, named_nasl_var *var)
tree_cell *	security_notus (lex_ctxt *lexic)
tree_cell *	security_message (lex_ctxt *lexic)
	Send a security message to the client.
tree_cell *	log_message (lex_ctxt *lexic)
tree_cell *	error_message2 (lex_ctxt *lexic)
tree_cell *	nasl_get_preference (lex_ctxt *lexic)
tree_cell *	nasl_vendor_version (lex_ctxt *lexic)
tree_cell *	nasl_update_table_driven_lsc_data (lex_ctxt *lexic)
	Communicate to the parent process that LSC data is ready for use in the host kb.
static tree_cell *	parse_notus (advisories_t *advisories)
static tree_cell *	parse_skiron (advisories_t *adv)
tree_cell *	nasl_notus (lex_ctxt *lexic)
	Directly runs a LSC with the given package list and OS release.
tree_cell *	nasl_notus_type (lex_ctxt *lexic)
	Get the Notus scan type.
tree_cell *	nasl_notus_error (lex_ctxt *lexic)
	Get the last Notus error as string.
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)

Variables
static int	notus_type = 0
	Type of Notus scan. This is either Notus or Skiron.
static int	notus_err = 0
	Error code for Notus.

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 50 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 951 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 945 of file nasl_scanner_glue.c.

Function Documentation

error_message2()

tree_cell * error_message2

(

lex_ctxt *

lexic

)

Definition at line 1179 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 766 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 714 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 = -1, 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 653 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_notus_result_message()

unsigned char * get_notus_result_message ( lex_ctxt * lexic, named_nasl_var * var )

static

Definition at line 1018 of file nasl_scanner_glue.c.

{
  named_nasl_var *vul_packages, *name, *version, *fixed, *fixed_version,
    *specifier, *start, *end;
  anon_nasl_var *pkg;
  int i;
  GString *result_buf, *buf;
 
  vul_packages = get_var_by_name (&var->u.v.v_arr, "vulnerable_packages");
  if (vul_packages == NULL || vul_packages->u.var_type != VAR2_ARRAY)
    {
      nasl_perror (lexic, "security_lsc: vul_packages is not an array\n");
      return NULL;
    }
  result_buf = g_string_new (NULL);
  for (i = 0; i < vul_packages->u.v.v_arr.max_idx; i++)
    {
      pkg = nasl_get_var_by_num (lexic, &vul_packages->u.v.v_arr, i, 0);
      if (pkg == NULL)
        continue;
 
      name = get_var_by_name (&pkg->v.v_arr, "name");
      version = get_var_by_name (&pkg->v.v_arr, "installed");
      fixed = get_var_by_name (&pkg->v.v_arr, "fixed");
      if (fixed == NULL)
        continue;
      fixed_version = get_var_by_name (&fixed->u.v.v_arr, "version");
      specifier = get_var_by_name (&fixed->u.v.v_arr, "specifier");
      start = get_var_by_name (&fixed->u.v.v_arr, "start");
      end = get_var_by_name (&fixed->u.v.v_arr, "end");
 
      if (name == NULL || version == NULL)
        {
          continue;
        }
 
      if (fixed_version != NULL && specifier != NULL)
        {
          buf = g_string_new (NULL);
          g_string_printf (buf,
                           "\n"
                           "Vulnerable package:   %s\n"
                           "Installed version:    %s-%s\n"
                           "Fixed version:      %2s%s-%s\n",
                           name->u.v.v_str.s_val, name->u.v.v_str.s_val,
                           version->u.v.v_str.s_val, specifier->u.v.v_str.s_val,
                           name->u.v.v_str.s_val,
                           fixed_version->u.v.v_str.s_val);
        }
      else if (start != NULL && end != NULL)
        {
          buf = g_string_new (NULL);
          g_string_printf (buf,
                           "\n"
                           "Vulnerable package:   %s\n"
                           "Installed version:    %s-%s\n"
                           "Fixed version:      < %s-%s\n"
                           "Fixed version:      >=%s-%s\n",
                           name->u.v.v_str.s_val, name->u.v.v_str.s_val,
                           version->u.v.v_str.s_val, name->u.v.v_str.s_val,
                           start->u.v.v_str.s_val, name->u.v.v_str.s_val,
                           end->u.v.v_str.s_val);
        }
      else
        {
          continue;
        }
      g_string_append (result_buf, buf->str);
      g_string_free (buf, TRUE);
    }
  return (unsigned char *) result_buf->str;
}

References get_var_by_name(), st_nasl_array::max_idx, name, nasl_get_var_by_num(), nasl_perror(), st_nasl_string::s_val, st_n_nasl_var::u, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, VAR2_ARRAY, and st_a_nasl_var::var_type.

Referenced by security_notus().

Here is the call graph for this function:

Here is the caller 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 635 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()

int isalldigit ( char * str, int len )

static

Definition at line 55 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 1171 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 1185 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_notus()

tree_cell * nasl_notus

(

lex_ctxt *

lexic

)

Directly runs a LSC with the given package list and OS release.

This function runs a Notus scan using the provided package list and OS release. As there are currently 2 types of LSC scanner, with different result formats, the result depends on the used scanner type. In case of Notus it returns a list of results in a JSON-like format. If an error occurs, it returns NULL and sets the notus_err variable to the appropriate error code. The error can be gathered using the notus_error function. In case of Skiron, it returns a dictionary with the OIDs and corresponding result messages.

NASL Function: notus\n

NASL Named Parameters:\n

• pkg_list String containing the gathered package list.
• product The OS release.

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

List of Notus results in a JSON-like format, NULL on error.

Definition at line 1444 of file nasl_scanner_glue.c.

{
  char *response;
  advisories_t *advisories = NULL;
  char *pkg_list = get_str_var_by_name (lexic, "pkg_list");
  char *product = get_str_var_by_name (lexic, "product");
 
  notus_err = 0;
 
  if (product == NULL || pkg_list == NULL)
    {
      g_warning ("%s: Missing data for running LSC", __func__);
      notus_err = -1;
      return NULL;
    }
 
  response = lsc_get_response (pkg_list, product);
 
  if (!response)
    {
      g_warning ("%s: Unable to get the response", __func__);
      notus_err = -2;
 
      return NULL;
    }
 
  advisories = lsc_process_response (response, strlen (response));
  g_free (response);
 
  if (!advisories)
    {
      g_warning ("%s: Unable to process the response", __func__);
      notus_err = -4;
 
      return NULL;
    }
 
  notus_type = advisories->type;
 
  if (notus_type == NOTUS)
    // TODO: Remove notus, when it is deprecated
    return parse_notus (advisories);
  else
    return parse_skiron (advisories);
}

References get_str_var_by_name(), lsc_get_response(), lsc_process_response(), NOTUS, notus_err, notus_type, parse_notus(), parse_skiron(), and advisories::type.

Here is the call graph for this function:

nasl_notus_error()

tree_cell * nasl_notus_error

(

lex_ctxt *

lexic

)

Get the last Notus error as string.

NASL Function: notus_error\n

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

Error message as a string.

Definition at line 1523 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  char *notus_err_str;
  (void) lexic;
 
  switch (notus_err)
    {
    case -1:
      notus_err_str = strdup ("Missing data for running LSC");
      break;
    case -2:
      notus_err_str = strdup ("Unable to get the response");
      break;
    case -3:
      notus_err_str = strdup ("Unknown fixed version type for advisory");
      break;
    case -4:
      notus_err_str = strdup ("Unable to process the response");
      break;
    default:
      return NULL;
    }
 
  retc = alloc_typed_cell (CONST_STR);
  retc->x.str_val = notus_err_str;
  retc->size = strlen (notus_err_str);
 
  return retc;
}

References alloc_typed_cell(), CONST_STR, notus_err, TC::size, TC::str_val, and TC::x.

Here is the call graph for this function:

nasl_notus_type()

tree_cell * nasl_notus_type

(

lex_ctxt *

lexic

)

Get the Notus scan type.

0 for Notus, 1 for Skiron.

NASL Function: notus_type\n

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

Scan type as integer.

Definition at line 1502 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  (void) lexic;
 
  retc = alloc_typed_cell (CONST_INT);
  retc->x.i_val = (int) notus_type;
  return retc;
}

References alloc_typed_cell(), CONST_INT, TC::i_val, notus_type, 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 1601 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 1561 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 1617 of file nasl_scanner_glue.c.

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

References FAKE_CELL.

nasl_update_table_driven_lsc_data()

tree_cell * nasl_update_table_driven_lsc_data

(

lex_ctxt *

lexic

)

Communicate to the parent process that LSC data is ready for use in the host kb.

NASL Function: update_table_driven_lsc_data\n

NASL Named Parameters:\n

• pkg_list String containing the gathered package list.
• os_release The OS release.

Parameters

[in]

lexic

Lexical context of the NASL interpreter.

Returns

NULL

Definition at line 1236 of file nasl_scanner_glue.c.

{
  struct script_infos *script_infos = lexic->script_infos;
  ipc_data_t *lsc = NULL;
  const char *json = NULL;
  gchar *pkg_list = get_str_var_by_name (lexic, "pkg_list");
  gchar *os_version = get_str_var_by_name (lexic, "os_release");
 
  if (os_version == NULL || pkg_list == NULL)
    {
      g_warning ("%s: Missing data for running LSC", __func__);
      return NULL;
    }
 
  plug_set_key (script_infos, "ssh/login/package_list_notus", ARG_STRING,
                pkg_list);
  plug_set_key (script_infos, "ssh/login/release_notus", ARG_STRING,
                os_version);
 
  lsc = ipc_data_type_from_lsc (TRUE);
  if (!lsc)
    return NULL;
 
  json = ipc_data_to_json (lsc);
  ipc_data_destroy (&lsc);
  if (ipc_send (lexic->script_infos->ipc_context, IPC_MAIN, json, strlen (json))
      < 0)
    g_warning ("Unable to send the package list for LSC to the host process");
 
  g_free ((void *) json);
  return NULL;
}

References ARG_STRING, get_str_var_by_name(), script_infos::ipc_context, ipc_data_destroy(), ipc_data_to_json(), ipc_data_type_from_lsc(), IPC_MAIN, ipc_send(), plug_set_key(), and struct_lex_ctxt::script_infos.

Here is the call graph for this function:

nasl_vendor_version()

tree_cell * nasl_vendor_version

(

lex_ctxt *

lexic

)

Definition at line 1208 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:

parse_notus()

tree_cell * parse_notus ( advisories_t * advisories )

static

Definition at line 1277 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  anon_nasl_var element;
 
  retc = alloc_typed_cell (DYN_ARRAY);
  retc->x.ref_val = g_malloc0 (sizeof (nasl_array));
 
  // Process the advisories, generate results and store them in the kb
  for (size_t i = 0; i < advisories->count; i++)
    {
      advisory_t *advisory = advisories->advisories[i];
      anon_nasl_var vulnerable_pkgs, oid;
 
      memset (&element, 0, sizeof (element));
      element.var_type = VAR2_ARRAY;
 
      memset (&vulnerable_pkgs, 0, sizeof (vulnerable_pkgs));
      vulnerable_pkgs.var_type = VAR2_ARRAY;
 
      memset (&oid, 0, sizeof (oid));
      oid.var_type = VAR2_STRING;
      oid.v.v_str.s_val = (unsigned char *) advisory->oid;
      oid.v.v_str.s_siz = strlen (advisory->oid);
 
      for (size_t j = 0; j < advisory->count; j++)
        {
          vuln_pkg_t *pkg = advisory->pkgs[j];
          anon_nasl_var name, installed, vul_pkg;
          memset (&name, 0, sizeof (name));
          memset (&installed, 0, sizeof (installed));
          memset (&vul_pkg, 0, sizeof (vul_pkg));
          name.var_type = VAR2_STRING;
          installed.var_type = VAR2_STRING;
          vul_pkg.var_type = VAR2_ARRAY;
          name.v.v_str.s_val = (unsigned char *) pkg->pkg_name;
          name.v.v_str.s_siz = strlen (pkg->pkg_name);
          installed.v.v_str.s_val = (unsigned char *) pkg->install_version;
          installed.v.v_str.s_siz = strlen (pkg->install_version);
 
          if (pkg->type == RANGE)
            {
              anon_nasl_var range, start, end;
              memset (&range, 0, sizeof (range));
              range.var_type = VAR2_ARRAY;
 
              memset (&start, 0, sizeof (start));
              start.var_type = VAR2_STRING;
              start.v.v_str.s_val = (unsigned char *) pkg->range->start;
              start.v.v_str.s_siz = strlen (pkg->range->start);
              add_var_to_array (&range.v.v_arr, "start", &start);
 
              memset (&end, 0, sizeof (end));
              end.var_type = VAR2_STRING;
              end.v.v_str.s_val = (unsigned char *) pkg->range->stop;
              end.v.v_str.s_siz = strlen (pkg->range->stop);
              add_var_to_array (&range.v.v_arr, "end", &end);
              add_var_to_array (&vul_pkg.v.v_arr, "fixed", &range);
            }
          else if (pkg->type == SINGLE)
            {
              anon_nasl_var single, version, specifier;
 
              memset (&single, 0, sizeof (single));
              single.var_type = VAR2_ARRAY;
 
              memset (&version, 0, sizeof (version));
              version.var_type = VAR2_STRING;
              version.v.v_str.s_val = (unsigned char *) pkg->version->version;
              version.v.v_str.s_siz = strlen (pkg->version->version);
              add_var_to_array (&single.v.v_arr, "version", &version);
 
              memset (&specifier, 0, sizeof (specifier));
              specifier.var_type = VAR2_STRING;
              specifier.v.v_str.s_val =
                (unsigned char *) pkg->version->specifier;
              specifier.v.v_str.s_siz = strlen (pkg->version->specifier);
              add_var_to_array (&single.v.v_arr, "specifier", &specifier);
 
              add_var_to_array (&vul_pkg.v.v_arr, "fixed", &single);
            }
          else
            {
              g_warning ("%s: Unknown fixed version type for advisory %s",
                         __func__, advisory->oid);
              advisories_free (advisories);
              notus_err = -3;
              deref_cell (retc);
 
              return NULL;
            }
          add_var_to_array (&vul_pkg.v.v_arr, "name", &name);
          add_var_to_array (&vul_pkg.v.v_arr, "installed", &installed);
          add_var_to_list (&vulnerable_pkgs.v.v_arr, j, &vul_pkg);
        }
 
      add_var_to_array (&element.v.v_arr, "oid", &oid);
      add_var_to_array (&element.v.v_arr, "vulnerable_packages",
                        &vulnerable_pkgs);
      add_var_to_list (retc->x.ref_val, i, &element);
    }
 
  advisories_free (advisories);
 
  return retc;
}

References add_var_to_array(), add_var_to_list(), advisories::advisories, advisories_free(), alloc_typed_cell(), advisories::count, notus_advisory::count, deref_cell(), DYN_ARRAY, vulnerable_pkg::install_version, name, notus_err, notus_advisory::oid, oid, vulnerable_pkg::pkg_name, notus_advisory::pkgs, RANGE, vulnerable_pkg::range, TC::ref_val, st_nasl_string::s_siz, st_nasl_string::s_val, SINGLE, fixed_version::specifier, version_range::start, version_range::stop, vulnerable_pkg::type, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_STRING, st_a_nasl_var::var_type, fixed_version::version, vulnerable_pkg::version, and TC::x.

Referenced by nasl_notus().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_skiron()

tree_cell * parse_skiron ( advisories_t * adv )

static

Definition at line 1385 of file nasl_scanner_glue.c.

{
  tree_cell *retc;
  anon_nasl_var element;
 
  retc = alloc_typed_cell (DYN_ARRAY);
  retc->x.ref_val = g_malloc0 (sizeof (nasl_array));
 
  for (size_t i = 0; i < adv->count; i++)
    {
      skiron_advisory_t *advisory = adv->skiron_advisories[i];
      anon_nasl_var msg, oid;
 
      memset (&element, 0, sizeof (element));
      element.var_type = VAR2_ARRAY;
 
      memset (&msg, 0, sizeof (msg));
      msg.var_type = VAR2_STRING;
      msg.v.v_str.s_val = (unsigned char *) advisory->message;
      msg.v.v_str.s_siz = strlen (advisory->message);
 
      memset (&oid, 0, sizeof (oid));
      oid.var_type = VAR2_STRING;
      oid.v.v_str.s_val = (unsigned char *) advisory->oid;
      oid.v.v_str.s_siz = strlen (advisory->oid);
 
      add_var_to_array (&element.v.v_arr, "oid", &oid);
      add_var_to_array (&element.v.v_arr, "message", &msg);
      add_var_to_list (retc->x.ref_val, i, &element);
    }
  advisories_free (adv);
 
  return retc;
}

References add_var_to_array(), add_var_to_list(), advisories_free(), alloc_typed_cell(), advisories::count, DYN_ARRAY, skiron_advisory::message, oid, skiron_advisory::oid, TC::ref_val, st_nasl_string::s_siz, st_nasl_string::s_val, advisories::skiron_advisories, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, VAR2_ARRAY, VAR2_STRING, st_a_nasl_var::var_type, and TC::x.

Referenced by nasl_notus().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_kb_item()

tree_cell * replace_kb_item

(

lex_ctxt *

lexic

)

Definition at line 785 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");
      size_t 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 617 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 440 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 260 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 253 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 117 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 284 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 381 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 277 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 497 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 534 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 578 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 334 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 239 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 110 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 310 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 404 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 422 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 199 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 92 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 246 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 155 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 1165 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_notus()

tree_cell * security_notus

(

lex_ctxt *

lexic

)

Definition at line 1092 of file nasl_scanner_glue.c.

{
  tree_cell *result;
  gchar *kb_result;
  named_nasl_var *oid_var, *var;
  unsigned char *oid, *result_string;
 
  result = get_variable_by_name (lexic, "result");
  if (result == NULL)
    {
      nasl_perror (lexic, "security_lsc: oid or result is NULL\n");
      return FAKE_CELL;
    }
 
  var = (named_nasl_var *) result->x.ref_val;
 
  oid_var = get_var_by_name (&var->u.v.v_arr, "oid");
  if (oid_var == NULL)
    {
      nasl_perror (lexic, "security_lsc: oid not found\n");
      return NULL;
    }
 
  oid = (unsigned char *) oid_var->u.v.v_str.s_val;
 
  if (notus_type == NOTUS)
    {
      result_string = get_notus_result_message (lexic, var);
    }
  else
    {
      named_nasl_var *message;
      message = get_var_by_name (&var->u.v.v_arr, "message");
      if (message == NULL)
        {
          nasl_perror (lexic, "security_lsc: message not found\n");
          return NULL;
        }
      result_string = message->u.v.v_str.s_val;
    }
 
  if (result_string == NULL)
    {
      nasl_perror (lexic, "security_lsc: No results to publish\n");
      return FAKE_CELL;
    }
 
  gchar ip_str[INET6_ADDRSTRLEN];
  addr6_to_str (lexic->script_infos->ip, ip_str);
  // type|||IP|||HOSTNAME|||package|||OID|||the result message|||URI
  kb_result = g_strdup_printf ("%s|||%s|||%s|||%s|||%s|||%s|||%s", "ALARM",
                               ip_str, " ", "package", oid, result_string, "");
 
  // Only free result_string for notus type, as skiron uses a reference to a
  // nasl var
  if (notus_type == NOTUS)
    g_free (result_string);
 
  kb_item_push_str_with_main_kb_check (get_main_kb (), "internal/results",
                                       kb_result);
  g_free (kb_result);
 
  return FAKE_CELL;
}

References FAKE_CELL, get_main_kb(), get_notus_result_message(), get_var_by_name(), get_variable_by_name(), script_infos::ip, kb_item_push_str_with_main_kb_check(), nasl_perror(), NOTUS, notus_type, oid, TC::ref_val, st_nasl_string::s_val, struct_lex_ctxt::script_infos, st_n_nasl_var::u, st_a_nasl_var::v, st_a_nasl_var::v_arr, st_a_nasl_var::v_str, and TC::x.

Here is the call graph for this function:

security_something()

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

static

Definition at line 960 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)
    {
      size_t len = get_var_size_by_name (lexic, "data");
      size_t 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_message2(), 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 895 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");
      size_t 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()

tree_cell * set_kb_item_volatile ( lex_ctxt * lexic )

static

Set a volatile 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 837 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");
      size_t 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:

Variable Documentation

notus_err

int notus_err = 0

static

Error code for Notus.

The last occurred error code is stored in this variable.

Definition at line 1274 of file nasl_scanner_glue.c.

Referenced by nasl_notus(), nasl_notus_error(), and parse_notus().

notus_type

int notus_type = 0

static

Type of Notus scan. This is either Notus or Skiron.

Definition at line 957 of file nasl_scanner_glue.c.

Referenced by nasl_notus(), nasl_notus_type(), and security_notus().