os_priority.c File Reference

Methods to set process priority. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "disk.h"
#include <unistr.h>

Include dependency graph for os_priority.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_OS_Process
struct	GNUNET_OS_CommandHandle
	Handle to a command. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-os-priority", syscall)
#define	LOG_STRERROR_FILE(kind, syscall, filename)
#define	GNUNET_OS_CONTROL_PIPE   "GNUNET_OS_CONTROL_PIPE"

Functions
static void	shutdown_pch (void *cls)
	This handler is called on shutdown to remove the pch. More...
static void	parent_control_handler (void *cls)
	This handler is called when there are control data to be read on the pipe. More...
void	GNUNET_OS_install_parent_control_handler (void *cls)
	Connects this process to its parent via pipe; essentially, the parent control handler will read signal numbers from the GNUNET_OS_CONTROL_PIPE (as given in an environment variable) and raise those signals. More...
struct GNUNET_OS_Process *	GNUNET_OS_process_current ()
	Get process structure for current process. More...
int	GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
	Sends a signal to the process. More...
pid_t	GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc)
	Get the pid of the process in question. More...
void	GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc)
	Cleans up process structure contents (OS-dependent) and deallocates it. More...
static void	open_dev_null (int target_fd, int flags)
	Open '/dev/null' and make the result the given file descriptor. More...
static struct GNUNET_OS_Process *	start_process (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const int *lsocks, const char *filename, char *const argv[])
	Start a process. More...
struct GNUNET_OS_Process *	GNUNET_OS_start_process_vap (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename, char *const argv[])
	Start a process. More...
struct GNUNET_OS_Process *	GNUNET_OS_start_process_va (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename, va_list va)
	Start a process. More...
struct GNUNET_OS_Process *	GNUNET_OS_start_process (enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename,...)
	Start a process. More...
struct GNUNET_OS_Process *	GNUNET_OS_start_process_v (enum GNUNET_OS_InheritStdioFlags std_inheritance, const int *lsocks, const char *filename, char *const argv[])
	Start a process. More...
struct GNUNET_OS_Process *	GNUNET_OS_start_process_s (enum GNUNET_OS_InheritStdioFlags std_inheritance, const int *lsocks, const char *filename,...)
	Start a process. More...
static enum GNUNET_GenericReturnValue	process_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code, int options)
	Retrieve the status of a process, waiting on it if dead. More...
enum GNUNET_GenericReturnValue	GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
	Retrieve the status of a process. More...
enum GNUNET_GenericReturnValue	GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
	Retrieve the status of a process, waiting on it if dead. More...
enum GNUNET_GenericReturnValue	GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
	Wait for a process to terminate. More...
void	GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
	Stop/kill a command. More...
static void	cmd_read (void *cls)
	Read from the process and call the line processor. More...
struct GNUNET_OS_CommandHandle *	GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls, struct GNUNET_TIME_Relative timeout, const char *binary,...)
	Run the given command line and call the given function for each line of the output. More...

Variables
static struct GNUNET_OS_Process	current_process
	Handle for 'this' process. More...
static struct GNUNET_SCHEDULER_Task *	pch
	Handle for the parent_control_handler() Task. More...
static struct GNUNET_SCHEDULER_Task *	spch
	Handle for the shutdown_pch() Task. More...

Detailed Description

Methods to set process priority.

Author

Nils Durner

Definition in file os_priority.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)

Definition at line 33 of file os_priority.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-os-priority", syscall)

Definition at line 35 of file os_priority.c.

LOG_STRERROR_FILE

#define LOG_STRERROR_FILE	(		kind,
			syscall,
			filename
	)

Value:

        GNUNET_log_from_strerror_file (kind, "util-os-priority", syscall, \
                                       filename)

Definition at line 38 of file os_priority.c.

GNUNET_OS_CONTROL_PIPE

#define GNUNET_OS_CONTROL_PIPE   "GNUNET_OS_CONTROL_PIPE"

Definition at line 42 of file os_priority.c.

Function Documentation

shutdown_pch()

static void shutdown_pch ( void *  cls )

static

This handler is called on shutdown to remove the pch.

Parameters

cls	the struct GNUNET_DISK_FileHandle of the control pipe

Definition at line 82 of file os_priority.c.

{
  struct GNUNET_DISK_FileHandle *control_pipe = cls;
 
  GNUNET_SCHEDULER_cancel (pch);
  pch = NULL;
  GNUNET_DISK_file_close (control_pipe);
  control_pipe = NULL;
}

References GNUNET_DISK_file_close(), GNUNET_SCHEDULER_cancel(), and pch.

Referenced by GNUNET_OS_install_parent_control_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

parent_control_handler()

static void parent_control_handler ( void *  cls )

static

This handler is called when there are control data to be read on the pipe.

Parameters

cls	the struct GNUNET_DISK_FileHandle of the control pipe

Definition at line 99 of file os_priority.c.

{
  struct GNUNET_DISK_FileHandle *control_pipe = cls;
  char sig;
  char *pipe_fd;
  ssize_t ret;
 
  pch = NULL;
  ret = GNUNET_DISK_file_read (control_pipe, &sig, sizeof(sig));
  if (sizeof(sig) != ret)
  {
    if (-1 == ret)
      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing control pipe\n");
    GNUNET_DISK_file_close (control_pipe);
    control_pipe = NULL;
    GNUNET_SCHEDULER_cancel (spch);
    spch = NULL;
    return;
  }
  pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE);
  GNUNET_assert ((NULL == pipe_fd) || (strlen (pipe_fd) <= 0));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got control code %d from parent via pipe %s\n",
       sig,
       pipe_fd);
  pch = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                        control_pipe,
                                        &parent_control_handler,
                                        control_pipe);
  GNUNET_SIGNAL_raise ((int) sig);
}

References getenv(), GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_read(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OS_CONTROL_PIPE, GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_cancel(), GNUNET_SIGNAL_raise(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, LOG_STRERROR, parent_control_handler(), pch, ret, and spch.

Referenced by GNUNET_OS_install_parent_control_handler(), and parent_control_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

open_dev_null()

static void open_dev_null ( int  target_fd, int  flags  )

static

Open '/dev/null' and make the result the given file descriptor.

Parameters

target_fd	desired FD to point to /dev/null
flags	open flags (O_RDONLY, O_WRONLY)

Definition at line 278 of file os_priority.c.

{
  int fd;
 
  fd = open ("/dev/null", flags);
  if (-1 == fd)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", "/dev/null");
    return;
  }
  if (fd == target_fd)
    return;
  if (-1 == dup2 (fd, target_fd))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
    GNUNET_break (0 == close (fd));
    return;
  }
  GNUNET_break (0 == close (fd));
}

References GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_strerror, and GNUNET_log_strerror_file.

Referenced by start_process().

Here is the caller graph for this function:

start_process()

static struct GNUNET_OS_Process * start_process ( enum GNUNET_OS_InheritStdioFlags  std_inheritance, struct GNUNET_DISK_PipeHandle *  pipe_stdin, struct GNUNET_DISK_PipeHandle *  pipe_stdout, struct GNUNET_DISK_PipeHandle *  pipe_stderr, const int *  lsocks, const char *  filename, char *const  argv[]  )

static

Start a process.

Parameters

std_inheritance	a set of GNUNET_OS_INHERIT_STD_* flags controlling which std handles of the parent are inherited by the child. pipe_stdin and pipe_stdout take priority over std_inheritance (when they are non-NULL).
pipe_stdin	pipe to use to send input to child process (or NULL)
pipe_stdout	pipe to use to get output from child process (or NULL)
pipe_stderr	pipe to use for stderr for child process (or NULL)
lsocks	array of listen sockets to dup systemd-style (or NULL); must be NULL on platforms where dup is not supported
filename	name of the binary
argv	NULL-terminated list of arguments to the process

Returns

process ID of the new process, -1 on error

Definition at line 318 of file os_priority.c.

{
  pid_t ret;
  char fds[16];
  struct GNUNET_OS_Process *gnunet_proc;
  struct GNUNET_DISK_FileHandle *childpipe_read;
  struct GNUNET_DISK_FileHandle *childpipe_write;
  int childpipe_read_fd;
  int i;
  int j;
  int k;
  int tgt;
  int flags;
  int *lscp;
  unsigned int ls;
  int fd_stdout_write;
  int fd_stdout_read;
  int fd_stderr_write;
  int fd_stderr_read;
  int fd_stdin_read;
  int fd_stdin_write;
 
  if (GNUNET_SYSERR ==
      GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
    return NULL; /* not executable */
  if (0 != (std_inheritance & GNUNET_OS_USE_PIPE_CONTROL))
  {
    struct GNUNET_DISK_PipeHandle *childpipe;
    int dup_childpipe_read_fd = -1;
 
    childpipe = GNUNET_DISK_pipe (GNUNET_DISK_PF_NONE);
    if (NULL == childpipe)
      return NULL;
    childpipe_read =
      GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ);
    childpipe_write =
      GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE);
    GNUNET_DISK_pipe_close (childpipe);
    if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
        (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
                                                         &childpipe_read_fd)) ||
        (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd))))
    {
      if (NULL != childpipe_read)
        GNUNET_DISK_file_close (childpipe_read);
      if (NULL != childpipe_write)
        GNUNET_DISK_file_close (childpipe_write);
      if (0 <= dup_childpipe_read_fd)
        GNUNET_break (0 == close (dup_childpipe_read_fd));
      return NULL;
    }
    childpipe_read_fd = dup_childpipe_read_fd;
    GNUNET_DISK_file_close (childpipe_read);
  }
  else
  {
    childpipe_write = NULL;
    childpipe_read_fd = -1;
  }
  if (NULL != pipe_stdin)
  {
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_DISK_internal_file_handle_ (
        GNUNET_DISK_pipe_handle (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
        &fd_stdin_read));
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_DISK_internal_file_handle_ (
        GNUNET_DISK_pipe_handle (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE),
        &fd_stdin_write));
  }
  if (NULL != pipe_stdout)
  {
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_DISK_internal_file_handle_ (
        GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE),
        &fd_stdout_write));
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_DISK_internal_file_handle_ (
        GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_READ),
        &fd_stdout_read));
  }
  if (NULL != pipe_stderr)
  {
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_DISK_internal_file_handle_ (
        GNUNET_DISK_pipe_handle (pipe_stderr, GNUNET_DISK_PIPE_END_READ),
        &fd_stderr_read));
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_DISK_internal_file_handle_ (
        GNUNET_DISK_pipe_handle (pipe_stderr, GNUNET_DISK_PIPE_END_WRITE),
        &fd_stderr_write));
  }
  lscp = NULL;
  ls = 0;
  if (NULL != lsocks)
  {
    i = 0;
    while (-1 != (k = lsocks[i++]))
      GNUNET_array_append (lscp, ls, k);
    GNUNET_array_append (lscp, ls, -1);
  }
#if DARWIN
  /* see https://web.archive.org/web/20150924082249/gnunet.org/vfork */
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wdeprecated"
  #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  #pragma clang diagnostic push
  #pragma clang diagnostic ignored "-Wdeprecated"
  ret = vfork ();
  #pragma clang diagnostic pop
  #pragma GCC diagnostic pop
#else
  ret = fork ();
#endif
  if (-1 == ret)
  {
    int eno = errno;
 
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "fork");
    GNUNET_array_grow (lscp,
                       ls,
                       0);
    if (NULL != childpipe_write)
      GNUNET_DISK_file_close (childpipe_write);
    if (0 <= childpipe_read_fd)
      GNUNET_break (0 == close (childpipe_read_fd));
    errno = eno;
    return NULL;
  }
  if (0 != ret)
  {
    unsetenv (GNUNET_OS_CONTROL_PIPE);
    gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
    gnunet_proc->pid = ret;
    gnunet_proc->control_pipe = childpipe_write;
    if (0 != (std_inheritance & GNUNET_OS_USE_PIPE_CONTROL))
    {
      GNUNET_break (0 == close (childpipe_read_fd));
    }
    GNUNET_array_grow (lscp, ls, 0);
    return gnunet_proc;
  }
  if (0 <= childpipe_read_fd)
  {
    char fdbuf[100];
#ifndef DARWIN
    /* due to vfork, we must NOT free memory on DARWIN! */
    GNUNET_DISK_file_close (childpipe_write);
#endif
    snprintf (fdbuf,
              sizeof (fdbuf),
              "%x",
              childpipe_read_fd);
    setenv (GNUNET_OS_CONTROL_PIPE,
            fdbuf,
            1);
  }
  else
    unsetenv (GNUNET_OS_CONTROL_PIPE);
  if (NULL != pipe_stdin)
  {
    GNUNET_break (0 == close (fd_stdin_write));
    if (-1 == dup2 (fd_stdin_read,
                    0))
      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                    "dup2");
    GNUNET_break (0 == close (fd_stdin_read));
  }
  else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN))
  {
    GNUNET_break (0 == close (0));
    open_dev_null (0,
                   O_RDONLY);
  }
  if (NULL != pipe_stdout)
  {
    GNUNET_break (0 == close (fd_stdout_read));
    if (-1 == dup2 (fd_stdout_write,
                    1))
      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                    "dup2");
    GNUNET_break (0 ==
                  close (fd_stdout_write));
  }
  else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT))
  {
    GNUNET_break (0 == close (1));
    open_dev_null (1,
                   O_WRONLY);
  }
  if (NULL != pipe_stderr)
  {
    GNUNET_break (0 == close (fd_stderr_read));
    if (-1 == dup2 (fd_stderr_write,
                    2))
      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
    GNUNET_break (0 == close (fd_stderr_write));
  }
  else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR))
  {
    GNUNET_break (0 == close (2));
    open_dev_null (2,
                   O_WRONLY);
  }
  if (NULL != lscp)
  {
    char *fdnames = GNUNET_strdup ("");
 
    /* read systemd documentation... */
    i = 0;
    tgt = 3;
    while (-1 != lscp[i])
    {
      j = i + 1;
      while (-1 != lscp[j])
      {
        if (lscp[j] == tgt)
        {
          /* dup away */
          k = dup (lscp[j]);
          GNUNET_assert (-1 != k);
          GNUNET_assert (0 == close (lscp[j]));
          lscp[j] = k;
          break;
        }
        j++;
      }
      if (lscp[i] != tgt)
      {
        /* Bury any existing FD, no matter what; they should all be closed
         * on exec anyway and the important ones have been dup'ed away */
        GNUNET_break (0 == close (tgt));
        GNUNET_assert (-1 != dup2 (lscp[i],
                                   tgt));
      }
      /* unset close-on-exec flag */
      flags = fcntl (tgt,
                     F_GETFD);
      GNUNET_assert (flags >= 0);
      flags &= ~FD_CLOEXEC;
      fflush (stderr);
      (void) fcntl (tgt,
                    F_SETFD,
                    flags);
      {
        char *tmp;
 
        GNUNET_asprintf (&tmp,
                         "%s:%d",
                         fdnames,
                         tgt);
        GNUNET_free (fdnames);
        fdnames = tmp;
      }
      tgt++;
      i++;
    }
    GNUNET_snprintf (fds,
                     sizeof(fds),
                     "%u",
                     i);
    setenv ("LISTEN_FDS",
            fds,
            1);
    if (0 != strlen (fdnames))
      setenv ("LISTEN_FDNAMES",
              fdnames + 1, /* skip leading ':' */
              1);
    GNUNET_free (fdnames);
  }
#ifndef DARWIN
  /* due to vfork, we must NOT free memory on DARWIN! */
  GNUNET_array_grow (lscp,
                     ls,
                     0);
#endif
  execvp (filename,
          argv);
  LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR,
                     "execvp",
                     filename);
  _exit (1);
}

References GNUNET_OS_Process::control_pipe, filename, GNUNET_array_append, GNUNET_array_grow, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_DISK_file_close(), GNUNET_DISK_internal_file_handle_(), GNUNET_DISK_PF_NONE, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_detach_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_OS_check_helper_binary(), GNUNET_OS_CONTROL_PIPE, GNUNET_OS_INHERIT_STD_ERR, GNUNET_OS_INHERIT_STD_IN, GNUNET_OS_INHERIT_STD_OUT, GNUNET_OS_USE_PIPE_CONTROL, GNUNET_snprintf(), GNUNET_strdup, GNUNET_SYSERR, LOG_STRERROR, LOG_STRERROR_FILE, ls, open_dev_null(), GNUNET_OS_Process::pid, and ret.

Referenced by GNUNET_OS_start_process_v(), and GNUNET_OS_start_process_vap().

Here is the call graph for this function:

Here is the caller graph for this function:

process_status()

static enum GNUNET_GenericReturnValue process_status ( struct GNUNET_OS_Process *  proc, enum GNUNET_OS_ProcessStatusType *  type, unsigned long *  code, int  options  )

static

Retrieve the status of a process, waiting on it if dead.

Nonblocking version.

Parameters

proc	process ID
type	status type
code	return code/signal number
options	WNOHANG if non-blocking is desired

Returns

GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise

Definition at line 840 of file os_priority.c.

{
  int status;
  int ret;
 
  GNUNET_assert (0 != proc);
  ret = waitpid (proc->pid,
                 &status,
                 options);
  if (ret < 0)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                  "waitpid");
    return GNUNET_SYSERR;
  }
  if (0 == ret)
  {
    *type = GNUNET_OS_PROCESS_RUNNING;
    *code = 0;
    return GNUNET_NO;
  }
  if (proc->pid != ret)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                  "waitpid");
    return GNUNET_SYSERR;
  }
  if (WIFEXITED (status))
  {
    *type = GNUNET_OS_PROCESS_EXITED;
    *code = WEXITSTATUS (status);
  }
  else if (WIFSIGNALED (status))
  {
    *type = GNUNET_OS_PROCESS_SIGNALED;
    *code = WTERMSIG (status);
  }
  else if (WIFSTOPPED (status))
  {
    *type = GNUNET_OS_PROCESS_SIGNALED;
    *code = WSTOPSIG (status);
  }
#ifdef WIFCONTINUED
  else if (WIFCONTINUED (status))
  {
    *type = GNUNET_OS_PROCESS_RUNNING;
    *code = 0;
  }
#endif
  else
  {
    *type = GNUNET_OS_PROCESS_UNKNOWN;
    *code = 0;
  }
 
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_OK, GNUNET_OS_PROCESS_EXITED, GNUNET_OS_PROCESS_RUNNING, GNUNET_OS_PROCESS_SIGNALED, GNUNET_OS_PROCESS_UNKNOWN, GNUNET_SYSERR, LOG_STRERROR, options, GNUNET_OS_Process::pid, ret, status, and type.

Referenced by GNUNET_OS_process_status(), and GNUNET_OS_process_wait_status().

Here is the caller graph for this function:

cmd_read()

static void cmd_read ( void *  cls )

static

Read from the process and call the line processor.

Parameters

cls	the struct GNUNET_OS_CommandHandle *

Definition at line 1012 of file os_priority.c.

{
  struct GNUNET_OS_CommandHandle *cmd = cls;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
  GNUNET_OS_LineProcessor proc;
  char *end;
  ssize_t ret;
 
  cmd->rtask = NULL;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if (GNUNET_YES != GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, cmd->r))
  {
    /* timeout */
    proc = cmd->proc;
    cmd->proc = NULL;
    proc (cmd->proc_cls, NULL);
    return;
  }
  ret = GNUNET_DISK_file_read (cmd->r,
                               &cmd->buf[cmd->off],
                               sizeof(cmd->buf) - cmd->off);
  if (ret <= 0)
  {
    if ((cmd->off > 0) && (cmd->off < sizeof(cmd->buf)))
    {
      cmd->buf[cmd->off] = '\0';
      cmd->proc (cmd->proc_cls, cmd->buf);
    }
    proc = cmd->proc;
    cmd->proc = NULL;
    proc (cmd->proc_cls, NULL);
    return;
  }
  end = memchr (&cmd->buf[cmd->off], '\n', ret);
  cmd->off += ret;
  while (NULL != end)
  {
    *end = '\0';
    cmd->proc (cmd->proc_cls, cmd->buf);
    memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
    cmd->off -= (end + 1 - cmd->buf);
    end = memchr (cmd->buf, '\n', cmd->off);
  }
  cmd->rtask =
    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining (
                                      cmd->timeout),
                                    cmd->r,
                                    &cmd_read,
                                    cmd);
}

References GNUNET_OS_CommandHandle::buf, cmd_read(), end, GNUNET_DISK_file_read(), GNUNET_NETWORK_fdset_handle_isset(), GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_get_task_context(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, GNUNET_OS_CommandHandle::off, GNUNET_OS_CommandHandle::proc, GNUNET_OS_CommandHandle::proc_cls, GNUNET_OS_CommandHandle::r, GNUNET_SCHEDULER_TaskContext::read_ready, ret, GNUNET_OS_CommandHandle::rtask, tc, and GNUNET_OS_CommandHandle::timeout.

Referenced by cmd_read(), and GNUNET_OS_command_run().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

current_process

struct GNUNET_OS_Process current_process

static

Handle for 'this' process.

Definition at line 63 of file os_priority.c.

Referenced by GNUNET_OS_process_current().

pch

struct GNUNET_SCHEDULER_Task* pch

static

Handle for the parent_control_handler() Task.

Definition at line 68 of file os_priority.c.

Referenced by extract_filename(), GNUNET_OS_install_parent_control_handler(), parent_control_handler(), and shutdown_pch().

spch

struct GNUNET_SCHEDULER_Task* spch

static

Handle for the shutdown_pch() Task.

Definition at line 73 of file os_priority.c.

Referenced by GNUNET_OS_install_parent_control_handler(), and parent_control_handler().