#include "openvas.h"
#include "../misc/kb_cache.h"
#include "../misc/plugutils.h"
#include "../misc/scan_id.h"
#include "../misc/vendorversion.h"
#include "attack.h"
#include "debug_utils.h"
#include "pluginlaunch.h"
#include "processes.h"
#include "sighand.h"
#include "utils.h"
#include <bsd/unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <gcrypt.h>
#include <glib.h>
#include <gnutls/gnutls.h>
#include <grp.h>
#include <gvm/base/logging.h>
#include <gvm/base/nvti.h>
#include <gvm/base/prefs.h>
#include <gvm/base/version.h>
#include <gvm/util/kb.h>
#include <gvm/util/mqtt.h>
#include <gvm/util/nvticache.h>
#include <gvm/util/uuidutils.h>
#include <netdb.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <unistd.h>
#include "../misc/network.h"

Include dependency graph for openvas.c:

Data Structures
struct	openvas_option

Macros
#define	G_LOG_DOMAIN "sd main"
	GLib log domain.

#define	PROCTITLE_WAITING "openvas: Waiting for incoming connections"

#define	PROCTITLE_LOADING "openvas: Loading Handler"

#define	PROCTITLE_RELOADING "openvas: Reloading"

#define	PROCTITLE_SERVING "openvas: Serving %s"

Functions
static void	set_default_openvas_prefs ()
	Set the prefs from the openvas_defaults array.

static void	my_gnutls_log_func (int level, const char *text)

static void	set_globals_from_preferences (void)

static void	handle_termination_signal (int sig)

static void	init_signal_handlers (void)
	Initializes main scanner process' signal handlers.

static int	overwrite_openvas_prefs_with_prefs_from_client (struct scan_globals *globals)
	Read the scan preferences from redis.

static int	init_logging ()
	Init logging.

static void	gcrypt_init (void)

static void	check_tls ()
	Check TLS.

static void	openvas_print_start_msg ()
	Print start message.

static int	stop_single_task_scan (void)
	Search in redis the process ID of a running scan and sends it the kill signal SIGUSR1, which will stop the scan. To find the process ID, it uses the scan_id passed with the –scan-stop option.

static void	send_message_to_client_and_finish_scan (const char *msg)
	Send a failure message and set the scan as finished.

static int	attack_network_init (struct scan_globals globals, const gchar config_file)
	Set up data needed for attack_network().

int	openvas (int argc, char argv[], char env[])
	openvas.

Variables
int	global_max_hosts = 15

int	global_max_checks = 10

int	global_min_memory = 0

int	global_max_sysload = 0

GSList *	log_config = NULL
	Logging parameters, as passed to setup_log_handlers.

static volatile int	termination_signal = 0

static openvas_option	openvas_defaults []
	Default values for scanner options. Must be NULL terminated.

Detailed Description

OpenVAS main module, runs the scanner.

Definition in file openvas.c.

Macro Definition Documentation

◆ G_LOG_DOMAIN

#define G_LOG_DOMAIN "sd main"

GLib log domain.

Definition at line 73 of file openvas.c.

◆ PROCTITLE_LOADING

#define PROCTITLE_LOADING "openvas: Loading Handler"

Definition at line 76 of file openvas.c.

◆ PROCTITLE_RELOADING

#define PROCTITLE_RELOADING "openvas: Reloading"

Definition at line 77 of file openvas.c.

◆ PROCTITLE_SERVING

#define PROCTITLE_SERVING "openvas: Serving %s"

Definition at line 78 of file openvas.c.

◆ PROCTITLE_WAITING

#define PROCTITLE_WAITING "openvas: Waiting for incoming connections"

Definition at line 75 of file openvas.c.

Function Documentation

◆ attack_network_init()

static int attack_network_init	(	struct scan_globals *	globals,
		const gchar *	config_file
	)

static

Set up data needed for attack_network().

Parameters

globals	scan_globals needed for client preference handling.
config_file	Used for config preference handling.

Returns: 0 on success, 1 otherwise.

Definition at line 410 of file openvas.c.

{
  const char *mqtt_server_uri;
 
  set_default_openvas_prefs ();
  prefs_config (config_file);
  set_globals_from_preferences ();
 
  if (prefs_get ("vendor_version") != NULL)
    vendor_version_set (prefs_get ("vendor_version"));
  check_tls ();
  openvas_print_start_msg ();
 
  if (plugins_cache_init ())
    {
      g_message ("Failed to initialize nvti cache.");
      send_message_to_client_and_finish_scan (
        "ERRMSG||| ||| ||| ||| |||NVTI cache initialization failed");
      nvticache_reset ();
      return 1;
    }
  nvticache_reset ();
 
  /* Init MQTT communication */
  mqtt_server_uri = prefs_get ("mqtt_server_uri");
  if (mqtt_server_uri)
    {
      if ((mqtt_init (mqtt_server_uri)) != 0)
        {
          g_message ("%s: INIT MQTT: FAIL", __func__);
          send_message_to_client_and_finish_scan (
            "ERRMSG||| ||| ||| ||| |||MQTT initialization failed");
        }
      else
        {
          g_message ("%s: INIT MQTT: SUCCESS", __func__);
          prefs_set ("mqtt_enabled", "yes");
        }
    }
 
  init_signal_handlers ();
 
  /* Make process a group leader, to make it easier to cleanup forked
   * processes & their children. */
  setpgid (0, 0);
 
  if (overwrite_openvas_prefs_with_prefs_from_client (globals))
    {
      g_warning ("No preferences found for the scan %s", globals->scan_id);
      return 1;
    }
 
  return 0;
}

References check_tls(), init_signal_handlers(), openvas_print_start_msg(), overwrite_openvas_prefs_with_prefs_from_client(), plugins_cache_init(), scan_globals::scan_id, send_message_to_client_and_finish_scan(), set_default_openvas_prefs(), set_globals_from_preferences(), and vendor_version_set().

Referenced by openvas().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_tls()

static void check_tls ( )

static

Check TLS.

Definition at line 312 of file openvas.c.

{
#if GNUTLS_VERSION_NUMBER < 0x030300
  if (openvas_SSL_init () < 0)
    g_message ("Could not initialize openvas SSL!");
#endif
 
  if (prefs_get ("debug_tls") != NULL && atoi (prefs_get ("debug_tls")) > 0)
    {
      g_warning ("TLS debug is enabled and should only be used with care, "
                 "since it may reveal sensitive information in the scanner "
                 "logs and might make openvas fill your disk rather quickly.");
      gnutls_global_set_log_function (my_gnutls_log_func);
      gnutls_global_set_log_level (atoi (prefs_get ("debug_tls")));
    }
}

References my_gnutls_log_func(), and openvas_SSL_init().

Referenced by attack_network_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gcrypt_init()

static void gcrypt_init ( void )

static

Definition at line 297 of file openvas.c.

{
  if (gcry_control (GCRYCTL_ANY_INITIALIZATION_P))
    return;
  gcry_check_version (NULL);
  gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
  gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
  gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
  gcry_control (GCRYCTL_INITIALIZATION_FINISHED);
}

Referenced by openvas().

Here is the caller graph for this function:

◆ handle_termination_signal()

static void handle_termination_signal ( int sig )

static

Definition at line 168 of file openvas.c.

{
  termination_signal = sig;
  procs_terminate_childs ();
}

References procs_terminate_childs(), and termination_signal.

Referenced by init_signal_handlers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_logging()

static int init_logging ( )

static

Init logging.

Returns: 0 on success, -1 on error.

Definition at line 273 of file openvas.c.

{
  static gchar *log_config_file_name = NULL;
  int err;
 
  log_config_file_name =
    g_build_filename (OPENVAS_SYSCONF_DIR, "openvas_log.conf", NULL);
  if (g_file_test (log_config_file_name, G_FILE_TEST_EXISTS))
    log_config = load_log_configuration (log_config_file_name);
  err = setup_log_handlers (log_config);
  if (err)
    {
      g_warning ("%s: Can not open or create log file or directory. "
                 "Please check permissions of log files listed in %s.",
                 __func__, log_config_file_name);
      g_free (log_config_file_name);
      return -1;
    }
  g_free (log_config_file_name);
 
  return 0;
}

References log_config.

Referenced by openvas().

Here is the caller graph for this function:

◆ init_signal_handlers()

static void init_signal_handlers ( void )

static

Initializes main scanner process' signal handlers.

Definition at line 178 of file openvas.c.

{
  openvas_signal (SIGTERM, handle_termination_signal);
  openvas_signal (SIGINT, handle_termination_signal);
  openvas_signal (SIGQUIT, handle_termination_signal);
  openvas_signal (SIGCHLD, sighand_chld);
}

References handle_termination_signal(), openvas_signal, and sighand_chld().

Referenced by attack_network_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ my_gnutls_log_func()

static void my_gnutls_log_func	(	int	level,
		const char *	text
	)

static

Definition at line 128 of file openvas.c.

{
  g_message ("(%d) %s", level, text);
}

Referenced by check_tls().

Here is the caller graph for this function:

◆ openvas()

int openvas	(	int	argc,
		char *	argv[],
		char *	env[]
	)

openvas.

Parameters

argc	Argument count.
argv	Argument vector.

Definition at line 471 of file openvas.c.

{
  int err;
 
  setproctitle_init (argc, argv, env);
  gcrypt_init ();
 
  static gboolean display_version = FALSE;
  static gchar *config_file = NULL;
  static gchar *scan_id = NULL;
  static gchar *stop_scan_id = NULL;
  static gboolean print_specs = FALSE;
  static gboolean print_sysconfdir = FALSE;
  static gboolean update_vt_info = FALSE;
  GError *error = NULL;
  GOptionContext *option_context;
  static GOptionEntry entries[] = {
    {"version", 'V', 0, G_OPTION_ARG_NONE, &display_version,
     "Display version information", NULL},
    {"config-file", 'c', 0, G_OPTION_ARG_FILENAME, &config_file,
     "Configuration file", "<filename>"},
    {"cfg-specs", 's', 0, G_OPTION_ARG_NONE, &print_specs,
     "Print configuration settings", NULL},
    {"sysconfdir", 'y', 0, G_OPTION_ARG_NONE, &print_sysconfdir,
     "Print system configuration directory (set at compile time)", NULL},
    {"update-vt-info", 'u', 0, G_OPTION_ARG_NONE, &update_vt_info,
     "Updates VT info into redis store from VT files", NULL},
    {"scan-start", '\0', 0, G_OPTION_ARG_STRING, &scan_id,
     "ID of scan to start. ID and related data must be stored into redis "
     "before.",
     "<string>"},
    {"scan-stop", '\0', 0, G_OPTION_ARG_STRING, &stop_scan_id,
     "ID of scan to stop", "<string>"},
 
    {NULL, 0, 0, 0, NULL, NULL, NULL}};
 
  option_context =
    g_option_context_new ("- Open Vulnerability Assessment Scanner");
  g_option_context_add_main_entries (option_context, entries, NULL);
  if (!g_option_context_parse (option_context, &argc, &argv, &error))
    {
      g_print ("%s\n\n", error->message);
      return EXIT_SUCCESS;
    }
  g_option_context_free (option_context);
 
  /* --sysconfdir */
  if (print_sysconfdir)
    {
      g_print ("%s\n", SYSCONFDIR);
      return EXIT_SUCCESS;
    }
 
  /* --version */
  if (display_version)
    {
      printf ("OpenVAS %s\n", OPENVAS_VERSION);
#ifdef OPENVAS_GIT_REVISION
      printf ("GIT revision %s\n", OPENVAS_GIT_REVISION);
#endif
      printf ("gvm-libs %s\n", gvm_libs_version ());
      printf ("Most new code since 2005: (C) 2022 Greenbone Networks GmbH\n");
      printf (
        "Nessus origin: (C) 2004 Renaud Deraison <deraison@nessus.org>\n");
      printf ("License GPLv2: GNU GPL version 2\n");
      printf (
        "This is free software: you are free to change and redistribute it.\n"
        "There is NO WARRANTY, to the extent permitted by law.\n\n");
      return EXIT_SUCCESS;
    }
 
  /* Switch to UTC so that OTP times are always in UTC. */
  if (setenv ("TZ", "utc 0", 1) == -1)
    {
      g_print ("%s\n\n", strerror (errno));
      return EXIT_SUCCESS;
    }
  tzset ();
 
#ifdef LOG_REFERENCES_AVAILABLE
  if (scan_id)
    set_log_reference (scan_id);
  if (stop_scan_id)
    set_log_reference (stop_scan_id);
#endif // LOG_REFERENCES_AVAILABLE
  if (init_logging () != 0)
    return EXIT_FAILURE;
 
  if (!init_sentry ())
    {
      g_message ("Sentry is enabled. This can log sensitive information.");
    }
 
  /* Config file location */
  if (!config_file)
    config_file = OPENVAS_CONF;
 
  if (update_vt_info)
    {
      set_default_openvas_prefs ();
      prefs_config (config_file);
      set_globals_from_preferences ();
      err = plugins_init ();
      nvticache_reset ();
      gvm_close_sentry ();
      return err ? EXIT_FAILURE : EXIT_SUCCESS;
    }
 
  /* openvas --scan-stop */
  if (stop_scan_id)
    {
      set_default_openvas_prefs ();
      prefs_config (config_file);
      if (plugins_cache_init ())
        {
          g_message ("Failed to initialize nvti cache. Not possible to "
                     "stop the scan");
          nvticache_reset ();
          gvm_close_sentry ();
          return EXIT_FAILURE;
        }
      nvticache_reset ();
 
      set_scan_id (g_strdup (stop_scan_id));
      err = stop_single_task_scan ();
      gvm_close_sentry ();
#ifdef LOG_REFERENCES_AVAILABLE
      free_log_reference ();
#endif // LOG_REFERENCES_AVAILABLE
      return err ? EXIT_FAILURE : EXIT_SUCCESS;
    }
 
  /* openvas --scan-start */
  if (scan_id)
    {
      struct scan_globals *globals;
      set_scan_id (g_strdup (scan_id));
      globals = g_malloc0 (sizeof (struct scan_globals));
      globals->scan_id = g_strdup (get_scan_id ());
 
      if (attack_network_init (globals, config_file) != 0)
        {
          destroy_scan_globals (globals);
          return EXIT_FAILURE;
        }
      attack_network (globals);
 
      gvm_close_sentry ();
      destroy_scan_globals (globals);
#ifdef LOG_REFERENCES_AVAILABLE
      free_log_reference ();
#endif // LOG_REFERENCES_AVAILABLE
      return EXIT_SUCCESS;
    }
 
  if (print_specs)
    {
      set_default_openvas_prefs ();
      prefs_config (config_file);
      prefs_dump ();
      gvm_close_sentry ();
    }
 
  return EXIT_SUCCESS;
}

References attack_network(), attack_network_init(), destroy_scan_globals(), gcrypt_init(), get_scan_id(), init_logging(), init_sentry(), plugins_cache_init(), plugins_init(), scan_id, scan_globals::scan_id, set_default_openvas_prefs(), set_globals_from_preferences(), set_scan_id(), and stop_single_task_scan().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ openvas_print_start_msg()

static void openvas_print_start_msg ( )

static

Print start message.

Definition at line 333 of file openvas.c.

{
#ifdef OPENVAS_GIT_REVISION
  g_message ("openvas %s (GIT revision %s) started", OPENVAS_VERSION,
             OPENVAS_GIT_REVISION);
#else
  g_message ("openvas %s started", OPENVAS_VERSION);
#endif
}

Referenced by attack_network_init().

Here is the caller graph for this function:

◆ overwrite_openvas_prefs_with_prefs_from_client()

static int overwrite_openvas_prefs_with_prefs_from_client ( struct scan_globals * globals )

static

Read the scan preferences from redis.

Adds preferences to the global_prefs. If preference already exists in global_prefs they will be overwritten by prefs from client.

Parameters

globals Scan ID of globals used as key to find the corresponding KB where to take the preferences from. Globals also used for file upload.

Returns: 0 on success, -1 if the kb is not found or no prefs are found in the kb.

Definition at line 200 of file openvas.c.

{
  char key[1024];
  kb_t kb;
  struct kb_item *res = NULL;
 
  g_debug ("Start loading scan preferences.");
  if (!globals->scan_id)
    return -1;
 
  snprintf (key, sizeof (key), "internal/%s/scanprefs", globals->scan_id);
 
  kb = kb_find (prefs_get ("db_address"), key);
  if (!kb)
    return -1;
  // 2022-10-19: currently internal/%s/scanprefs are set by ospd which is the
  // main_kb in our context
  set_main_kb (kb);
 
  res = kb_item_get_all (kb, key);
  if (!res)
    return -1;
 
  while (res)
    {
      gchar **pref = g_strsplit (res->v_str, "|||", 2);
      if (pref[0])
        {
          gchar **pref_name = g_strsplit (pref[0], ":", 3);
          if (pref_name[1] && pref_name[2] && !strncmp (pref_name[2], "file", 4)
              && strcmp (pref[1], ""))
            {
              char *file_uuid = gvm_uuid_make ();
              int ret;
              prefs_set (pref[0], file_uuid);
              ret = store_file (globals, pref[1], file_uuid);
              if (ret)
                g_debug ("Load preference: Failed to upload file "
                         "for nvt %s preference.",
                         pref_name[0]);
 
              g_free (file_uuid);
            }
          else if (is_scanner_only_pref (pref[0]))
            g_warning ("%s is a scanner only preference. It can not be written "
                       "by the client and will be ignored.",
                       pref_name[0]);
          else
            prefs_set (pref[0], pref[1] ? pref[1] : "");
          g_strfreev (pref_name);
        }
 
      g_strfreev (pref);
      res = res->next;
    }
  kb_del_items (kb, key);
  snprintf (key, sizeof (key), "internal/%s", globals->scan_id);
  kb_item_set_str_with_main_kb_check (kb, key, "ready", 0);
  kb_item_set_int_with_main_kb_check (kb, "internal/ovas_pid", getpid ());
  kb_lnk_reset (kb);
 
  g_debug ("End loading scan preferences.");
 
  kb_item_free (res);
  return 0;
}

References is_scanner_only_pref(), kb_item_set_int_with_main_kb_check(), kb_item_set_str_with_main_kb_check(), scan_globals::scan_id, set_main_kb(), and store_file().

Referenced by attack_network_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_message_to_client_and_finish_scan()

static void send_message_to_client_and_finish_scan ( const char * msg )

static

Send a failure message and set the scan as finished.

Parameters

msg	Message to send to the client.

Definition at line 387 of file openvas.c.

{
  char key[1024];
  kb_t kb;
 
  // We get the main kb. It is still not set as global at this point.
  snprintf (key, sizeof (key), "internal/%s/scanprefs", get_scan_id ());
  kb = kb_find (prefs_get ("db_address"), key);
  kb_item_push_str (kb, "internal/results", msg);
  snprintf (key, sizeof (key), "internal/%s", get_scan_id ());
  kb_item_set_str (kb, key, "finished", 0);
  kb_lnk_reset (kb);
}

References get_scan_id().

Referenced by attack_network_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_default_openvas_prefs()

static void set_default_openvas_prefs ( )

static

Set the prefs from the openvas_defaults array.

Definition at line 121 of file openvas.c.

{
  for (int i = 0; openvas_defaults[i].option != NULL; i++)
    prefs_set (openvas_defaults[i].option, openvas_defaults[i].value);
}

References openvas_defaults, option, and openvas_option::option.

Referenced by attack_network_init(), and openvas().

Here is the caller graph for this function:

◆ set_globals_from_preferences()

static void set_globals_from_preferences ( void )

static

Definition at line 134 of file openvas.c.

{
  const char *str;
 
  if ((str = prefs_get ("max_hosts")) != NULL)
    {
      global_max_hosts = atoi (str);
      if (global_max_hosts <= 0)
        global_max_hosts = 15;
    }
 
  if ((str = prefs_get ("max_checks")) != NULL)
    {
      global_max_checks = atoi (str);
      if (global_max_checks <= 0)
        global_max_checks = 10;
    }
 
  if ((str = prefs_get ("max_sysload")) != NULL)
    {
      global_max_sysload = atoi (str);
      if (global_max_sysload <= 0)
        global_max_sysload = 0;
    }
 
  if ((str = prefs_get ("min_free_mem")) != NULL)
    {
      global_min_memory = atoi (str);
      if (global_min_memory <= 0)
        global_min_memory = 0;
    }
}

References global_max_checks, global_max_hosts, global_max_sysload, and global_min_memory.

Referenced by attack_network_init(), and openvas().

Here is the caller graph for this function:

◆ stop_single_task_scan()

static int stop_single_task_scan ( void )

static

Search in redis the process ID of a running scan and sends it the kill signal SIGUSR1, which will stop the scan. To find the process ID, it uses the scan_id passed with the –scan-stop option.

Returns: 0 on success, 1 otherwise.

Definition at line 352 of file openvas.c.

{
  char key[1024];
  kb_t kb;
  int pid;
 
  if (!get_scan_id ())
    return 1;
 
  snprintf (key, sizeof (key), "internal/%s", get_scan_id ());
  kb = kb_find (prefs_get ("db_address"), key);
  if (!kb)
    return 1;
 
  pid = kb_item_get_int (kb, "internal/ovas_pid");
 
  /* Only send the signal if the pid is a positive value.
     Since kb_item_get_int() will return -1 if the key does
     not exist.
     Warning: killing with -1 pid will send the signal system wide.
   */
  if (pid <= 0)
    return 1;
 
  /* Send the signal to the process group. */
  killpg (pid, SIGUSR1);
  return 0;
}

References get_scan_id(), and pid.

Referenced by openvas().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ global_max_checks

int global_max_checks = 10

Definition at line 84 of file openvas.c.

Referenced by get_max_checks_number(), and set_globals_from_preferences().

◆ global_max_hosts

int global_max_hosts = 15

Globals that should not be touched (used in utils module).

Definition at line 83 of file openvas.c.

Referenced by get_max_hosts_number(), and set_globals_from_preferences().

◆ global_max_sysload

int global_max_sysload = 0

Definition at line 87 of file openvas.c.

Referenced by check_sysload(), and set_globals_from_preferences().

◆ global_min_memory

int global_min_memory = 0

Definition at line 86 of file openvas.c.

Referenced by check_memory(), and set_globals_from_preferences().

◆ log_config

GSList* log_config = NULL

Logging parameters, as passed to setup_log_handlers.

Definition at line 92 of file openvas.c.

Referenced by init_logging().

◆ openvas_defaults

openvas_option openvas_defaults[]

static

Initial value:

= {
  {"plugins_folder", OPENVAS_NVT_DIR},
  {"include_folders", OPENVAS_NVT_DIR},
  {"plugins_timeout", G_STRINGIFY (NVT_TIMEOUT)},
  {"scanner_plugins_timeout", G_STRINGIFY (SCANNER_NVT_TIMEOUT)},
  {"db_address", KB_PATH_DEFAULT},
  {NULL, NULL}}

Default values for scanner options. Must be NULL terminated.

Only include options which are dependent on CMake variables. Empty options must be "\0", not NULL, to match the behavior of prefs_init.

Definition at line 109 of file openvas.c.

Referenced by set_default_openvas_prefs().

◆ termination_signal

volatile int termination_signal = 0

static

Definition at line 94 of file openvas.c.

Referenced by handle_termination_signal().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ G_LOG_DOMAIN

◆ PROCTITLE_LOADING

◆ PROCTITLE_RELOADING

◆ PROCTITLE_SERVING

◆ PROCTITLE_WAITING

Function Documentation

◆ attack_network_init()

◆ check_tls()

◆ gcrypt_init()

◆ handle_termination_signal()

◆ init_logging()

◆ init_signal_handlers()

◆ my_gnutls_log_func()

◆ openvas()

◆ openvas_print_start_msg()

◆ overwrite_openvas_prefs_with_prefs_from_client()

◆ send_message_to_client_and_finish_scan()

◆ set_default_openvas_prefs()

◆ set_globals_from_preferences()

◆ stop_single_task_scan()

Variable Documentation

◆ global_max_checks

◆ global_max_hosts

◆ global_max_sysload

◆ global_min_memory

◆ log_config

◆ openvas_defaults

◆ termination_signal