openvassd.c File Reference

#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <netdb.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <sys/stat.h>
#include <pwd.h>
#include <grp.h>
#include <openvas/misc/openvas_proctitle.h>
#include <openvas/misc/openvas_logging.h>
#include <openvas/base/pidfile.h>
#include <openvas/base/nvticache.h>
#include <openvas/base/kb.h>
#include <openvas/base/gpgme_util.h>
#include <openvas/misc/prefs.h>
#include <openvas/misc/vendorversion.h>
#include <gcrypt.h>
#include "comm.h"
#include "attack.h"
#include "sighand.h"
#include "log.h"
#include "processes.h"
#include "ntp.h"
#include "utils.h"
#include "pluginlaunch.h"
#include <openvas/misc/network.h>

Include dependency graph for openvassd.c:

Go to the source code of this file.

Data Structures
struct	openvassd_option

Functions
void	loading_handler_stop (pid_t handler_pid)
void	check_kb_status ()
	Check if Redis Server is up and if the KB exists. If KB does not exist,force a reload and stop all the running scans. More...
int	main (int argc, char *argv[])
	openvassd. More...

Variables
int	global_max_hosts = 15
int	global_max_checks = 10
gchar *	unix_socket_path = NULL

Detailed Description

OpenVAS Scanner main module, runs the scanner.

Definition in file openvassd.c.

Function Documentation

check_kb_status()

void check_kb_status

(

)

Check if Redis Server is up and if the KB exists. If KB does not exist,force a reload and stop all the running scans.

Definition at line 570 of file openvassd.c.

References log_write().

{
  int  waitredis = 5, waitkb = 5, ret = 0;
  kb_t kb_access_aux;

  while (waitredis != 0)
    {
      ret = kb_new (&kb_access_aux, prefs_get ("kb_location"));
      if (ret)
        {
          log_write ("Redis connection lost. Trying to reconnect.");
          waitredis--;
          sleep (5);
          continue;
        }
      else
        {
          kb_delete (kb_access_aux);
          break;
        }
    }

  if (waitredis == 0)
    {
      log_write ("Critical Redis connection error.");
      exit (1);
    }

  while (waitkb != 0)
    {
      kb_access_aux = kb_find (prefs_get ("kb_location"), "nvticache");
      if (!kb_access_aux)
        {
          log_write ("Redis kb not found. Trying again in 2 seconds.");
          waitkb--;
          sleep (2);
          continue;
        }
      else
        {
          kb_lnk_reset (kb_access_aux);
          g_free (kb_access_aux);
          break;
        }
    }

  if (waitredis != 5 || waitkb == 0)
    {
      log_write ("Redis connection error. Stopping all the running scans.");
      stop_all_scans ();
      reload_openvassd ();
    }
}

Here is the call graph for this function:

loading_handler_stop()

void loading_handler_stop

(

pid_t

handler_pid

)

Definition at line 343 of file openvassd.c.

References destroy_loading_shm(), and terminate_process().

{
  terminate_process (handler_pid);
  destroy_loading_shm ();
}

Here is the call graph for this function:

main()

int main	(	int	argc,
		char *	argv[]
	)

openvassd.

Parameters

argc	Argument count.
argv	Argument vector.

Definition at line 874 of file openvassd.c.

{
  int ret;
  pid_t handler_pid;

  proctitle_init (argc, argv);
  gcrypt_init ();

  static gboolean display_version = FALSE;
  static gboolean dont_fork = FALSE;
  static gchar *config_file = NULL;
  static gchar *vendor_version_string = NULL;
  static gchar *listen_owner = NULL;
  static gchar *listen_group = NULL;
  static gchar *listen_mode = NULL;
  static gchar *gnupg_dir = NULL;
  static gboolean print_specs = FALSE;
  static gboolean print_sysconfdir = FALSE;
  static gboolean only_cache = FALSE;
  GError *error = NULL;
  GOptionContext *option_context;
  static GOptionEntry entries[] = {
    {"version", 'V', 0, G_OPTION_ARG_NONE, &display_version,
     "Display version information", NULL},
    {"foreground", 'f', 0, G_OPTION_ARG_NONE, &dont_fork,
     "Do not run in daemon mode but stay in foreground", NULL},
    {"config-file", 'c', 0, G_OPTION_ARG_FILENAME, &config_file,
     "Configuration file", "<filename>"},
    {"vendor-version", '\0', 0, G_OPTION_ARG_STRING, &vendor_version_string,
     "Use <string> as vendor version.", "<string>"},
    {"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},
    {"only-cache", 'C', 0, G_OPTION_ARG_NONE, &only_cache,
     "Exit once the NVT cache has been initialized or updated", NULL},
    {"unix-socket", 'c', 0, G_OPTION_ARG_FILENAME, &unix_socket_path,
     "Path of unix socket to listen on", "<filename>"},
    {"listen-owner", '\0', 0, G_OPTION_ARG_STRING, &listen_owner,
     "Owner of the unix socket", "<string>"},
    {"listen-group", '\0', 0, G_OPTION_ARG_STRING, &listen_group,
     "Group of the unix socket", "<string>"},
    {"listen-mode", '\0', 0, G_OPTION_ARG_STRING, &listen_mode,
     "File mode of the unix socket", "<string>"},
    {"gnupg-home", 'c', 0, G_OPTION_ARG_STRING, &gnupg_dir,
     "Gnupg home directory", "<directory>"},
    {NULL, 0, 0, 0, NULL, NULL, NULL}
  };

  option_context =
    g_option_context_new ("- Scanner of the Open Vulnerability Assessment System");
  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);
      exit (0);
    }
  g_option_context_free (option_context);

  if (print_sysconfdir)
    {
      g_print ("%s\n", SYSCONFDIR);
      exit (0);
    }

  /* 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));
      exit (0);
    }
  tzset ();

  if (!unix_socket_path)
    unix_socket_path = g_build_filename (OPENVAS_RUN_DIR, "openvassd.sock", NULL);

  if (display_version)
    {
      printf ("OpenVAS Scanner %s\n", OPENVASSD_VERSION);
#ifdef OPENVASSD_SVN_REVISION
      printf ("SVN revision %i\n", OPENVASSD_SVN_REVISION);
#endif
      printf
        ("Most new code since 2005: (C) 2016 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");
      exit (0);
    }

  if (gnupg_dir)
    set_gpghome (gnupg_dir);

  if (vendor_version_string)
    vendor_version_set (vendor_version_string);

  if (!config_file)
    config_file = OPENVASSD_CONF;
  if (only_cache)
    {
      if (init_openvassd (dont_fork, config_file))
        return 1;
      if (plugins_init ())
        return 1;
      return 0;
    }

  if (init_openvassd (dont_fork, config_file))
    return 1;
  if (!print_specs)
    {
      if (init_unix_network (&global_iana_socket, listen_owner, listen_group,
                             listen_mode))
        return 1;
    }

  /* special treatment */
  if (print_specs)
    {
      prefs_dump ();
      exit (0);
    }
  flush_all_kbs ();

#if GNUTLS_VERSION_NUMBER < 0x030300
  if (openvas_SSL_init () < 0)
    log_write ("Could not initialize openvas SSL!");
#endif

  // Daemon mode:
  if (dont_fork == FALSE)
    set_daemon_mode ();
  pidfile_create ("openvassd");

  /* Ignore SIGHUP while reloading. */
  openvas_signal (SIGHUP, SIG_IGN);
  handler_pid = loading_handler_start ();
  if (handler_pid < 0)
    return 1;
  ret = plugins_init ();
  loading_handler_stop (handler_pid);
  if (ret)
    return 1;
  init_signal_handlers ();
  main_loop ();
  exit (0);
}

Variable Documentation

global_max_checks

int global_max_checks = 10

Definition at line 87 of file openvassd.c.

Referenced by get_max_checks_number().

global_max_hosts

int global_max_hosts = 15

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

Definition at line 86 of file openvassd.c.

Referenced by get_max_hosts_number().

unix_socket_path

gchar* unix_socket_path = NULL

Definition at line 139 of file openvassd.c.