#include "pluginload.h"
#include "pluginscheduler.h"

Include dependency graph for pluginlaunch.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	ERR_CANT_FORK -2
	Error for when it is not possible to fork a new plugin process.

#define	ERR_NO_FREE_SLOT -99
	Error for when the process table is full.

Functions
void	pluginlaunch_init (const char *)

void	pluginlaunch_wait (kb_t, kb_t)
	Waits and 'pushes' processes until num_running_processes is 0.

void	pluginlaunch_wait_for_free_process (kb_t, kb_t)
	Waits and 'pushes' processes until the number of running processes has changed.

void	pluginlaunch_stop (void)

int	plugin_launch (struct scan_globals , struct scheduler_plugin , struct in6_addr , GSList , kb_t, kb_t, nvti_t , int )
	Start a plugin.

void	pluginlaunch_disable_parallel_checks (void)

void	pluginlaunch_enable_parallel_checks (void)

int	wait_for_children (void)

Detailed Description

pluginlaunch.c header.

Definition in file pluginlaunch.h.

Macro Definition Documentation

◆ ERR_CANT_FORK

#define ERR_CANT_FORK -2

Error for when it is not possible to fork a new plugin process.

Definition at line 22 of file pluginlaunch.h.

◆ ERR_NO_FREE_SLOT

#define ERR_NO_FREE_SLOT -99

Error for when the process table is full.

Definition at line 26 of file pluginlaunch.h.

Function Documentation

◆ plugin_launch()

int plugin_launch	(	struct scan_globals *	globals,
		struct scheduler_plugin *	plugin,
		struct in6_addr *	ip,
		GSList *	vhosts,
		kb_t	kb,
		kb_t	main_kb,
		nvti_t *	nvti,
		int *	error
	)

Start a plugin.

Check for free slots available in the process table. Set error with ERR_NO_FREE_SLOT if the process table is full. Set error with ERR_CANT_FORK if was not possible to fork() a new child.

Returns: PID of process that is connected to the plugin as returned by plugin classes pl_launch function. Less than 0 means there was a problem, but error param should be checked.

Definition at line 458 of file pluginlaunch.c.

{
  int p;
 
  /* Wait for a free slot */
  pluginlaunch_wait_for_free_process (main_kb, kb);
  p = next_free_process (main_kb, kb, plugin);
  if (p < 0)
    {
      g_warning ("%s. There is currently no free slot available for starting a "
                 "new plugin.",
                 __func__);
      *error = ERR_NO_FREE_SLOT;
      return -1;
    }
 
  processes[p].plugin = plugin;
  processes[p].timeout = plugin_timeout (nvti);
  gettimeofday (&(processes[p].start), NULL);
  processes[p].pid = nasl_plugin_launch (globals, ip, vhosts, kb, plugin->oid);
 
  if (processes[p].pid > 0)
    num_running_processes++;
  else
    {
      processes[p].plugin->running_state = PLUGIN_STATUS_UNRUN;
      *error = ERR_CANT_FORK;
    }
  return processes[p].pid;
}

References ERR_CANT_FORK, ERR_NO_FREE_SLOT, main_kb, nasl_plugin_launch(), next_free_process(), num_running_processes, scheduler_plugin::oid, pid, running::pid, running::plugin, PLUGIN_STATUS_UNRUN, plugin_timeout(), pluginlaunch_wait_for_free_process(), processes, scheduler_plugin::running_state, and running::timeout.

Referenced by launch_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pluginlaunch_disable_parallel_checks()

void pluginlaunch_disable_parallel_checks ( void )

Definition at line 340 of file pluginlaunch.c.

{
  max_running_processes = 1;
}

References max_running_processes.

Referenced by get_next_in_range().

Here is the caller graph for this function:

◆ pluginlaunch_enable_parallel_checks()

void pluginlaunch_enable_parallel_checks ( void )

Definition at line 346 of file pluginlaunch.c.

{
  max_running_processes = old_max_running_processes;
}

References max_running_processes, and old_max_running_processes.

Referenced by get_next_in_range().

Here is the caller graph for this function:

◆ pluginlaunch_init()

void pluginlaunch_init ( const char * host )

Definition at line 315 of file pluginlaunch.c.

{
  int i;
 
  char **split = g_strsplit (prefs_get ("non_simult_ports"), ", ", 0);
  for (i = 0; split[i]; i++)
    non_simult_ports = g_slist_prepend (non_simult_ports, g_strdup (split[i]));
  g_strfreev (split);
  max_running_processes = get_max_checks_number ();
  old_max_running_processes = max_running_processes;
  hostname = host;
 
  if (max_running_processes >= MAX_PROCESSES)
    {
      g_debug ("max_checks (%d) > MAX_PROCESSES (%d) - modify "
               "openvas/openvas/pluginlaunch.c",
               max_running_processes, MAX_PROCESSES);
      max_running_processes = MAX_PROCESSES - 1;
    }
 
  num_running_processes = 0;
  bzero (&(processes), sizeof (processes));
}

References get_max_checks_number(), hostname, MAX_PROCESSES, max_running_processes, non_simult_ports, num_running_processes, old_max_running_processes, and processes.

Referenced by attack_host().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pluginlaunch_stop()

void pluginlaunch_stop ( void )

Definition at line 352 of file pluginlaunch.c.

{
  int i;
 
  for (i = 0; i < MAX_PROCESSES; i++)
    {
      if (processes[i].pid > 0)
        {
          /* Since the plugin process is a group leader process
           * we can send the signal to -PID process to kill
           * also the plugin's child processes. */
          terminate_process (processes[i].pid * -1);
          num_running_processes--;
          processes[i].plugin->running_state = PLUGIN_STATUS_DONE;
          bzero (&(processes[i]), sizeof (struct running));
        }
    }
}

References MAX_PROCESSES, num_running_processes, pid, running::plugin, PLUGIN_STATUS_DONE, processes, scheduler_plugin::running_state, and terminate_process().

Referenced by attack_host(), launch_plugin(), pluginlaunch_wait_for_free_process(), and scan_stop_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pluginlaunch_wait()

void pluginlaunch_wait	(	kb_t	main_kb,
		kb_t	kb
	)

Waits and 'pushes' processes until num_running_processes is 0.

Definition at line 495 of file pluginlaunch.c.

{
  while (num_running_processes)
    {
      update_running_processes (main_kb, kb);
      if (num_running_processes)
        waitpid (-1, NULL, 0);
    }
}

References main_kb, num_running_processes, and update_running_processes().

Referenced by attack_host().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pluginlaunch_wait_for_free_process()

void pluginlaunch_wait_for_free_process	(	kb_t	main_kb,
		kb_t	kb
	)

Waits and 'pushes' processes until the number of running processes has changed.

Definition at line 528 of file pluginlaunch.c.

{
  if (!num_running_processes)
    return;
  update_running_processes (main_kb, kb);
  /* Max number of processes are still running, wait for a child to exit or
   * to timeout. */
 
  if (num_running_processes >= max_running_processes)
    g_debug ("%s. Number of running processes >= maximum running processes (%d "
             ">= %d). "
             "Waiting for free slot for processes.",
             __func__, num_running_processes, max_running_processes);
 
  /* Be careful with changing the max_running_process value.
   * The plugin scheduler can change this value for running one plugin at
   * time. */
  while (
    (num_running_processes >= max_running_processes)
    || (num_running_processes > 0 && (check_memory () || check_sysload ())))
    {
      sigset_t mask;
      struct timespec ts = {0, 0};
 
      ts.tv_sec = timeout_running_processes ();
      assert (ts.tv_sec);
      sigemptyset (&mask);
      sigaddset (&mask, SIGCHLD);
      sigaddset (&mask, SIGUSR1);
      /* Wait here for the shortest plugins timeout or for a child which ended.
       * Also, it handles signal SIGUSR1 to stop a scan. Otherwise the signa is
       * ignored, the plugin is never stopped and the scanner keeps waiting. */
      int sig = sigtimedwait (&mask, NULL, &ts);
      if (sig < 0 && errno != EAGAIN)
        g_warning ("%s: %s (%d)", __func__, strerror (errno), errno);
      else if (sig == SIGUSR1)
        {
          /* SIGUSR1 signal is sent during scan stop to all host processes.
             Therefore pluginlaunch_stop() is called here, for the
             special case in which we are waiting for the last plugin, of the
             last host, to finish.
          */
          pluginlaunch_stop ();
        }
      // cleanup ipcc cache
      procs_cleanup_children ();
      update_running_processes (main_kb, kb);
    }
}