OS library

Low level process routines. More...

Collaboration diagram for OS library:

Data Structures
struct	GNUNET_OS_ProjectData
	Project-specific data used to help the OS subsystem find installation paths. More...

Macros
#define	GNUNET_OS_get_hostname_max_length()   255
	Get maximum string length returned by gethostname() More...

Typedefs
typedef int(*	GNUNET_OS_NetworkInterfaceProcessor) (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
	Callback function invoked for each interface found. More...
typedef void(*	GNUNET_OS_LineProcessor) (void *cls, const char *line)
	Type of a function to process a line of output. More...

Enumerations
enum	GNUNET_OS_InheritStdioFlags {   GNUNET_OS_INHERIT_STD_NONE = 0 , GNUNET_OS_INHERIT_STD_IN = 1 , GNUNET_OS_INHERIT_STD_OUT = 2 , GNUNET_OS_INHERIT_STD_ERR = 4 ,   GNUNET_OS_INHERIT_STD_OUT_AND_ERR = 6 , GNUNET_OS_INHERIT_STD_ALL = 7 , GNUNET_OS_USE_PIPE_CONTROL = 8 }
	Flags that determine which of the standard streams should be inherited by the child process. More...
enum	GNUNET_OS_InstallationPathKind {   GNUNET_OS_IPK_PREFIX , GNUNET_OS_IPK_BINDIR , GNUNET_OS_IPK_LIBDIR , GNUNET_OS_IPK_DATADIR ,   GNUNET_OS_IPK_LOCALEDIR , GNUNET_OS_IPK_SELF_PREFIX , GNUNET_OS_IPK_ICONDIR , GNUNET_OS_IPK_DOCDIR ,   GNUNET_OS_IPK_LIBEXECDIR }
	Possible installation paths to request. More...
enum	GNUNET_OS_ProcessStatusType {   GNUNET_OS_PROCESS_UNKNOWN , GNUNET_OS_PROCESS_RUNNING , GNUNET_OS_PROCESS_STOPPED , GNUNET_OS_PROCESS_EXITED ,   GNUNET_OS_PROCESS_SIGNALED }
	Process status types. More...

Functions
const struct GNUNET_OS_ProjectData *	GNUNET_OS_project_data_default (void)
	Return default project data used by 'libgnunetutil' for GNUnet. More...
const struct GNUNET_OS_ProjectData *	GNUNET_OS_project_data_get (void)
void	GNUNET_OS_init (const struct GNUNET_OS_ProjectData *pd)
	Setup OS subsystem with project data. More...
char *	GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
	Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX, the current running apps installation directory. More...
char *	GNUNET_OS_get_libexec_binary_path (const char *progname)
	Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the libexec/-directory to get the full path. More...
char *	GNUNET_OS_get_suid_binary_path (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *progname)
	Given the name of a helper, service or daemon binary construct the full path to the binary using the SUID_BINARY_PATH in the PATHS section of the configuration. More...
void	GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
	Enumerate all network interfaces. More...
struct GNUNET_OS_Process *	GNUNET_OS_process_current (void)
	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...
void	GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc)
	Cleans up process structure contents (OS-dependent) and deallocates it. More...
pid_t	GNUNET_OS_process_get_pid (struct GNUNET_OS_Process *proc)
	Get the pid of the process in question. 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 (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_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_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...
void	GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
	Stop/kill a command. 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...
int	GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
	Retrieve the status of a process. More...
int	GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
	Wait for a process to terminate. More...
int	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...
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...
enum GNUNET_GenericReturnValue	GNUNET_OS_check_helper_binary (const char *binary, bool check_suid, const char *params)
	Check whether an executable exists and possibly if the suid bit is set on the file. More...

Detailed Description

Low level process routines.

This code manages child processes. We can communicate with child processes using signals. Because signals are not supported on W32 and Java (at least not nicely), we can alternatively use a pipe to send signals to the child processes (if the child process is a full-blown GNUnet process that supports reading signals from a pipe, of course). Naturally, this also only works for 'normal' termination via signals, and not as a replacement for SIGKILL. Thus using pipes to communicate signals should only be enabled if the child is a Java process OR if we are on Windoze.

Macro Definition Documentation

GNUNET_OS_get_hostname_max_length

#define GNUNET_OS_get_hostname_max_length

(

)

255

Get maximum string length returned by gethostname()

Definition at line 416 of file gnunet_os_lib.h.

Typedef Documentation

GNUNET_OS_NetworkInterfaceProcessor

typedef int(* GNUNET_OS_NetworkInterfaceProcessor) (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)

Callback function invoked for each interface found.

Parameters

cls	closure
name	name of the interface (can be NULL for unknown)
isDefault	is this presumably the default interface
addr	address of this interface (can be NULL for unknown or unassigned)
broadcast_addr	the broadcast address (can be NULL for unknown or unassigned)
netmask	the network mask (can be NULL for unknown or unassigned)
addrlen	length of the address

Returns

GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 386 of file gnunet_os_lib.h.

GNUNET_OS_LineProcessor

typedef void(* GNUNET_OS_LineProcessor) (void *cls, const char *line)

Type of a function to process a line of output.

Parameters

cls	closure
line	line of output from a command, NULL for the end

Definition at line 574 of file gnunet_os_lib.h.

Enumeration Type Documentation

GNUNET_OS_InheritStdioFlags

enum GNUNET_OS_InheritStdioFlags

Flags that determine which of the standard streams should be inherited by the child process.

Enumerator
GNUNET_OS_INHERIT_STD_NONE	No standard streams should be inherited.
GNUNET_OS_INHERIT_STD_IN	When this flag is set, the child process will inherit stdin of the parent.
GNUNET_OS_INHERIT_STD_OUT	When this flag is set, the child process will inherit stdout of the parent.
GNUNET_OS_INHERIT_STD_ERR	When this flag is set, the child process will inherit stderr of the parent.
GNUNET_OS_INHERIT_STD_OUT_AND_ERR	When these flags are set, the child process will inherit stdout and stderr of the parent.
GNUNET_OS_INHERIT_STD_ALL	Use this option to have all of the standard streams (stdin, stdout and stderror) be inherited.
GNUNET_OS_USE_PIPE_CONTROL	Should a pipe be used to send signals to the child?

Definition at line 72 of file gnunet_os_lib.h.

{
  GNUNET_OS_INHERIT_STD_NONE = 0,
 
  GNUNET_OS_INHERIT_STD_IN = 1,
 
  GNUNET_OS_INHERIT_STD_OUT = 2,
 
  GNUNET_OS_INHERIT_STD_ERR = 4,
 
  GNUNET_OS_INHERIT_STD_OUT_AND_ERR = 6,
 
  GNUNET_OS_INHERIT_STD_ALL = 7,
 
  GNUNET_OS_USE_PIPE_CONTROL = 8
};

GNUNET_OS_InstallationPathKind

enum GNUNET_OS_InstallationPathKind

Possible installation paths to request.

Enumerator
GNUNET_OS_IPK_PREFIX	Return the "PREFIX" directory given to configure.
GNUNET_OS_IPK_BINDIR	Return the directory where the program binaries are installed. (bin/)
GNUNET_OS_IPK_LIBDIR	Return the directory where libraries are installed. (lib/gnunet/)
GNUNET_OS_IPK_DATADIR	Return the directory where data is installed (share/gnunet/)
GNUNET_OS_IPK_LOCALEDIR	Return the directory where translations are installed (share/locale/)
GNUNET_OS_IPK_SELF_PREFIX	Return the installation directory of this application, not the one of the overall GNUnet installation (in case they are different).
GNUNET_OS_IPK_ICONDIR	Return the prefix of the path with application icons (share/icons/).
GNUNET_OS_IPK_DOCDIR	Return the prefix of the path with documentation files, including the license (share/doc/gnunet/).
GNUNET_OS_IPK_LIBEXECDIR	Return the directory where helper binaries are installed (lib/gnunet/libexec/)

Definition at line 125 of file gnunet_os_lib.h.

{
  GNUNET_OS_IPK_PREFIX,
 
  GNUNET_OS_IPK_BINDIR,
 
  GNUNET_OS_IPK_LIBDIR,
 
  GNUNET_OS_IPK_DATADIR,
 
  GNUNET_OS_IPK_LOCALEDIR,
 
  GNUNET_OS_IPK_SELF_PREFIX,
 
  GNUNET_OS_IPK_ICONDIR,
 
  GNUNET_OS_IPK_DOCDIR,
 
  GNUNET_OS_IPK_LIBEXECDIR
};

GNUNET_OS_ProcessStatusType

enum GNUNET_OS_ProcessStatusType

Process status types.

Enumerator
GNUNET_OS_PROCESS_UNKNOWN	The process is not known to the OS (or at least not one of our children).
GNUNET_OS_PROCESS_RUNNING	The process is still running.
GNUNET_OS_PROCESS_STOPPED	The process is paused (but could be resumed).
GNUNET_OS_PROCESS_EXITED	The process exited with a return code.
GNUNET_OS_PROCESS_SIGNALED	The process was killed by a signal.

Definition at line 180 of file gnunet_os_lib.h.

{
  GNUNET_OS_PROCESS_UNKNOWN,
 
  GNUNET_OS_PROCESS_RUNNING,
 
  GNUNET_OS_PROCESS_STOPPED,
 
  GNUNET_OS_PROCESS_EXITED,
 
  GNUNET_OS_PROCESS_SIGNALED
};

Function Documentation

GNUNET_OS_project_data_default()

const struct GNUNET_OS_ProjectData* GNUNET_OS_project_data_default

(

void

)

Return default project data used by 'libgnunetutil' for GNUnet.

Definition at line 95 of file os_installation.c.

{
  return &default_pd;
}

References default_pd.

Referenced by __attribute__(), GNUNET_BLOCK_context_create(), GNUNET_CONFIGURATION_default(), GNUNET_DATACACHE_create(), init(), and run().

Here is the caller graph for this function:

GNUNET_OS_project_data_get()

const struct GNUNET_OS_ProjectData* GNUNET_OS_project_data_get

(

void

)

Returns

current (actual) project data.

current project data.

Definition at line 105 of file os_installation.c.

{
  if (current_pd != gettextinit)
  {
    char *path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
 
    if (NULL != path)
      bindtextdomain (PACKAGE,
                      path);
    GNUNET_free (path);
    gettextinit = current_pd;
  }
  return current_pd;
}

References bindtextdomain, current_pd, gettextinit, GNUNET_free, GNUNET_OS_installation_get_path(), and GNUNET_OS_IPK_LOCALEDIR.

Referenced by __attribute__(), GNUNET_CADET_open_port(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_default(), GNUNET_CONFIGURATION_default_filename(), GNUNET_CONFIGURATION_load(), GNUNET_DATACACHE_create(), GNUNET_PLUGIN_load_all_in_context(), GNUNET_SERVICE_run_(), LEGACY_SERVICE_run(), return_agpl(), and set_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_init()

void GNUNET_OS_init

(

const struct GNUNET_OS_ProjectData *

pd

)

Setup OS subsystem with project data.

Parameters

pd	project data used to determine paths.

Definition at line 122 of file os_installation.c.

{
  GNUNET_assert (NULL != pd);
  current_pd = pd;
  if (pd != gettextinit)
  {
    char *path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
 
    if (NULL != path)
      bindtextdomain (PACKAGE,
                      path);
    GNUNET_free (path);
    gettextinit = pd;
  }
}

References bindtextdomain, current_pd, gettextinit, GNUNET_assert, GNUNET_free, GNUNET_OS_installation_get_path(), and GNUNET_OS_IPK_LOCALEDIR.

Referenced by __attribute__(), GNUNET_CONFIGURATION_default(), GNUNET_DATACACHE_create(), and GNUNET_PLUGIN_load_all_in_context().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_installation_get_path()

char* GNUNET_OS_installation_get_path

(

enum GNUNET_OS_InstallationPathKind

dirkind

)

Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX, the current running apps installation directory.

Parameters

dirkind

what kind of directory is desired?

Returns

a pointer to the dir path (to be freed by the caller)

Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX, the current running apps installation directory.

Returns

a pointer to the dir path (to be freed by the caller)

Definition at line 451 of file os_installation.c.

{
  size_t n;
  char *dirname;
  char *execpath = NULL;
  char *tmp;
  char *multiarch;
  char *libdir;
  int isbasedir;
 
  /* if wanted, try to get the current app's bin/ */
  if (dirkind == GNUNET_OS_IPK_SELF_PREFIX)
    execpath = os_get_exec_path ();
 
  /* try to get GNUnet's bin/ or lib/, or if previous was unsuccessful some
   * guess for the current app */
  if (NULL == execpath)
    execpath = os_get_gnunet_path ();
  if (NULL == execpath)
    return NULL;
 
  n = strlen (execpath);
  if (0 == n)
  {
    /* should never happen, but better safe than sorry */
    GNUNET_free (execpath);
    return NULL;
  }
  /* remove filename itself */
  while ((n > 1) && (DIR_SEPARATOR == execpath[n - 1]))
    execpath[--n] = '\0';
 
  isbasedir = 1;
  if ((n > 6) && ((0 == strcasecmp (&execpath[n - 6], "/lib32")) ||
                  (0 == strcasecmp (&execpath[n - 6], "/lib64"))))
  {
    if ((GNUNET_OS_IPK_LIBDIR != dirkind) &&
        (GNUNET_OS_IPK_LIBEXECDIR != dirkind))
    {
      /* strip '/lib32' or '/lib64' */
      execpath[n - 6] = '\0';
      n -= 6;
    }
    else
      isbasedir = 0;
  }
  else if ((n > 4) && ((0 == strcasecmp (&execpath[n - 4], "/bin")) ||
                       (0 == strcasecmp (&execpath[n - 4], "/lib"))))
  {
    /* strip '/bin' or '/lib' */
    execpath[n - 4] = '\0';
    n -= 4;
  }
  multiarch = NULL;
  if (NULL != (libdir = strstr (execpath, "/lib/")))
  {
    /* test for multi-arch path of the form "PREFIX/lib/MULTIARCH/";
       here we need to re-add 'multiarch' to lib and libexec paths later! */
    multiarch = &libdir[5];
    if (NULL == strchr (multiarch, '/'))
      libdir[0] =
        '\0';   /* Debian multiarch format, cut of from 'execpath' but preserve in multicarch */
    else
      multiarch =
        NULL;   /* maybe not, multiarch still has a '/', which is not OK */
  }
  /* in case this was a directory named foo-bin, remove "foo-" */
  while ((n > 1) && (execpath[n - 1] == DIR_SEPARATOR))
    execpath[--n] = '\0';
  switch (dirkind)
  {
  case GNUNET_OS_IPK_PREFIX:
  case GNUNET_OS_IPK_SELF_PREFIX:
    dirname = GNUNET_strdup (DIR_SEPARATOR_STR);
    break;
 
  case GNUNET_OS_IPK_BINDIR:
    dirname = GNUNET_strdup (DIR_SEPARATOR_STR "bin" DIR_SEPARATOR_STR);
    break;
 
  case GNUNET_OS_IPK_LIBDIR:
    if (isbasedir)
    {
      GNUNET_asprintf (&tmp,
                       "%s%s%s%s%s%s%s",
                       execpath,
                       DIR_SEPARATOR_STR "lib",
                       (NULL != multiarch) ? DIR_SEPARATOR_STR : "",
                       (NULL != multiarch) ? multiarch : "",
                       DIR_SEPARATOR_STR,
                       current_pd->project_dirname,
                       DIR_SEPARATOR_STR);
      if (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES))
      {
        GNUNET_free (execpath);
        return tmp;
      }
      GNUNET_free (tmp);
      tmp = NULL;
      dirname = NULL;
      if (4 == sizeof(void *))
      {
        GNUNET_asprintf (&dirname,
                         DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR
                         "%s" DIR_SEPARATOR_STR,
                         current_pd->project_dirname);
        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
      }
      if (8 == sizeof(void *))
      {
        GNUNET_asprintf (&dirname,
                         DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR
                         "%s" DIR_SEPARATOR_STR,
                         current_pd->project_dirname);
        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
      }
 
      if ((NULL != tmp) &&
          (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES)))
      {
        GNUNET_free (execpath);
        GNUNET_free (dirname);
        return tmp;
      }
      GNUNET_free (tmp);
      GNUNET_free (dirname);
    }
    GNUNET_asprintf (&dirname,
                     DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
                     current_pd->project_dirname);
    break;
 
  case GNUNET_OS_IPK_DATADIR:
    GNUNET_asprintf (&dirname,
                     DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
                     "%s" DIR_SEPARATOR_STR,
                     current_pd->project_dirname);
    break;
 
  case GNUNET_OS_IPK_LOCALEDIR:
    dirname = GNUNET_strdup (DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
                             "locale" DIR_SEPARATOR_STR);
    break;
 
  case GNUNET_OS_IPK_ICONDIR:
    dirname = GNUNET_strdup (DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
                             "icons" DIR_SEPARATOR_STR);
    break;
 
  case GNUNET_OS_IPK_DOCDIR:
    GNUNET_asprintf (&dirname,
                     DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
                     "doc" DIR_SEPARATOR_STR
                     "%s" DIR_SEPARATOR_STR,
                     current_pd->project_dirname);
    break;
 
  case GNUNET_OS_IPK_LIBEXECDIR:
    if (isbasedir)
    {
      GNUNET_asprintf (&dirname,
                       DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR
                       "libexec" DIR_SEPARATOR_STR,
                       current_pd->project_dirname);
      GNUNET_asprintf (&tmp,
                       "%s%s%s%s",
                       execpath,
                       DIR_SEPARATOR_STR "lib" DIR_SEPARATOR_STR,
                       (NULL != multiarch) ? multiarch : "",
                       dirname);
      GNUNET_free (dirname);
      if (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES))
      {
        GNUNET_free (execpath);
        return tmp;
      }
      GNUNET_free (tmp);
      tmp = NULL;
      dirname = NULL;
      if (4 == sizeof(void *))
      {
        GNUNET_asprintf (&dirname,
                         DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR
                         "%s" DIR_SEPARATOR_STR
                         "libexec" DIR_SEPARATOR_STR,
                         current_pd->project_dirname);
        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
      }
      if (8 == sizeof(void *))
      {
        GNUNET_asprintf (&dirname,
                         DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR
                         "%s" DIR_SEPARATOR_STR
                         "libexec" DIR_SEPARATOR_STR,
                         current_pd->project_dirname);
        GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
      }
      if ((NULL != tmp) &&
          (GNUNET_YES == GNUNET_DISK_directory_test (tmp, GNUNET_YES)))
      {
        GNUNET_free (execpath);
        GNUNET_free (dirname);
        return tmp;
      }
      GNUNET_free (tmp);
      GNUNET_free (dirname);
    }
    GNUNET_asprintf (&dirname,
                     DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR
                     "libexec" DIR_SEPARATOR_STR,
                     current_pd->project_dirname);
    break;
 
  default:
    GNUNET_free (execpath);
    return NULL;
  }
  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
  GNUNET_free (dirname);
  GNUNET_free (execpath);
  return tmp;
}

References current_pd, DIR_SEPARATOR, DIR_SEPARATOR_STR, GNUNET_asprintf(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_OS_IPK_BINDIR, GNUNET_OS_IPK_DATADIR, GNUNET_OS_IPK_DOCDIR, GNUNET_OS_IPK_ICONDIR, GNUNET_OS_IPK_LIBDIR, GNUNET_OS_IPK_LIBEXECDIR, GNUNET_OS_IPK_LOCALEDIR, GNUNET_OS_IPK_PREFIX, GNUNET_OS_IPK_SELF_PREFIX, GNUNET_strdup, GNUNET_YES, os_get_exec_path(), os_get_gnunet_path(), and GNUNET_OS_ProjectData::project_dirname.

Referenced by GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_load(), GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_init(), GNUNET_OS_project_data_get(), GNUNET_PLUGIN_load_all(), GNUNET_SERVICE_run_(), hostkeys_load(), load_keys(), netjail_stop_run(), plugin_init(), run(), run_service(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_get_libexec_binary_path()

char* GNUNET_OS_get_libexec_binary_path

(

const char *

progname

)

Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the libexec/-directory to get the full path.

Parameters

progname

name of the binary

Returns

full path to the binary, if possible, otherwise copy of 'progname'

Definition at line 684 of file os_installation.c.

{
  static char *cache;
  char *libexecdir;
  char *binary;
 
  if ((DIR_SEPARATOR == progname[0]) ||
      (GNUNET_YES ==
       GNUNET_STRINGS_path_is_absolute (progname, GNUNET_NO, NULL, NULL)))
    return GNUNET_strdup (progname);
  if (NULL != cache)
    libexecdir = cache;
  else
    libexecdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBEXECDIR);
  if (NULL == libexecdir)
    return GNUNET_strdup (progname);
  GNUNET_asprintf (&binary, "%s%s", libexecdir, progname);
  cache = libexecdir;
  return binary;
}

References cache, DIR_SEPARATOR, GNUNET_asprintf(), GNUNET_NO, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_LIBEXECDIR, GNUNET_strdup, GNUNET_STRINGS_path_is_absolute(), and GNUNET_YES.

Referenced by communicator_start(), GNUNET_HELPER_start(), GNUNET_OS_check_helper_binary(), GNUNET_TESTBED_controller_start(), GNUNET_TESTBED_is_host_habitable(), GNUNET_TESTING_peer_configure(), GNUNET_TESTING_service_run(), nat_start(), peerstore_start(), resolver_start(), start_helper(), start_process(), start_shared_service_instance(), statistics_start(), test_icmp_client(), test_icmp_server(), and tokenizer_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_get_suid_binary_path()

char* GNUNET_OS_get_suid_binary_path	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	progname
	)

Given the name of a helper, service or daemon binary construct the full path to the binary using the SUID_BINARY_PATH in the PATHS section of the configuration.

If that option is not present, fall back to GNUNET_OS_get_libexec_binary_path. If progname is an absolute path, a copy of this path is returned.

Parameters

cfg	configuration to inspect
progname	name of the binary

Returns

full path to the binary, if possible, a copy of progname otherwise

Definition at line 719 of file os_installation.c.

{
  static char *cache;
  char *binary = NULL;
  char *path = NULL;
  size_t path_len;
 
  if (GNUNET_YES ==
      GNUNET_STRINGS_path_is_absolute (progname, GNUNET_NO, NULL, NULL))
  {
    return GNUNET_strdup (progname);
  }
  if (NULL != cache)
    path = cache;
  else
    GNUNET_CONFIGURATION_get_value_string (cfg,
                                           "PATHS",
                                           "SUID_BINARY_PATH",
                                           &path);
  if ((NULL == path) || (0 == strlen (path)))
  {
    if (NULL != path)
      GNUNET_free (path);
    cache = NULL;
    return GNUNET_OS_get_libexec_binary_path (progname);
  }
  path_len = strlen (path);
  GNUNET_asprintf (&binary,
                   "%s%s%s",
                   path,
                   (path[path_len - 1] == DIR_SEPARATOR) ? ""
                   : DIR_SEPARATOR_STR,
                   progname);
  cache = path;
  return binary;
}

Referenced by restart_nat_server(), and run().

Here is the caller graph for this function:

GNUNET_OS_network_interfaces_list()

void GNUNET_OS_network_interfaces_list	(	GNUNET_OS_NetworkInterfaceProcessor	proc,
		void *	proc_cls
	)

Enumerate all network interfaces.

Parameters

proc	the callback function
proc_cls	closure for proc

Definition at line 397 of file os_network.c.

{
#if HAVE_GETIFADDRS && HAVE_FREEIFADDRS
  struct ifaddrs *ifa_first;
  struct ifaddrs *ifa_ptr;
  socklen_t alen;
 
  if (getifaddrs (&ifa_first) == 0)
  {
    for (ifa_ptr = ifa_first; ifa_ptr != NULL; ifa_ptr = ifa_ptr->ifa_next)
    {
      if ((ifa_ptr->ifa_name != NULL) && (ifa_ptr->ifa_addr != NULL) &&
          ( (ifa_ptr->ifa_flags & IFF_UP) != 0) )
      {
        if ((ifa_ptr->ifa_addr->sa_family != AF_INET) &&
            (ifa_ptr->ifa_addr->sa_family != AF_INET6))
          continue;
        if (ifa_ptr->ifa_addr->sa_family == AF_INET)
          alen = sizeof(struct sockaddr_in);
        else
          alen = sizeof(struct sockaddr_in6);
        if (GNUNET_OK !=
            proc (proc_cls, ifa_ptr->ifa_name,
                  (0 == strcmp (ifa_ptr->ifa_name, GNUNET_DEFAULT_INTERFACE)),
                  ifa_ptr->ifa_addr, ifa_ptr->ifa_broadaddr,
                  ifa_ptr->ifa_netmask, alen))
          break;
      }
    }
    freeifaddrs (ifa_first);
  }
#else
  if (GNUNET_OK ==
      try_ip (proc,
              proc_cls))
    return;
  if (GNUNET_OK ==
      try_ifconfig (proc,
                    proc_cls))
    return;
  LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
       "Failed to enumerate network interfaces\n");
#endif
}

References GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_WARNING, GNUNET_OK, LOG, try_ifconfig(), and try_ip().

Referenced by do_broadcast(), get_addresses(), GNUNET_NT_scanner_init(), host_habitable_cb(), run_scan(), scan(), setup_broadcast(), and test_local_ip().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_process_current()

struct GNUNET_OS_Process* GNUNET_OS_process_current

(

void

)

Get process structure for current process.

The pointer it returns points to static memory location and must not be deallocated/closed

Returns

pointer to the process sturcutre for this process

The pointer it returns points to static memory location and must not be deallocated/closed.

Returns

pointer to the process sturcutre for this process

Definition at line 202 of file os_priority.c.

{
  current_process.pid = 0;
  return &current_process;
}

References current_process, and GNUNET_OS_Process::pid.

GNUNET_OS_process_kill()

int GNUNET_OS_process_kill	(	struct GNUNET_OS_Process *	proc,
		int	sig
	)

Sends a signal to the process.

Parameters

proc	pointer to process structure
sig	signal

Returns

0 on success, -1 on error

Definition at line 210 of file os_priority.c.

{
  int ret;
  char csig;
 
  csig = (char) sig;
  if (NULL != proc->control_pipe)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sending signal %d to pid: %u via pipe\n",
         sig,
         proc->pid);
    ret = GNUNET_DISK_file_write (proc->control_pipe, &csig, sizeof(csig));
    if (sizeof(csig) == ret)
      return 0;
  }
  /* pipe failed or non-existent, try other methods */
  switch (sig)
  {
  case SIGHUP:
  case SIGINT:
  case SIGKILL:
  case SIGTERM:
#if (SIGTERM != GNUNET_TERM_SIG)
  case GNUNET_TERM_SIG:
#endif
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sending signal %d to pid: %u via system call\n",
         sig,
         proc->pid);
    return kill (proc->pid, sig);
  default:
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sending signal %d to pid: %u via system call\n",
         sig,
         proc->pid);
    return kill (proc->pid, sig);
  }
}

References GNUNET_OS_Process::control_pipe, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_TERM_SIG, LOG, GNUNET_OS_Process::pid, and ret.

Referenced by do_stop_task(), GN_stop_gnunet_nat_server_(), GNUNET_HELPER_kill(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_stop(), GNUNET_TESTBED_is_host_habitable_cancel(), GNUNET_TESTING_peer_kill(), handle_stop(), maint_child_death(), nat_server_read(), netjail_start_cleanup(), netjail_stop_cleanup(), shutdown_process(), shutdown_program(), shutdown_task(), and stop_shared_service_instance().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_process_destroy()

void GNUNET_OS_process_destroy

(

struct GNUNET_OS_Process *

proc

)

Cleans up process structure contents (OS-dependent) and deallocates it.

Parameters

proc	pointer to process structure

Definition at line 273 of file os_priority.c.

{
  if (NULL != proc->control_pipe)
    GNUNET_DISK_file_close (proc->control_pipe);
 
  GNUNET_free (proc);
}

References GNUNET_OS_Process::control_pipe, GNUNET_DISK_file_close(), and GNUNET_free.

Referenced by child_completed_callback(), child_death_task(), GN_stop_gnunet_nat_server_(), GNUNET_HELPER_wait(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_stop(), GNUNET_TESTBED_is_host_habitable_cancel(), GNUNET_TESTING_peer_wait(), habitability_check(), maint_child_death(), nat_server_read(), netjail_start_cleanup(), netjail_stop_cleanup(), shutdown_process(), shutdown_task(), stop_shared_service_instance(), and wait_child().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_process_get_pid()

pid_t GNUNET_OS_process_get_pid

(

struct GNUNET_OS_Process *

proc

)

Get the pid of the process in question.

Parameters

proc	the process to get the pid of

Returns

the current process id

Definition at line 260 of file os_priority.c.

{
  return proc->pid;
}

References GNUNET_OS_Process::pid.

Referenced by maint_child_death().

Here is the caller graph for this function:

GNUNET_OS_start_process_vap()

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.

Parameters

std_inheritance	a set of GNUNET_OS_INHERIT_STD_* flags
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 to get error output from child process (or NULL)
filename	name of the binary
argv	NULL-terminated array of arguments to the process

Returns

pointer to process structure of the new process, NULL on error

Definition at line 580 of file os_priority.c.

{
  return start_process (std_inheritance,
                        pipe_stdin,
                        pipe_stdout,
                        pipe_stderr,
                        NULL,
                        filename,
                        argv);
}

References filename, and start_process().

Referenced by GNUNET_OS_start_process_va(), GNUNET_TESTBED_is_host_habitable(), handle_uri(), main(), netjail_stop_run(), start_helper(), and work().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_start_process()

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.

Parameters

std_inheritance	a set of GNUNET_OS_INHERIT_STD_* flags
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 to get error output from child process (or NULL)
filename	name of the binary
...	NULL-terminated list of arguments to the process

Returns

pointer to process structure of the new process, NULL on error

Definition at line 633 of file os_priority.c.

{
  struct GNUNET_OS_Process *ret;
  va_list ap;
 
  va_start (ap, filename);
  ret = GNUNET_OS_start_process_va (std_inheritance,
                                    pipe_stdin,
                                    pipe_stdout,
                                    pipe_stderr,
                                    filename,
                                    ap);
  va_end (ap);
  return ret;
}

References filename, GNUNET_OS_start_process_va(), and ret.

Referenced by GNUNET_NAT_mini_get_external_ipv4_(), nat_start(), peerstore_start(), resolver_start(), restart_nat_server(), run(), start_shared_service_instance(), statistics_start(), and tokenizer_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_start_process_va()

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.

Parameters

std_inheritance	a set of GNUNET_OS_INHERIT_STD_* flags
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 to get error output from child process (or NULL)
filename	name of the binary
va	NULL-terminated list of arguments to the process

Returns

pointer to process structure of the new process, NULL on error

Definition at line 598 of file os_priority.c.

{
  struct GNUNET_OS_Process *ret;
  va_list ap;
  char **argv;
  int argc;
 
  argc = 0;
  va_copy (ap, va);
  while (NULL != va_arg (ap, char *))
    argc++;
  va_end (ap);
  argv = GNUNET_malloc (sizeof(char *) * (argc + 1));
  argc = 0;
  va_copy (ap, va);
  while (NULL != (argv[argc] = va_arg (ap, char *)))
    argc++;
  va_end (ap);
  ret = GNUNET_OS_start_process_vap (std_inheritance,
                                     pipe_stdin,
                                     pipe_stdout,
                                     pipe_stderr,
                                     filename,
                                     argv);
  GNUNET_free (argv);
  return ret;
}

References filename, GNUNET_free, GNUNET_malloc, GNUNET_OS_start_process_vap(), and ret.

Referenced by GNUNET_OS_command_run(), GNUNET_OS_start_process(), and run_process_and_wait().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_start_process_v()

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.

Parameters

std_inheritance	a set of GNUNET_OS_INHERIT_STD_* flags
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, including the process name as the first argument

Returns

pointer to process structure of the new process, NULL on error

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).
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 669 of file os_priority.c.

{
  return start_process (std_inheritance,
                        NULL,
                        NULL,
                        NULL,
                        lsocks,
                        filename,
                        argv);
}

References filename, and start_process().

Referenced by GNUNET_OS_process_status().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_start_process_s()

struct GNUNET_OS_Process* GNUNET_OS_start_process_s	(	enum GNUNET_OS_InheritStdioFlags	std_inheritance,
		const int *	lsocks,
		const char *	filename,
			...
	)

Start a process.

This function is similar to the GNUNET_OS_start_process_* except that the filename and arguments can have whole strings which contain the arguments. These arguments are to be separated by spaces and are parsed in the order they appear. Arguments containing spaces can be used by quoting them with ".

Parameters

std_inheritance	a set of GNUNET_OS_INHERIT_STD_* flags
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. It is valid to have the arguments in this string when they are separated by spaces.
...	more arguments. Should be of type char *. It is valid to have the arguments in these strings when they are separated by spaces. The last argument MUST be NULL.

Returns

pointer to process structure of the new process, NULL on error

Definition at line 702 of file os_priority.c.

{
  va_list ap;
  char **argv;
  unsigned int argv_size;
  const char *arg;
  const char *rpos;
  char *pos;
  char *cp;
  const char *last;
  struct GNUNET_OS_Process *proc;
  char *binary_path;
  int quote_on;
  unsigned int i;
  size_t len;
 
  argv_size = 1;
  va_start (ap, filename);
  arg = filename;
  last = NULL;
  do
  {
    rpos = arg;
    quote_on = 0;
    while ('\0' != *rpos)
    {
      if ('"' == *rpos)
      {
        if (1 == quote_on)
          quote_on = 0;
        else
          quote_on = 1;
      }
      if ((' ' == *rpos) && (0 == quote_on))
      {
        if (NULL != last)
          argv_size++;
        last = NULL;
        rpos++;
        while (' ' == *rpos)
          rpos++;
      }
      if ((NULL == last) && ('\0' != *rpos))     // FIXME: == or !=?
        last = rpos;
      if ('\0' != *rpos)
        rpos++;
    }
    if (NULL != last)
      argv_size++;
  }
  while (NULL != (arg = (va_arg (ap, const char *))));
  va_end (ap);
 
  argv = GNUNET_malloc (argv_size * sizeof(char *));
  argv_size = 0;
  va_start (ap, filename);
  arg = filename;
  last = NULL;
  do
  {
    cp = GNUNET_strdup (arg);
    quote_on = 0;
    pos = cp;
    while ('\0' != *pos)
    {
      if ('"' == *pos)
      {
        if (1 == quote_on)
          quote_on = 0;
        else
          quote_on = 1;
      }
      if ((' ' == *pos) && (0 == quote_on))
      {
        *pos = '\0';
        if (NULL != last)
          argv[argv_size++] = GNUNET_strdup (last);
        last = NULL;
        pos++;
        while (' ' == *pos)
          pos++;
      }
      if ((NULL == last) && ('\0' != *pos))     // FIXME: == or !=?
        last = pos;
      if ('\0' != *pos)
        pos++;
    }
    if (NULL != last)
      argv[argv_size++] = GNUNET_strdup (last);
    last = NULL;
    GNUNET_free (cp);
  }
  while (NULL != (arg = (va_arg (ap, const char *))));
  va_end (ap);
  argv[argv_size] = NULL;
 
  for (i = 0; i < argv_size; i++)
  {
    len = strlen (argv[i]);
    if ((argv[i][0] == '"') && (argv[i][len - 1] == '"'))
    {
      memmove (&argv[i][0], &argv[i][1], len - 2);
      argv[i][len - 2] = '\0';
    }
  }
  binary_path = argv[0];
  proc = GNUNET_OS_start_process_v (std_inheritance,
                                    lsocks,
                                    binary_path,
                                    argv);
  while (argv_size > 0)
    GNUNET_free_nz (argv[--argv_size]);
  GNUNET_free (argv);
  return proc;
}

Referenced by communicator_start(), GNUNET_TESTING_peer_start(), and start_process().

Here is the caller graph for this function:

GNUNET_OS_command_stop()

void GNUNET_OS_command_stop

(

struct GNUNET_OS_CommandHandle *

cmd

)

Stop/kill a command.

Parameters

cmd	handle to the process

Must ONLY be called either from the callback after 'NULL' was passed for 'line' OR from an independent task (not within the line processor).

Parameters

cmd	handle to the process

Definition at line 1018 of file os_priority.c.

{
  if (NULL != cmd->proc)
  {
    GNUNET_assert (NULL != cmd->rtask);
    GNUNET_SCHEDULER_cancel (cmd->rtask);
  }
  (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
  GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (cmd->eip));
  GNUNET_OS_process_destroy (cmd->eip);
  GNUNET_DISK_pipe_close (cmd->opipe);
  GNUNET_free (cmd);
}

References GNUNET_OS_CommandHandle::eip, GNUNET_assert, GNUNET_break, GNUNET_DISK_pipe_close(), GNUNET_free, GNUNET_OK, GNUNET_OS_process_destroy(), GNUNET_OS_process_kill(), GNUNET_OS_process_wait(), GNUNET_SCHEDULER_cancel(), GNUNET_OS_CommandHandle::opipe, GNUNET_OS_CommandHandle::proc, and GNUNET_OS_CommandHandle::rtask.

Referenced by do_refresh(), GNUNET_NAT_mini_map_stop(), process_map_output(), process_refresh_output(), and process_unmap_output().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_command_run()

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.

Parameters

proc	function to call for each line of the output
proc_cls	closure for proc
timeout	when to time out
binary	command to run
...	arguments to command

Returns

NULL on error

Definition at line 1092 of file os_priority.c.

{
  struct GNUNET_OS_CommandHandle *cmd;
  struct GNUNET_OS_Process *eip;
  struct GNUNET_DISK_PipeHandle *opipe;
  va_list ap;
 
  opipe = GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_RW);
  if (NULL == opipe)
    return NULL;
  va_start (ap, binary);
  /* redirect stdout, don't inherit stderr/stdin */
  eip =
    GNUNET_OS_start_process_va (GNUNET_OS_INHERIT_STD_NONE,
                                NULL,
                                opipe,
                                NULL,
                                binary,
                                ap);
  va_end (ap);
  if (NULL == eip)
  {
    GNUNET_DISK_pipe_close (opipe);
    return NULL;
  }
  GNUNET_DISK_pipe_close_end (opipe, GNUNET_DISK_PIPE_END_WRITE);
  cmd = GNUNET_new (struct GNUNET_OS_CommandHandle);
  cmd->timeout = GNUNET_TIME_relative_to_absolute (timeout);
  cmd->eip = eip;
  cmd->opipe = opipe;
  cmd->proc = proc;
  cmd->proc_cls = proc_cls;
  cmd->r = GNUNET_DISK_pipe_handle (opipe, GNUNET_DISK_PIPE_END_READ);
  cmd->rtask = GNUNET_SCHEDULER_add_read_file (timeout, cmd->r, &cmd_read, cmd);
  return cmd;
}

References cmd_read(), GNUNET_OS_CommandHandle::eip, GNUNET_DISK_PF_BLOCKING_RW, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_close_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_new, GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_start_process_va(), GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_relative_to_absolute(), GNUNET_OS_CommandHandle::opipe, GNUNET_OS_CommandHandle::proc, GNUNET_OS_CommandHandle::proc_cls, GNUNET_OS_CommandHandle::r, GNUNET_OS_CommandHandle::rtask, timeout, and GNUNET_OS_CommandHandle::timeout.

Referenced by do_refresh(), GNUNET_NAT_mini_map_stop(), and run_upnpc_r().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_process_status()

int GNUNET_OS_process_status	(	struct GNUNET_OS_Process *	proc,
		enum GNUNET_OS_ProcessStatusType *	type,
		unsigned long *	code
	)

Retrieve the status of a process.

Nonblocking version.

Parameters

proc	pointer to process structure
type	status type
code	return code/signal number

Returns

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

Nonblocking version.

Parameters

proc	process ID
type	status type
code	return code/signal number

Returns

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

Definition at line 702 of file os_priority.c.

{
  return process_status (proc, type, code, WNOHANG);
}

References find_typedefs::arg, filename, GNUNET_free, GNUNET_free_nz, GNUNET_malloc, GNUNET_OS_start_process_v(), GNUNET_strdup, and len.

Referenced by child_death_task(), habitability_check(), main(), maint_child_death(), and run_process_and_wait().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_process_wait()

int GNUNET_OS_process_wait

(

struct GNUNET_OS_Process *

proc

)

Wait for a process to terminate.

The return code is discarded. You must not use GNUNET_OS_process_status() on the same process after calling this function! This function is blocking and should thus only be used if the child process is known to have terminated or to terminate very soon.

Parameters

proc	pointer to process structure of the process to wait for

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

The return code is discarded. You must not use GNUNET_OS_process_status() on the same process after calling this function! This function is blocking and should thus only be used if the child process is known to have terminated or to terminate very soon.

Parameters

proc	pointer to process structure

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 942 of file os_priority.c.

{
  pid_t pid = proc->pid;
  pid_t ret;
 
  while ((pid != (ret = waitpid (pid, NULL, 0))) && (EINTR == errno))
    ;
  if (pid != ret)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_OK, GNUNET_SYSERR, LOG_STRERROR, pid, GNUNET_OS_Process::pid, and ret.

Referenced by GN_stop_gnunet_nat_server_(), GNUNET_HELPER_wait(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_stop(), GNUNET_TESTBED_is_host_habitable_cancel(), GNUNET_TESTING_peer_wait(), nat_server_read(), netjail_start_cleanup(), netjail_stop_cleanup(), run_process_and_wait(), shutdown_task(), and stop_shared_service_instance().

Here is the caller graph for this function:

GNUNET_OS_process_wait_status()

int 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.

Blocking version.

Parameters

proc	pointer to process structure
type	status type
code	return code/signal number

Returns

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

Blocking version.

Parameters

proc	pointer to process structure
type	status type
code	return code/signal number

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 702 of file os_priority.c.

{
  return process_status (proc, type, code, 0);
}

GNUNET_OS_install_parent_control_handler()

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.

Parameters

cls	closure (unused)

Definition at line 133 of file os_priority.c.

{
  const char *env_buf;
  char *env_buf_end;
  struct GNUNET_DISK_FileHandle *control_pipe;
  uint64_t pipe_fd;
 
  (void) cls;
  if (NULL != pch)
  {
    /* already done, we've been called twice... */
    GNUNET_break (0);
    return;
  }
  env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
  if ((NULL == env_buf) || (strlen (env_buf) <= 0))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Not installing a handler because $%s is empty\n",
         GNUNET_OS_CONTROL_PIPE);
    putenv (GNUNET_OS_CONTROL_PIPE "=");
    return;
  }
  errno = 0;
  pipe_fd = strtoull (env_buf, &env_buf_end, 16);
  if ((0 != errno) || (env_buf == env_buf_end))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf);
    putenv (GNUNET_OS_CONTROL_PIPE "=");
    return;
  }
  if (pipe_fd >= FD_SETSIZE)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
         env_buf);
    putenv (GNUNET_OS_CONTROL_PIPE "=");
    return;
  }
 
  control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd);
 
  if (NULL == control_pipe)
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
    putenv (GNUNET_OS_CONTROL_PIPE "=");
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Adding parent control handler pipe `%s' to the scheduler\n",
       env_buf);
  pch = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                        control_pipe,
                                        &parent_control_handler,
                                        control_pipe);
  spch = GNUNET_SCHEDULER_add_shutdown (&shutdown_pch, control_pipe);
  putenv (GNUNET_OS_CONTROL_PIPE "=");
}

References getenv(), GNUNET_break, GNUNET_DISK_get_handle_from_int_fd(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_OS_CONTROL_PIPE, GNUNET_SCHEDULER_add_read_file(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, LOG_STRERROR_FILE, parent_control_handler(), pch, shutdown_pch(), and spch.

Referenced by install_parent_control_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_OS_check_helper_binary()

enum GNUNET_GenericReturnValue GNUNET_OS_check_helper_binary	(	const char *	binary,
		bool	check_suid,
		const char *	params
	)

Check whether an executable exists and possibly if the suid bit is set on the file.

Attempts to find the file using the current PATH environment variable as a search path.

Parameters

binary	the name of the file to check. W32: must not have an .exe suffix.
check_suid	input true if the binary should be checked for SUID (*nix) W32: checks if the program has sufficient privileges by executing this binary with the -d flag. -d omits a programs main loop and only executes all privileged operations in an binary.
params	parameters used for w32 privilege checking (can be NULL for != w32, or when not checking for suid/permissions )

Returns

GNUNET_YES if the file is SUID (*nix) or can be executed with current privileges (W32), GNUNET_NO if not SUID (but binary exists), GNUNET_SYSERR on error (no such binary or not executable)

Definition at line 719 of file os_installation.c.

{
  struct stat statbuf;
  char *p;
  char *pf;
 
  if ((GNUNET_YES ==
       GNUNET_STRINGS_path_is_absolute (binary, GNUNET_NO, NULL, NULL)) ||
      (0 == strncmp (binary, "./", 2)))
  {
    p = GNUNET_strdup (binary);
  }
  else
  {
    p = get_path_from_PATH (binary);
    if (NULL != p)
    {
      GNUNET_asprintf (&pf, "%s/%s", p, binary);
      GNUNET_free (p);
      p = pf;
    }
  }
 
  if (NULL == p)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ ("Could not find binary `%s' in PATH!\n"),
         binary);
    return GNUNET_SYSERR;
  }
  if (0 != access (p, X_OK))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", p);
    GNUNET_free (p);
    return GNUNET_SYSERR;
  }
 
  if (0 == getuid ())
  {
    /* as we run as root, we don't insist on SUID */
    GNUNET_free (p);
    return GNUNET_YES;
  }
 
  if (0 != stat (p, &statbuf))
  {
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", p);
    GNUNET_free (p);
    return GNUNET_SYSERR;
  }
  if (check_suid)
  {
    (void) params;
    if ((0 != (statbuf.st_mode & S_ISUID)) && (0 == statbuf.st_uid))
    {
      GNUNET_free (p);
      return GNUNET_YES;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("Binary `%s' exists, but is not SUID\n"),
                p);
    /* binary exists, but not SUID */
  }
  GNUNET_free (p);
  return GNUNET_NO;
}

References cache, cfg, DIR_SEPARATOR, DIR_SEPARATOR_STR, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_NO, GNUNET_OS_get_libexec_binary_path(), GNUNET_strdup, GNUNET_STRINGS_path_is_absolute(), and GNUNET_YES.

Referenced by GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_NAT_mini_map_start(), handle_autoconfig_request(), netjail_stop_run(), restart_nat_server(), run(), start_helper(), start_process(), test_icmp_client(), test_icmp_server(), and test_upnpc().

Here is the call graph for this function:

Here is the caller graph for this function: