helper.c File Reference

API for dealing with (SUID) helper processes that communicate via GNUNET_MessageHeaders on stdin/stdout. More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for helper.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_HELPER_SendHandle
	Entry in the queue of messages we need to transmit to the helper. More...
struct	GNUNET_HELPER_Handle
	The handle to a helper process. More...

Functions
enum GNUNET_GenericReturnValue	GNUNET_HELPER_kill (struct GNUNET_HELPER_Handle *h, int soft_kill)
	Sends termination signal to the helper process.
enum GNUNET_GenericReturnValue	GNUNET_HELPER_wait (struct GNUNET_HELPER_Handle *h)
	Reap the helper process.
static void	stop_helper (struct GNUNET_HELPER_Handle *h, int soft_kill)
	Stop the helper process, we're closing down or had an error.
static void	restart_task (void *cls)
	Restart the helper process.
static void	helper_read (void *cls)
	Read from the helper-process.
static void	start_helper (struct GNUNET_HELPER_Handle *h)
	Start the helper process.
struct GNUNET_HELPER_Handle *	GNUNET_HELPER_start (const struct GNUNET_OS_ProjectData *pd, int with_control_pipe, const char *binary_name, char *const binary_argv[], GNUNET_MessageTokenizerCallback cb, GNUNET_HELPER_ExceptionCallback exp_cb, void *cb_cls)
	Starts a helper and begins reading from it.
void	GNUNET_HELPER_destroy (struct GNUNET_HELPER_Handle *h)
	Free's the resources occupied by the helper handle.
void	GNUNET_HELPER_stop (struct GNUNET_HELPER_Handle *h, int soft_kill)
	Kills the helper, closes the pipe and frees the handle.
static void	helper_write (void *cls)
	Write to the helper-process.
struct GNUNET_HELPER_SendHandle *	GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h, const struct GNUNET_MessageHeader *msg, bool can_drop, GNUNET_HELPER_Continuation cont, void *cont_cls)
	Send an message to the helper.
void	GNUNET_HELPER_send_cancel (struct GNUNET_HELPER_SendHandle *sh)
	Cancel a GNUNET_HELPER_send operation.

Detailed Description

API for dealing with (SUID) helper processes that communicate via GNUNET_MessageHeaders on stdin/stdout.

Author

Philipp Toelke

Christian Grothoff

Definition in file helper.c.

Function Documentation

stop_helper()

static void stop_helper ( struct GNUNET_HELPER_Handle *  h, int  soft_kill  )

static

Stop the helper process, we're closing down or had an error.

Parameters

h	handle to the helper process
soft_kill	if GNUNET_YES, signals termination by closing the helper's stdin; GNUNET_NO to signal termination by sending SIGTERM to helper

Definition at line 274 of file helper.c.

{
  if (NULL != h->restart_task)
  {
    GNUNET_SCHEDULER_cancel (h->restart_task);
    h->restart_task = NULL;
  }
  else
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_HELPER_kill (h,
                                      soft_kill));
    GNUNET_break (GNUNET_OK ==
                  GNUNET_HELPER_wait (h));
  }
}

References GNUNET_break, GNUNET_HELPER_kill(), GNUNET_HELPER_wait(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), and h.

Referenced by GNUNET_HELPER_stop(), helper_read(), helper_write(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

restart_task()

static void restart_task ( void *  cls )

static

Restart the helper process.

Parameters

cls	handle to the helper process

Definition at line 474 of file helper.c.

{
  struct GNUNET_HELPER_Handle *h = cls;
 
  h->restart_task = NULL;
  h->retry_back_off++;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Restarting helper with back-off %u\n",
              h->retry_back_off);
  start_helper (h);
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, h, and start_helper().

Referenced by helper_read(), helper_write(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

helper_read()

static void helper_read ( void *  cls )

static

Read from the helper-process.

Parameters

cls	handle to the helper process

Definition at line 308 of file helper.c.

{
  struct GNUNET_HELPER_Handle *h = cls;
  char buf[GNUNET_MAX_MESSAGE_SIZE] GNUNET_ALIGN;
  ssize_t t;
 
  h->read_task = NULL;
  t = GNUNET_DISK_file_read (h->fh_from_helper, &buf, sizeof(buf));
  if (t < 0)
  {
    /* On read-error, restart the helper */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Error reading from `%s': %s\n"),
                h->binary_name,
                strerror (errno));
    if (NULL != h->exp_cb)
    {
      h->exp_cb (h->cb_cls);
      GNUNET_HELPER_stop (h, GNUNET_NO);
      return;
    }
    stop_helper (h, GNUNET_NO);
    /* Restart the helper */
    h->restart_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     h->retry_back_off),
      &restart_task,
      h);
    return;
  }
  if (0 == t)
  {
    /* this happens if the helper is shut down via a
       signal, so it is not a "hard" error */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Got 0 bytes from helper `%s' (EOF)\n",
                h->binary_name);
    if (NULL != h->exp_cb)
    {
      h->exp_cb (h->cb_cls);
      GNUNET_HELPER_stop (h, GNUNET_NO);
      return;
    }
    stop_helper (h, GNUNET_NO);
    /* Restart the helper */
    h->restart_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     h->retry_back_off),
      &restart_task,
      h);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got %u bytes from helper `%s'\n",
              (unsigned int) t,
              h->binary_name);
  h->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 h->fh_from_helper,
                                                 &helper_read,
                                                 h);
  if (GNUNET_SYSERR ==
      GNUNET_MST_from_buffer (h->mst, buf, t, GNUNET_NO, GNUNET_NO))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to parse inbound message from helper `%s'\n"),
                h->binary_name);
    if (NULL != h->exp_cb)
    {
      h->exp_cb (h->cb_cls);
      GNUNET_HELPER_stop (h, GNUNET_NO);
      return;
    }
    stop_helper (h, GNUNET_NO);
    /* Restart the helper */
    h->restart_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     h->retry_back_off),
      &restart_task,
      h);
    return;
  }
}

References _, GNUNET_ALIGN, GNUNET_DISK_file_read(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_HELPER_stop(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SYSERR, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_SECONDS, h, helper_read(), restart_task(), stop_helper(), and t.

Referenced by helper_read(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

start_helper()

static void start_helper ( struct GNUNET_HELPER_Handle *  h )

static

Start the helper process.

Parameters

h	handle to the helper process

Definition at line 398 of file helper.c.

{
  h->helper_in =
    GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_RW);
  h->helper_out =
    GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_RW);
  if ((h->helper_in == NULL) || (h->helper_out == NULL))
  {
    /* out of file descriptors? try again later... */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "out of file descriptors? try again later\n");
    stop_helper (h, GNUNET_NO);
    h->restart_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     h->retry_back_off),
      &restart_task,
      h);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting HELPER process `%s'\n",
              h->binary_name);
  h->fh_from_helper =
    GNUNET_DISK_pipe_handle (h->helper_out, GNUNET_DISK_PIPE_END_READ);
  h->fh_to_helper =
    GNUNET_DISK_pipe_handle (h->helper_in, GNUNET_DISK_PIPE_END_WRITE);
  h->helper_proc = GNUNET_process_create ();
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_process_set_options (
                   h->helper_proc,
                   GNUNET_process_option_std_inheritance (
                     h->with_control_pipe
                     ? GNUNET_OS_INHERIT_STD_ERR
                     | GNUNET_OS_USE_PIPE_CONTROL
                     : GNUNET_OS_INHERIT_STD_ERR),
                   GNUNET_process_option_inherit_rpipe (h->helper_in,
                                                        STDIN_FILENO),
                   GNUNET_process_option_inherit_wpipe (h->helper_out,
                                                        STDOUT_FILENO)));
  if ( (GNUNET_OK !=
        GNUNET_process_set_command_argv (h->helper_proc,
                                         h->binary_name,
                                         (const char **) h->binary_argv)) ||
       (GNUNET_OK !=
        GNUNET_process_start (h->helper_proc)) )
  {
    /* failed to start process? try again later... */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "failed to start process? try again later\n");
    stop_helper (h,
                 GNUNET_NO);
    h->restart_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     h->retry_back_off),
      &restart_task,
      h);
    return;
  }
  GNUNET_DISK_pipe_close_end (h->helper_out,
                              GNUNET_DISK_PIPE_END_WRITE);
  GNUNET_DISK_pipe_close_end (h->helper_in,
                              GNUNET_DISK_PIPE_END_READ);
  if (NULL != h->mst)
    h->read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                                   h->fh_from_helper,
                                                   &helper_read,
                                                   h);
}

References GNUNET_assert, GNUNET_DISK_PF_BLOCKING_RW, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_OS_INHERIT_STD_ERR, GNUNET_OS_USE_PIPE_CONTROL, GNUNET_process_create(), GNUNET_process_option_inherit_rpipe, GNUNET_process_option_inherit_wpipe, GNUNET_process_option_std_inheritance, GNUNET_process_set_command_argv(), GNUNET_process_set_options, GNUNET_process_start(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_SECONDS, h, helper_read(), restart_task(), and stop_helper().

Referenced by GNUNET_HELPER_start(), and restart_task().

Here is the call graph for this function:

Here is the caller graph for this function:

helper_write()

static void helper_write ( void *  cls )

static

Write to the helper-process.

Parameters

cls	handle to the helper process

Definition at line 580 of file helper.c.

{
  struct GNUNET_HELPER_Handle *h = cls;
  struct GNUNET_HELPER_SendHandle *sh;
  const char *buf;
  ssize_t t;
 
  h->write_task = NULL;
  if (NULL == (sh = h->sh_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Helper write had no work!\n");
    return;   /* how did this happen? */
  }
  buf = (const char *) sh->msg;
  t = GNUNET_DISK_file_write (h->fh_to_helper,
                              &buf[sh->wpos],
                              ntohs (sh->msg->size) - sh->wpos);
  if (-1 == t)
  {
    /* On write-error, restart the helper */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Error writing to `%s': %s\n"),
                h->binary_name,
                strerror (errno));
    if (NULL != h->exp_cb)
    {
      h->exp_cb (h->cb_cls);
      GNUNET_HELPER_stop (h, GNUNET_NO);
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopping and restarting helper task!\n");
    stop_helper (h, GNUNET_NO);
    /* Restart the helper */
    h->restart_task = GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
                                     h->retry_back_off),
      &restart_task,
      h);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Transmitted %u bytes to %s\n",
              (unsigned int) t,
              h->binary_name);
  sh->wpos += t;
  if (sh->wpos == ntohs (sh->msg->size))
  {
    GNUNET_CONTAINER_DLL_remove (h->sh_head, h->sh_tail, sh);
    if (NULL != sh->cont)
      sh->cont (sh->cont_cls, GNUNET_YES);
    GNUNET_free (sh);
  }
  if (NULL != h->sh_head)
    h->write_task =
      GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                       h->fh_to_helper,
                                       &helper_write,
                                       h);
}

References _, GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_HELPER_stop(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_write_file(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, h, helper_write(), restart_task(), sh, stop_helper(), and t.

Referenced by GNUNET_HELPER_send(), and helper_write().

Here is the call graph for this function:

Here is the caller graph for this function: