pluginload.c File Reference

Loads plugins from disk into memory. More...

#include "pluginload.h"
#include "../nasl/nasl.h"
#include "processes.h"
#include "sighand.h"
#include "utils.h"
#include <bsd/unistd.h>
#include <errno.h>
#include <glib.h>
#include <gvm/base/prefs.h>
#include <gvm/util/nvticache.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/shm.h>
#include <sys/time.h>
#include <sys/wait.h>

Include dependency graph for pluginload.c:

Go to the source code of this file.

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

Functions
static GSList *	collect_nvts (const char *folder, const char *subdir, GSList *files)
	Collects all NVT files in a directory and recurses into subdirs. More...
static int	calculate_eta (struct timeval start_time, int loaded, int total)
void	init_loading_shm (void)
void	destroy_loading_shm (void)
int	current_loading_plugins (void)
int	total_loading_plugins (void)
static void	set_current_loading_plugins (int current)
static void	set_total_loading_plugins (int total)
static void	cleanup_leftovers (int num_files)
static int	plugins_reload_from_dir (const char *folder)
static void	include_dirs (void)
int	plugins_cache_init (void)
	Main function for nvticache initialization without loading the plugins. More...
int	plugins_init (void)
	main function for loading all the plugins More...

Variables
static int *	loading_shm = NULL
static int	loading_shmid = 0

Detailed Description

Loads plugins from disk into memory.

Definition in file pluginload.c.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "sd main"

GLib log domain.

Definition at line 36 of file pluginload.c.

Function Documentation

calculate_eta()

static int calculate_eta ( struct timeval  start_time, int  loaded, int  total  )

static

Definition at line 98 of file pluginload.c.

{
  struct timeval current_time;
  int elapsed, remaining;
 
  if (start_time.tv_sec == 0)
    return 0;
 
  gettimeofday (&current_time, NULL);
  elapsed = current_time.tv_sec - start_time.tv_sec;
  remaining = total - loaded;
  return (remaining * elapsed) / loaded;
}

References timeval().

Referenced by plugins_reload_from_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_leftovers()

static void cleanup_leftovers ( int  num_files )

static

Definition at line 217 of file pluginload.c.

{
  size_t count;
  GSList *oids, *element;
 
  setproctitle ("openvas: Cleaning leftover NVTs.");
 
  count = nvticache_count ();
  if ((int) count <= num_files)
    return;
 
  oids = element = nvticache_get_oids ();
  while (element)
    {
      char *path = nvticache_get_src (element->data);
 
      if (!g_file_test (path, G_FILE_TEST_EXISTS))
        nvticache_delete (element->data);
      g_free (path);
      element = element->next;
    }
  g_slist_free_full (oids, g_free);
}

Referenced by plugins_reload_from_dir().

Here is the caller graph for this function:

collect_nvts()

static GSList* collect_nvts ( const char *  folder, const char *  subdir, GSList *  files  )

static

Collects all NVT files in a directory and recurses into subdirs.

Parameters

folder	The main directory from where to descend and collect.
subdir	A subdirectory to consider for the collection: "folder/subdir" is thus the effective directory to descend from. "subdir" can be "" to make "folder" the effective start.
files	A list that is extended with all found files. If it is NULL, a new list is created automatically.

Returns

Parameter "files", extended with all the NVT files found in "folder" and its subdirectories. Not added are directory names. NVT files are identified by the defined filename suffixes.

Definition at line 55 of file pluginload.c.

{
  GDir *dir;
  const gchar *fname;
 
  if (folder == NULL)
    return files;
 
  dir = g_dir_open (folder, 0, NULL);
  if (dir == NULL)
    return files;
 
  fname = g_dir_read_name (dir);
  while (fname)
    {
      char *path;
 
      path = g_build_filename (folder, fname, NULL);
      if (g_file_test (path, G_FILE_TEST_IS_DIR))
        {
          char *new_folder, *new_subdir;
 
          new_folder = g_build_filename (folder, fname, NULL);
          new_subdir = g_build_filename (subdir, fname, NULL);
 
          files = collect_nvts (new_folder, new_subdir, files);
 
          if (new_folder)
            g_free (new_folder);
          if (new_subdir)
            g_free (new_subdir);
        }
      else if (g_str_has_suffix (fname, ".nasl"))
        files = g_slist_prepend (files, g_build_filename (subdir, fname, NULL));
      g_free (path);
      fname = g_dir_read_name (dir);
    }
 
  g_dir_close (dir);
  return files;
}

Referenced by plugins_reload_from_dir().

Here is the caller graph for this function:

current_loading_plugins()

int current_loading_plugins

(

void

)

Definition at line 171 of file pluginload.c.

{
  return loading_shm ? loading_shm[0] : 0;
}

References loading_shm.

destroy_loading_shm()

void destroy_loading_shm

(

void

)

Definition at line 153 of file pluginload.c.

{
  if (loading_shm)
    {
      shmdt (loading_shm);
      if (shmctl (loading_shmid, IPC_RMID, NULL))
        perror ("shmctl");
      loading_shm = NULL;
      loading_shmid = 0;
    }
}

References loading_shm, and loading_shmid.

include_dirs()

static void include_dirs ( void  )

static

Definition at line 318 of file pluginload.c.

{
  const gchar *pref_include_folders;
 
  add_nasl_inc_dir (""); // for absolute and relative paths
  pref_include_folders = prefs_get ("include_folders");
  if (pref_include_folders != NULL)
    {
      gchar **include_folders = g_strsplit (pref_include_folders, ":", 0);
      unsigned int i = 0;
 
      for (i = 0; i < g_strv_length (include_folders); i++)
        {
          int result = add_nasl_inc_dir (include_folders[i]);
          if (result < 0)
            g_debug ("Could not add %s to the list of include folders.\n"
                     "Make sure %s exists and is a directory.\n",
                     include_folders[i], include_folders[i]);
        }
 
      g_strfreev (include_folders);
    }
}

References add_nasl_inc_dir().

Referenced by plugins_cache_init().

Here is the call graph for this function:

Here is the caller graph for this function:

init_loading_shm()

void init_loading_shm

(

void

)

Definition at line 120 of file pluginload.c.

{
  int shm_key;
 
  if (loading_shm)
    return;
 
  shm_key = rand () + 1;
  /*
   * Create shared memory segment if it doesn't exist.
   * This will be used to communicate current plugins loading progress to other
   * processes.
   * loading_shm[0]: Number of loaded plugins.
   * loading_shm[1]: Total number of plugins.
   */
  loading_shmid = shmget (shm_key, sizeof (int) * 2, IPC_CREAT | 0600);
  if (loading_shmid < 0)
    perror ("shmget");
  loading_shm = shmat (loading_shmid, NULL, 0);
  if (loading_shm == (void *) -1)
    {
      perror ("shmat");
      loading_shm = NULL;
    }
  else
    bzero (loading_shm, sizeof (int) * 2);
}

References loading_shm, and loading_shmid.

plugins_cache_init()

int plugins_cache_init

(

void

)

Main function for nvticache initialization without loading the plugins.

Returns

0 on success, -1 on failure.

Definition at line 348 of file pluginload.c.

{
  int ret;
  const char *plugins_folder = prefs_get ("plugins_folder");
 
  if (nvticache_init (plugins_folder, prefs_get ("db_address")))
    {
      g_debug ("Failed to initialize nvti cache.");
      return -1;
    }
  include_dirs ();
  ret = nasl_file_check (plugins_folder, "plugin_feed_info.inc");
  if (ret)
    return -1;
 
  return 0;
}

References include_dirs(), and nasl_file_check().

Referenced by attack_network_init(), openvas(), and plugins_init().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_init()

int plugins_init

(

void

)

main function for loading all the plugins

Returns

0 on success, !=0 on failure.

Definition at line 372 of file pluginload.c.

{
  int ret = 0;
  const char *plugins_folder = prefs_get ("plugins_folder");
 
  ret = plugins_cache_init ();
  if (ret)
    return ret;
 
  ret = plugins_reload_from_dir (plugins_folder);
  nvticache_save ();
  return ret;
}

References plugins_cache_init(), and plugins_reload_from_dir().

Referenced by openvas().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_reload_from_dir()

static int plugins_reload_from_dir ( const char *  folder )

static

Definition at line 242 of file pluginload.c.

{
  GSList *files = NULL, *f;
  int loaded_files = 0, num_files = 0;
  struct timeval start_time;
 
  openvas_signal (SIGTERM, SIG_DFL);
  if (folder == NULL)
    {
      g_debug ("%s:%d : folder == NULL", __FILE__, __LINE__);
      g_debug ("Could not determine the value of <plugins_folder>. "
               " Check %s\n",
               (char *) prefs_get ("config_file"));
      return 1;
    }
 
  files = collect_nvts (folder, "", files);
  num_files = g_slist_length (files);
 
  /*
   * Add the plugins
   */
 
  if (gettimeofday (&start_time, NULL))
    {
      bzero (&start_time, sizeof (start_time));
      g_debug ("gettimeofday: %s", strerror (errno));
    }
  f = files;
  set_total_loading_plugins (num_files);
  while (f != NULL)
    {
      static int err_count = 0;
      char *name = f->data;
 
      loaded_files++;
      if (loaded_files % 50 == 0)
        {
          int percentile, eta;
 
          set_current_loading_plugins (loaded_files);
          percentile = (loaded_files * 100) / num_files;
          eta = calculate_eta (start_time, loaded_files, num_files);
          setproctitle ("openvas: Reloaded %d of %d NVTs"
                        " (%d%% / ETA: %02d:%02d)",
                        loaded_files, num_files, percentile, eta / 60,
                        eta % 60);
        }
      if (prefs_get_bool ("log_plugins_name_at_load"))
        g_message ("Loading %s", name);
      if (g_str_has_suffix (name, ".nasl"))
        {
          if (nasl_plugin_add (folder, name))
            err_count++;
        }
 
      if (err_count == 20)
        {
          g_debug ("Stopped loading plugins: High number of errors.");
          setproctitle ("openvas: Error loading NVTs.");
          g_slist_free_full (files, g_free);
          return 1;
        }
      f = g_slist_next (f);
    }
 
  cleanup_leftovers (num_files);
  g_slist_free_full (files, g_free);
  nasl_clean_inc ();
 
  setproctitle ("openvas: Reloaded all the NVTs.");
 
  return 0;
}

References calculate_eta(), cleanup_leftovers(), collect_nvts(), name, nasl_clean_inc(), nasl_plugin_add(), openvas_signal, set_current_loading_plugins(), set_total_loading_plugins(), and timeval().

Referenced by plugins_init().

Here is the call graph for this function:

Here is the caller graph for this function:

set_current_loading_plugins()

static void set_current_loading_plugins ( int  current )

static

Definition at line 193 of file pluginload.c.

{
  if (loading_shm)
    loading_shm[0] = current;
}

References loading_shm.

Referenced by plugins_reload_from_dir().

Here is the caller graph for this function:

set_total_loading_plugins()

static void set_total_loading_plugins ( int  total )

static

Definition at line 205 of file pluginload.c.

{
  if (loading_shm)
    loading_shm[1] = total;
}

References loading_shm.

Referenced by plugins_reload_from_dir().

Here is the caller graph for this function:

total_loading_plugins()

int total_loading_plugins

(

void

)

Definition at line 182 of file pluginload.c.

{
  return loading_shm ? loading_shm[1] : 0;
}

References loading_shm.

Variable Documentation

loading_shm

int* loading_shm = NULL

static

Definition at line 112 of file pluginload.c.

Referenced by current_loading_plugins(), destroy_loading_shm(), init_loading_shm(), set_current_loading_plugins(), set_total_loading_plugins(), and total_loading_plugins().

loading_shmid

int loading_shmid = 0

static

Definition at line 113 of file pluginload.c.

Referenced by destroy_loading_shm(), and init_loading_shm().