#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <strings.h>
#include <errno.h>
#include <sys/time.h>
#include <openvas/misc/network.h>
#include <openvas/misc/nvt_categories.h>
#include <openvas/misc/internal_com.h>
#include <openvas/misc/prefs.h>
#include <openvas/base/nvticache.h>
#include "pluginload.h"
#include "utils.h"
#include "log.h"
#include "sighand.h"
#include "processes.h"
#include "pluginscheduler.h"
#include "plugs_req.h"

Include dependency graph for pluginlaunch.c:

Data Structures
struct	running
	Structure to represent a process in the sense of a running NVT. More...

Macros
#define	MAX_PROCESSES 32
	'Hard' limit of the max. number of concurrent plugins per host. More...

Functions
void	wait_for_children ()

void	pluginlaunch_init (const char *host)

void	pluginlaunch_disable_parrallel_checks (void)

void	pluginlaunch_enable_parrallel_checks (void)

void	pluginlaunch_stop (int soft_stop)

int	plugin_launch (struct arglist globals, struct scheduler_plugin plugin, struct host_info hostinfo, kb_t kb, char name)

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

void	pluginlaunch_child_cleanup (void)
	Cleanup file descriptors used by the processes array. To be called by the child process running the plugin. More...

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

Variables
const char *	hostname = NULL

Macro Definition Documentation

◆ MAX_PROCESSES

#define MAX_PROCESSES 32

'Hard' limit of the max. number of concurrent plugins per host.

Definition at line 52 of file pluginlaunch.c.

Referenced by pluginlaunch_child_cleanup(), and wait_for_children().

Function Documentation

◆ plugin_launch()

int plugin_launch	(	struct arglist *	globals,
		struct scheduler_plugin *	plugin,
		struct host_info *	hostinfo,
		kb_t	kb,
		char *	name
	)

Returns: PID of process that is connected to the plugin as returned by plugin classes pl_launch function (<=0 means there was a problem).

Definition at line 414 of file pluginlaunch.c.

 {
   int p;
   int dsoc[2];
 
   /* Wait for a free slot while reading the input from the plugins  */
   while (num_running_processes >= max_running_processes)
     {
       read_running_processes ();
       update_running_processes ();
     }
 
   p = next_free_process (plugin);
   processes[p].plugin = plugin;
   processes[p].timeout = prefs_nvt_timeout (plugin->oid);
   if (processes[p].timeout == 0)
     processes[p].timeout = nvticache_get_timeout (plugin->oid);
 
   if (processes[p].timeout == 0)
     {
       int category = nvticache_get_category (plugin->oid);
       if (category == ACT_SCANNER)
         processes[p].timeout = atoi (prefs_get ("scanner_plugins_timeout")
                                      ?: "-1");
       else
         processes[p].timeout = atoi (prefs_get ("plugins_timeout") ?: "-1");
     }
 
   if (socketpair (AF_UNIX, SOCK_STREAM, 0, dsoc) < 0)
     {
       perror ("pluginlaunch.c:plugin_launch:socketpair(1) ");
     }
   gettimeofday (&(processes[p].start), NULL);
 
   processes[p].upstream_soc = arg_get_value_int (globals, "global_socket");
   processes[p].internal_soc = dsoc[0];
 
   processes[p].pid =
     nasl_plugin_launch (globals, hostinfo, kb, name, plugin->oid, dsoc[1]);
 
   processes[p].alive = 1;
   close (dsoc[1]);
   if (processes[p].pid > 0)
     num_running_processes++;
   else
     processes[p].plugin->running_state = PLUGIN_STATUS_UNRUN;
 
   return processes[p].pid;
 }

◆ pluginlaunch_child_cleanup()

void pluginlaunch_child_cleanup ( void )

Cleanup file descriptors used by the processes array. To be called by the child process running the plugin.

Definition at line 486 of file pluginlaunch.c.

References MAX_PROCESSES.

 {
   int i;
   for (i = 0; i < MAX_PROCESSES; i++)
     if (processes[i].internal_soc)
       close (processes[i].internal_soc);
 }

◆ pluginlaunch_disable_parrallel_checks()

void pluginlaunch_disable_parrallel_checks ( void )

Definition at line 366 of file pluginlaunch.c.

 {
   max_running_processes = 1;
 }

◆ pluginlaunch_enable_parrallel_checks()

void pluginlaunch_enable_parrallel_checks ( void )

Definition at line 372 of file pluginlaunch.c.

 {
   max_running_processes = old_max_running_processes;
 }

◆ pluginlaunch_init()

void pluginlaunch_init ( const char * host )

Definition at line 344 of file pluginlaunch.c.

 {
   struct arglist *preferences = preferences_get ();
   non_simult_ports_list = arg_get_value (preferences, "non_simult_ports_list");
   max_running_processes = get_max_checks_number ();
   old_max_running_processes = max_running_processes;
   hostname = host;
 
   if (max_running_processes >= MAX_PROCESSES)
     {
       log_write
         ("max_checks (%d) > MAX_PROCESSES (%d) - modify openvas-scanner/openvassd/pluginlaunch.c",
          max_running_processes, MAX_PROCESSES);
       max_running_processes = MAX_PROCESSES - 1;
     }
 
 
   num_running_processes = 0;
   bzero (&(processes), sizeof (processes));
 }

◆ pluginlaunch_stop()

void pluginlaunch_stop ( int soft_stop )

Definition at line 379 of file pluginlaunch.c.

 {
   int i;
 
   if (soft_stop)
     {
       read_running_processes ();
 
       for (i = 0; i < MAX_PROCESSES; i++)
         {
           if (processes[i].pid > 0)
             kill (processes[i].pid, SIGTERM);
         }
       usleep (20000);
     }
 
   for (i = 0; i < MAX_PROCESSES; i++)
     {
       if (processes[i].pid > 0)
         {
           kill (processes[i].pid, SIGKILL);
           num_running_processes--;
           processes[i].plugin->running_state = PLUGIN_STATUS_DONE;
           close (processes[i].internal_soc);
           bzero (&(processes[i]), sizeof (struct running));
         }
     }
 }

◆ pluginlaunch_wait()

void pluginlaunch_wait ( void )

Waits and 'pushes' processes until num_running_processes is 0.

Definition at line 470 of file pluginlaunch.c.

References wait_for_children().

 {
   do
     {
       wait_for_children ();
       read_running_processes ();
       update_running_processes ();
     }
   while (num_running_processes != 0);
 }

Here is the call graph for this function:

◆ pluginlaunch_wait_for_free_process()

void pluginlaunch_wait_for_free_process ( void )

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

Definition at line 499 of file pluginlaunch.c.

Referenced by plugin_next_unrun_dependency().

 {
   int num = num_running_processes;
   while (num && num_running_processes == num)
     {
       wait_for_children ();
       read_running_processes ();
       update_running_processes ();
     }
 }

Here is the caller graph for this function:

◆ wait_for_children()

void wait_for_children ( void )

Definition at line 126 of file pluginlaunch.c.

References MAX_PROCESSES.

Referenced by pluginlaunch_wait().

 {
   int i;
 
   for (i = 0; i < MAX_PROCESSES; i++)
     if (processes[i].pid != 0)
       {
         int ret;
         do
           {
             ret = waitpid (-1, NULL, WNOHANG);
           }
         while (ret < 0 && errno == EINTR);
       }
 }

Here is the caller graph for this function:

Variable Documentation

◆ hostname

const char* hostname = NULL

Definition at line 81 of file pluginlaunch.c.

Data Structures

Macros

Functions

Variables