pluginscheduler.c File Reference

Tells openvas which plugin should be executed next. More...

#include "pluginscheduler.h"
#include "../misc/nvt_categories.h"
#include "../misc/plugutils.h"
#include "pluginlaunch.h"
#include "pluginload.h"
#include <glib.h>
#include <gvm/base/prefs.h>
#include <gvm/util/nvticache.h>
#include <malloc.h>
#include <string.h>

Include dependency graph for pluginscheduler.c:

Go to the source code of this file.

Data Structures
struct	plugins_scheduler

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

Functions
static int	plugin_add (plugins_scheduler_t sched, GHashTable *oids_table, GHashTable *names_table, int autoload, char *oid)
static void	plugins_scheduler_fill_deps (plugins_scheduler_t sched, GHashTable *oids_table)
static int	plugins_scheduler_enable (plugins_scheduler_t sched, const char *oid_list, int autoload)
static int	find_plugin_in_deps (GHashTable *checked, struct scheduler_plugin **array, int pos)
static int	check_dependency_cycles (plugins_scheduler_t sched)
plugins_scheduler_t	plugins_scheduler_init (const char *plugins_list, int autoload, int *error)
int	plugins_scheduler_count_active (plugins_scheduler_t sched)
static struct scheduler_plugin *	plugins_next_unrun (GSList *plugins)
static struct scheduler_plugin *	get_next_in_range (plugins_scheduler_t h, int start, int end)
static void	scheduler_phase_cleanup (plugins_scheduler_t sched, int start, int end)
struct scheduler_plugin *	plugins_scheduler_next (plugins_scheduler_t h)
void	plugins_scheduler_stop (plugins_scheduler_t sched)
static void	scheduler_plugin_free (void *data)
void	plugins_scheduler_free (plugins_scheduler_t sched)

Detailed Description

Tells openvas which plugin should be executed next.

Definition in file pluginscheduler.c.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "sd main"

GLib log domain.

Definition at line 30 of file pluginscheduler.c.

Function Documentation

check_dependency_cycles()

int check_dependency_cycles ( plugins_scheduler_t sched )

static

Definition at line 263 of file pluginscheduler.c.

{
  int i, j;
  GHashTable *checked;
 
  checked = g_hash_table_new_full (g_str_hash, g_direct_equal, NULL, NULL);
  for (i = ACT_INIT; i <= ACT_END; i++)
    {
      GSList *element = sched->list[i];
 
      while (element)
        {
          struct scheduler_plugin *array[1024];
          int pos;
 
          array[0] = element->data;
          pos = find_plugin_in_deps (checked, array, 0);
          if (pos >= 0)
            {
              g_warning ("Dependency cycle:");
              for (j = 0; j <= pos; j++)
                {
                  char *name = nvticache_get_filename (array[j]->oid);
 
                  g_message (" %s (%s)", name, array[j]->oid);
                  g_free (name);
                }
 
              g_hash_table_destroy (checked);
              return 1;
            }
          element = element->next;
        }
    }
  g_hash_table_destroy (checked);
  return 0;
}

References ACT_END, ACT_INIT, find_plugin_in_deps(), plugins_scheduler::list, name, and oid.

Referenced by plugins_scheduler_init().

Here is the call graph for this function:

Here is the caller graph for this function:

find_plugin_in_deps()

int find_plugin_in_deps ( GHashTable * checked, struct scheduler_plugin ** array, int pos )

static

Definition at line 236 of file pluginscheduler.c.

{
  GSList *element = array[pos]->deps;
  int i;
 
  for (i = 0; i < pos; i++)
    if (array[i] == array[pos])
      return pos;
 
  if (g_hash_table_lookup (checked, array[pos]))
    return -1;
  while (element)
    {
      int ret;
 
      array[pos + 1] = element->data;
      ret = find_plugin_in_deps (checked, array, pos + 1);
      if (ret != -1)
        return ret;
      element = element->next;
    }
  g_hash_table_insert (checked, array[pos], array[pos]);
  return -1;
}

References scheduler_plugin::deps, and find_plugin_in_deps().

Referenced by check_dependency_cycles(), and find_plugin_in_deps().

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_in_range()

struct scheduler_plugin * get_next_in_range ( plugins_scheduler_t h, int start, int end )

static

Definition at line 376 of file pluginscheduler.c.

{
  int category;
  GSList *element;
  int still_running = 0;
 
  for (category = start; category <= end; category++)
    {
      struct scheduler_plugin *plugin;
      element = h->list[category];
      if (category == ACT_SCANNER || category == ACT_KILL_HOST
          || category == ACT_FLOOD || category == ACT_DENIAL)
        pluginlaunch_disable_parallel_checks ();
 
      plugin = plugins_next_unrun (element);
      if (plugin == PLUG_RUNNING)
        still_running = 1;
      else if (plugin)
        return plugin;
      pluginlaunch_enable_parallel_checks ();
    }
  return still_running ? PLUG_RUNNING : NULL;
}

References ACT_DENIAL, ACT_FLOOD, ACT_KILL_HOST, ACT_SCANNER, plugins_scheduler::list, PLUG_RUNNING, pluginlaunch_disable_parallel_checks(), pluginlaunch_enable_parallel_checks(), and plugins_next_unrun().

Referenced by plugins_scheduler_next().

Here is the call graph for this function:

Here is the caller graph for this function:

plugin_add()

int plugin_add ( plugins_scheduler_t sched, GHashTable * oids_table, GHashTable * names_table, int autoload, char * oid )

static

Definition at line 45 of file pluginscheduler.c.

{
  struct scheduler_plugin *plugin;
  int category;
  nvti_t *nvti;
  int ret = 0;
  gchar *tag_value;
 
  if (g_hash_table_lookup (oids_table, oid))
    return 0;
 
  /* Check if the plugin is deprecated */
  nvti = nvticache_get_nvt (oid);
  if (nvti == NULL)
    {
      g_warning ("The NVT with oid %s was not found in the nvticache.", oid);
      return 1;
    }
 
  tag_value = nvti_get_tag (nvti, "deprecated");
  if (tag_value && !strcmp (tag_value, "1"))
    {
      if (prefs_get_bool ("log_whole_attack"))
        {
          char *name = nvticache_get_filename (oid);
          g_message ("Plugin %s is deprecated. "
                     "It will neither be loaded nor launched.",
                     name);
          g_free (name);
        }
      nvti_free (nvti);
      g_free (tag_value);
      return 0;
    }
 
  category = nvti_category (nvti);
  if (!(category >= ACT_INIT && category <= ACT_END))
    {
      g_warning ("The NVT with oid %s has no category assigned. This is "
                 "considered a fatal error, since the NVTI Cache "
                 "structure stored in Redis is out dated or corrupted.",
                 oid);
      nvti_free (nvti);
      return 1;
    }
  plugin = g_malloc0 (sizeof (struct scheduler_plugin));
  plugin->running_state = PLUGIN_STATUS_UNRUN;
  plugin->oid = g_strdup (oid);
  g_hash_table_insert (oids_table, plugin->oid, plugin);
 
  sched->list[category] = g_slist_prepend (sched->list[category], plugin);
 
  /* Add the plugin's dependencies too. */
  if (autoload)
    {
      char *saveptr, *dep_name = NULL, *deps = nvti_dependencies (nvti);
 
      if (deps)
        dep_name = strtok_r (deps, ", ", &saveptr);
      while (dep_name)
        {
          struct scheduler_plugin *dep_plugin;
          char *dep_oid;
 
          dep_oid = g_hash_table_lookup (names_table, dep_name);
          if (!dep_oid)
            {
              dep_oid = nvticache_get_oid (dep_name);
              g_hash_table_insert (names_table, g_strdup (dep_name), dep_oid);
            }
          if (dep_oid)
            {
              ret =
                plugin_add (sched, oids_table, names_table, autoload, dep_oid);
              if (ret)
                return 1;
              dep_plugin = g_hash_table_lookup (oids_table, dep_oid);
              /* In case of autoload, no need to wait for plugin_add() to
               * fill all enabled plugins to start filling dependencies
               * lists. */
              if (dep_plugin)
                plugin->deps = g_slist_prepend (plugin->deps, dep_plugin);
              else
                g_warning ("There was a problem loading %s (%s), a "
                           "dependency of %s. This can happen e.g. when "
                           "depending on a deprecated NVT.",
                           dep_name, dep_oid, oid);
            }
          else
            {
              char *name = nvticache_get_name (oid);
              g_warning (
                "There was a problem trying to load %s, a dependency "
                "of %s. This may be due to a parse error, or it failed "
                "to find the dependency. Please check the path to the "
                "file.",
                dep_name, name);
              g_free (name);
            }
          dep_name = strtok_r (NULL, ", ", &saveptr);
        }
    }
  nvti_free (nvti);
  return 0;
}

References ACT_END, ACT_INIT, scheduler_plugin::deps, plugins_scheduler::list, name, oid, scheduler_plugin::oid, plugin_add(), PLUGIN_STATUS_UNRUN, and scheduler_plugin::running_state.

Referenced by plugin_add(), and plugins_scheduler_enable().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_next_unrun()

struct scheduler_plugin * plugins_next_unrun ( GSList * plugins )

static

Definition at line 334 of file pluginscheduler.c.

{
  int still_running = 0;
 
  while (plugins)
    {
      struct scheduler_plugin *plugin = plugins->data;
      switch (plugin->running_state)
        {
        case PLUGIN_STATUS_UNRUN:
          {
            struct scheduler_plugin *nplugin;
            GSList *deps_list = plugin->deps;
 
            nplugin = plugins_next_unrun (deps_list);
 
            if (nplugin == PLUG_RUNNING)
              still_running = 1;
            else if (nplugin)
              {
                nplugin->running_state = PLUGIN_STATUS_RUNNING;
                return nplugin;
              }
            else
              {
                plugin->running_state = PLUGIN_STATUS_RUNNING;
                return plugin;
              }
            break;
          }
        case PLUGIN_STATUS_RUNNING:
          still_running = 1;
          break;
        case PLUGIN_STATUS_DONE:
          break;
        }
      plugins = plugins->next;
    }
  return still_running ? PLUG_RUNNING : NULL;
}

References scheduler_plugin::deps, PLUG_RUNNING, PLUGIN_STATUS_DONE, PLUGIN_STATUS_RUNNING, PLUGIN_STATUS_UNRUN, plugins_next_unrun(), and scheduler_plugin::running_state.

Referenced by get_next_in_range(), and plugins_next_unrun().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_scheduler_count_active()

int plugins_scheduler_count_active

(

plugins_scheduler_t

sched

)

Definition at line 323 of file pluginscheduler.c.

{
  int ret = 0, i;
  assert (sched);
 
  for (i = ACT_INIT; i <= ACT_END; i++)
    ret += g_slist_length (sched->list[i]);
  return ret;
}

References ACT_END, ACT_INIT, and plugins_scheduler::list.

Referenced by attack_host().

Here is the caller graph for this function:

plugins_scheduler_enable()

int plugins_scheduler_enable ( plugins_scheduler_t sched, const char * oid_list, int autoload )

static

Definition at line 200 of file pluginscheduler.c.

{
  char *oids, *oid, *saveptr;
  GHashTable *oids_table, *names_table;
  int error_counter = 0;
 
  oids_table = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
  names_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
 
  /* Store list of plugins in hashtable. */
  oids = g_strdup (oid_list);
  oid = strtok_r (oids, ";", &saveptr);
  while (oid)
    {
      error_counter +=
        plugin_add (sched, oids_table, names_table, autoload, oid);
      oid = strtok_r (NULL, ";", &saveptr);
    }
 
  /* When autoload is disabled, each plugin's deps list is still empty. */
  if (!autoload)
    plugins_scheduler_fill_deps (sched, oids_table);
 
  if (error_counter > 0)
    g_warning ("%s: %d errors were found during the plugin scheduling.",
               __func__, error_counter);
 
  g_hash_table_destroy (oids_table);
  g_hash_table_destroy (names_table);
  g_free (oids);
 
  return error_counter;
}

References oid, plugin_add(), and plugins_scheduler_fill_deps().

Referenced by plugins_scheduler_init().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_scheduler_fill_deps()

void plugins_scheduler_fill_deps ( plugins_scheduler_t sched, GHashTable * oids_table )

static

Definition at line 153 of file pluginscheduler.c.

{
  int category;
 
  for (category = ACT_INIT; category <= ACT_END; category++)
    {
      GSList *element = sched->list[category];
 
      while (element)
        {
          char *deps;
          struct scheduler_plugin *plugin = element->data;
 
          assert (plugin->deps == NULL);
          deps = nvticache_get_dependencies (plugin->oid);
          if (deps)
            {
              int i;
              char **array = g_strsplit (deps, ", ", 0);
 
              for (i = 0; array[i]; i++)
                {
                  struct scheduler_plugin *dep_plugin;
                  char *dep_oid = nvticache_get_oid (array[i]);
                  dep_plugin = g_hash_table_lookup (oids_table, dep_oid);
                  if (dep_plugin)
                    plugin->deps = g_slist_prepend (plugin->deps, dep_plugin);
                  g_free (dep_oid);
                }
              g_strfreev (array);
              g_free (deps);
            }
          element = element->next;
        }
    }
}

References ACT_END, ACT_INIT, scheduler_plugin::deps, plugins_scheduler::list, and scheduler_plugin::oid.

Referenced by plugins_scheduler_enable().

Here is the caller graph for this function:

plugins_scheduler_free()

void plugins_scheduler_free

(

plugins_scheduler_t

sched

)

Definition at line 518 of file pluginscheduler.c.

{
  int i;
 
  for (i = ACT_INIT; i <= ACT_END; i++)
    g_slist_free_full (sched->list[i], scheduler_plugin_free);
  g_free (sched);
}

References ACT_END, ACT_INIT, plugins_scheduler::list, and scheduler_plugin_free().

Referenced by attack_host(), attack_network(), and plugins_scheduler_init().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_scheduler_init()

plugins_scheduler_t plugins_scheduler_init	(	const char *	plugins_list,
		int	autoload,
		int *	error )

Definition at line 302 of file pluginscheduler.c.

{
  plugins_scheduler_t ret;
 
  /* Fill our lists */
  ret = g_malloc0 (sizeof (*ret));
  *error = plugins_scheduler_enable (ret, plugins_list, autoload);
 
  if (check_dependency_cycles (ret))
    {
      plugins_scheduler_free (ret);
      return NULL;
    }
 
#ifdef __GLIBC__
  malloc_trim (0);
#endif
  return ret;
}

References check_dependency_cycles(), plugins_scheduler_enable(), and plugins_scheduler_free().

Referenced by attack_network().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_scheduler_next()

struct scheduler_plugin * plugins_scheduler_next

(

plugins_scheduler_t

h

)

Definition at line 426 of file pluginscheduler.c.

{
  struct scheduler_plugin *ret;
  static int scheduler_phase = 0;
 
  if (h == NULL)
    return NULL;
 
  if (scheduler_phase == 0)
    {
      ret = get_next_in_range (h, ACT_INIT, ACT_INIT);
      if (ret)
        return ret;
      scheduler_phase = 1;
      scheduler_phase_cleanup (h, ACT_INIT, ACT_INIT);
    }
  if (scheduler_phase <= 1)
    {
      ret = get_next_in_range (h, ACT_SCANNER, ACT_SCANNER);
      if (ret)
        return ret;
      scheduler_phase = 2;
      scheduler_phase_cleanup (h, ACT_SCANNER, ACT_SCANNER);
    }
  if (scheduler_phase <= 2)
    {
      ret = get_next_in_range (h, ACT_SETTINGS, ACT_GATHER_INFO);
      if (ret)
        return ret;
      scheduler_phase = 3;
      scheduler_phase_cleanup (h, ACT_SETTINGS, ACT_GATHER_INFO);
    }
  if (scheduler_phase <= 3)
    {
      ret = get_next_in_range (h, ACT_ATTACK, ACT_FLOOD);
      if (ret)
        return ret;
      scheduler_phase = 4;
      scheduler_phase_cleanup (h, ACT_ATTACK, ACT_FLOOD);
    }
  if (scheduler_phase <= 4)
    {
      ret = get_next_in_range (h, ACT_END, ACT_END);
      if (ret)
        return ret;
      scheduler_phase = 5;
      scheduler_phase_cleanup (h, ACT_END, ACT_END);
    }
  return NULL;
}

References ACT_ATTACK, ACT_END, ACT_FLOOD, ACT_GATHER_INFO, ACT_INIT, ACT_SCANNER, ACT_SETTINGS, get_next_in_range(), and scheduler_phase_cleanup().

Referenced by attack_host().

Here is the call graph for this function:

Here is the caller graph for this function:

plugins_scheduler_stop()

void plugins_scheduler_stop

(

plugins_scheduler_t

sched

)

Definition at line 483 of file pluginscheduler.c.

{
  int category;
 
  if (sched->stopped)
    return;
  for (category = ACT_INIT; category < ACT_END; category++)
    {
      GSList *element = sched->list[category];
 
      while (element)
        {
          struct scheduler_plugin *plugin = element->data;
 
          plugin->running_state = PLUGIN_STATUS_DONE;
          element = element->next;
        }
    }
  sched->stopped = 1;
}

References ACT_END, ACT_INIT, plugins_scheduler::list, PLUGIN_STATUS_DONE, scheduler_plugin::running_state, and plugins_scheduler::stopped.

Referenced by attack_host().

Here is the caller graph for this function:

scheduler_phase_cleanup()

void scheduler_phase_cleanup ( plugins_scheduler_t sched, int start, int end )

static

Definition at line 401 of file pluginscheduler.c.

{
  int category;
 
  assert (sched);
  for (category = start; category <= end; category++)
    {
      GSList *element = sched->list[category];
      while (element)
        {
          struct scheduler_plugin *plugin = element->data;
 
          g_free (plugin->oid);
          g_slist_free (plugin->deps);
          plugin->oid = NULL;
          plugin->deps = NULL;
          element = element->next;
        }
    }
#ifdef __GLIBC__
  malloc_trim (0);
#endif
}

References scheduler_plugin::deps, plugins_scheduler::list, and scheduler_plugin::oid.

Referenced by plugins_scheduler_next().

Here is the caller graph for this function:

scheduler_plugin_free()

void scheduler_plugin_free ( void * data )

static

Definition at line 505 of file pluginscheduler.c.

{
  struct scheduler_plugin *plugin;
  if (!data)
    return;
 
  plugin = data;
  g_free (plugin->oid);
  g_slist_free (plugin->deps);
  g_free (plugin);
}

References scheduler_plugin::deps, and scheduler_plugin::oid.

Referenced by plugins_scheduler_free().

Here is the caller graph for this function: