processes.c File Reference

Creates new threads. More...

#include "processes.h"
#include "../misc/kb_cache.h"
#include "debug_utils.h"
#include "sighand.h"
#include <errno.h>
#include <glib.h>
#include <gvm/base/logging.h>
#include <gvm/util/mqtt.h>
#include <setjmp.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

Include dependency graph for processes.c:

Go to the source code of this file.

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

Functions
int	procs_cleanup_children (void)
	iterates through ipcc and verify if a child is stopped or killed to free the file handler.
static void	clean_procs (void)
	Cleans the process list and frees memory. This will not terminate child processes. Is primarily used after fork.
int	terminate_process (pid_t pid)
	Terminates a given process. If termination does not work, the process will get killed. Terminate process can be called with the (-1 * pid) to send the signal to the process group.
void	procs_terminate_childs (void)
	This function terminates all processes spawned with create_process. Calls terminate_child for each process active. In case init_procs was not called this function does nothing.
static void	init_child_signal_handlers (void)
static void	pre_fn_call (struct ipc_context *ctx, void *args)
static void	post_fn_call (struct ipc_context *ctx, void *args)
static void	reuse_or_add_context (struct ipc_context *ctx)
pid_t	create_ipc_process (ipc_process_func func, void *args)
	initializes a communication channels and calls a function with a new process
const struct ipc_contexts *	procs_get_ipc_contexts (void)
	returns ipc_contexts.

Variables
static struct ipc_contexts *	ipcc = NULL

Detailed Description

Creates new threads.

Definition in file processes.c.

Macro Definition Documentation

G_LOG_DOMAIN

#define G_LOG_DOMAIN   "sd main"

GLib log domain.

Definition at line 35 of file processes.c.

Function Documentation

clean_procs()

void clean_procs ( void )

static

Cleans the process list and frees memory. This will not terminate child processes. Is primarily used after fork.

Definition at line 79 of file processes.c.

{
  ipc_destroy_contexts (ipcc);
  ipcc = NULL;
}

References ipc_destroy_contexts(), and ipcc.

Referenced by pre_fn_call().

Here is the call graph for this function:

Here is the caller graph for this function:

create_ipc_process()

pid_t create_ipc_process	(	ipc_process_func	func,
		void *	args )

initializes a communication channels and calls a function with a new process

Parameters

func	Function to call
args	arguments

Returns

pid of spawned process on success or one of the following errors: FORKFAILED

Definition at line 195 of file processes.c.

{
  struct ipc_context *pctx = NULL;
  struct ipc_exec_context ec = {0};
  pid_t child_pid;
  // previously init call, we want to store the contexts without making
  // assumptions about signal handlung
  if (ipcc == NULL)
    ipcc = ipc_contexts_init (10);
 
  ec.pre_func = (ipc_process_func) &pre_fn_call;
  ec.post_func = (ipc_process_func) &post_fn_call;
  ec.func = (ipc_process_func) func;
  ec.func_arg = args;
  // check for exited processes and clean file descriptor
  // we do it twice, before forking and when forking fails with EMFILE or EAGAIN
retry:
  g_debug ("%s: closed %d fd.", __func__, procs_cleanup_children ());
  if ((pctx = ipc_exec_as_process (IPC_PIPE, ec)) == NULL)
    {
      if (errno == EMFILE || errno == EAGAIN)
        {
          g_debug (
            "%s: could not fork: %s (%d) retrying after trying to close fd.",
            __func__, strerror (errno), errno);
          goto retry;
        }
      g_warning ("%s: could not fork: %s (%d)", __func__, strerror (errno),
                 errno);
      return FORKFAILED;
    }
  reuse_or_add_context (pctx);
  child_pid = pctx->pid;
  // ipcc works uses copies of pctx therefore we free it
  free (pctx);
  return child_pid;
}

References FORKFAILED, free(), ipc_exec_context::func, ipc_exec_context::func_arg, ipc_contexts_init(), ipc_exec_as_process(), IPC_PIPE, ipcc, ipc_context::pid, post_fn_call(), ipc_exec_context::post_func, pre_fn_call(), ipc_exec_context::pre_func, procs_cleanup_children(), and reuse_or_add_context().

Referenced by attack_network().

Here is the call graph for this function:

Here is the caller graph for this function:

init_child_signal_handlers()

void init_child_signal_handlers ( void )

static

Definition at line 126 of file processes.c.

{
  /* SIGHUP is only for reloading main scanner process. */
  openvas_signal (SIGHUP, SIG_IGN);
  openvas_signal (SIGTERM, make_em_die);
  openvas_signal (SIGINT, make_em_die);
  openvas_signal (SIGQUIT, make_em_die);
  openvas_signal (SIGSEGV, sighand_segv);
  openvas_signal (SIGPIPE, SIG_IGN);
}

References make_em_die(), openvas_signal, and sighand_segv().

Referenced by pre_fn_call().

Here is the call graph for this function:

Here is the caller graph for this function:

post_fn_call()

void post_fn_call ( struct ipc_context * ctx, void * args )

static

Definition at line 157 of file processes.c.

{
  (void) ctx;
  (void) args;
  g_debug ("%s: called", __func__);
  gvm_close_sentry ();
}

Referenced by create_ipc_process().

Here is the caller graph for this function:

pre_fn_call()

void pre_fn_call ( struct ipc_context * ctx, void * args )

static

Definition at line 138 of file processes.c.

{
  (void) ctx;
  (void) args;
  // in a chuld we clean up every preexisting context
  ipc_destroy_contexts (ipcc);
  ipcc = ipc_contexts_init (0);
  g_debug ("%s: called", __func__);
  usleep (1000);
  init_child_signal_handlers ();
  clean_procs ();
  mqtt_reset ();
  init_sentry ();
  srand48 (getpid () + getppid () + (long) time (NULL));
 
  g_debug ("%s: exit", __func__);
}

References clean_procs(), init_child_signal_handlers(), init_sentry(), ipc_contexts_init(), ipc_destroy_contexts(), and ipcc.

Referenced by create_ipc_process().

Here is the call graph for this function:

Here is the caller graph for this function:

procs_cleanup_children()

int procs_cleanup_children

(

void

)

iterates through ipcc and verify if a child is stopped or killed to free the file handler.

Returns

the amount of freed file handler or -1 on ipcc not initialized

Definition at line 47 of file processes.c.

{
  int freed = 0, i, status;
  pid_t pid;
  if (ipcc == NULL)
    return -1;
  g_debug ("%s: checking %d ipc.", __func__, ipcc->len);
  for (i = 0; i < ipcc->len; i++)
    {
      if (ipcc->ctxs[i].closed)
        {
          continue;
        }
      pid = waitpid (ipcc->ctxs[i].pid, &status, WNOHANG);
      if ((pid < 0)
          || ((pid == ipcc->ctxs[i].pid)
              && (WIFEXITED (status) || WIFSTOPPED (status)
                  || WIFSIGNALED (status))))
        {
          freed++;
          ipc_close (&ipcc->ctxs[i]);
        }
    }
  return freed;
}

References ipc_close(), ipcc, and pid.

Referenced by create_ipc_process(), and pluginlaunch_wait_for_free_process().

Here is the call graph for this function:

Here is the caller graph for this function:

procs_get_ipc_contexts()

const struct ipc_contexts * procs_get_ipc_contexts

(

void

)

returns ipc_contexts.

Returns

the globally hold array of all ipc_context; do not manipulate them.

Definition at line 239 of file processes.c.

{
  return ipcc;
}

References ipcc.

Referenced by launch_plugin().

Here is the caller graph for this function:

procs_terminate_childs()

void procs_terminate_childs

(

void

)

This function terminates all processes spawned with create_process. Calls terminate_child for each process active. In case init_procs was not called this function does nothing.

Definition at line 113 of file processes.c.

{
  if (ipcc == NULL)
    return;
 
  for (int i = 0; i < ipcc->len; i++)
    {
      if (!ipcc->ctxs[i].closed)
        terminate_process (ipcc->ctxs[i].pid);
    }
}

References ipcc, and terminate_process().

Referenced by handle_termination_signal().

Here is the call graph for this function:

Here is the caller graph for this function:

reuse_or_add_context()

void reuse_or_add_context ( struct ipc_context * ctx )

static

Definition at line 166 of file processes.c.

{
  if (ipcc == NULL)
    return;
  for (int i = 0; i < ipcc->len; i++)
    {
      if (ipcc->ctxs[i].closed == 1)
        {
          ipcc->ctxs[i].context = ctx->context;
          ipcc->ctxs[i].pid = ctx->pid;
          ipcc->ctxs[i].relation = ctx->relation;
          ipcc->ctxs[i].type = ctx->type;
          ipcc->ctxs[i].closed = 0;
          return;
        }
    }
  ipc_add_context (ipcc, ctx);
}

References ipc_context::context, ipc_add_context(), ipcc, ipc_context::pid, ipc_context::relation, and ipc_context::type.

Referenced by create_ipc_process().

Here is the call graph for this function:

Here is the caller graph for this function:

terminate_process()

int terminate_process

(

pid_t

pid

)

Terminates a given process. If termination does not work, the process will get killed. Terminate process can be called with the (-1 * pid) to send the signal to the process group.

Parameters

pid	id of the child process

Returns

int 0 on success, NOCHILD if child does not exist, NOINIT if not initialized

Definition at line 96 of file processes.c.

{
  kill (pid, SIGTERM);
  usleep (10000);
  if (waitpid (pid, NULL, WNOHANG))
    kill (pid, SIGKILL);
 
  return 0;
}

References pid.

Referenced by pluginlaunch_stop(), procs_terminate_childs(), and update_running_processes().

Here is the caller graph for this function:

Variable Documentation

ipcc

struct ipc_contexts* ipcc = NULL

static

Definition at line 39 of file processes.c.

Referenced by attack_start(), clean_procs(), create_ipc_process(), nasl_thread(), pre_fn_call(), procs_cleanup_children(), procs_get_ipc_contexts(), procs_terminate_childs(), and reuse_or_add_context().