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...
struct	GNUNET_ProcessOptionValue
	Possible options we can set for a process. More...

Macros
#define	GNUNET_OS_get_hostname_max_length()   255
	Get maximum string length returned by gethostname()
#define	GNUNET_PROCESS_OPTIONS_ARRAY_MAX_SIZE   32
	Maximum number of process options we can set in one pass.
#define	GNUNET_process_option_end_()
	Terminate the list of the options.
#define	GNUNET_process_option_set_environment(k, v)
	Set environment variable in child process.
#define	GNUNET_process_option_inherit_fd(p, c)
	Have child process inherit a file descriptor.
#define	GNUNET_process_option_inherit_rpipe(rpipe, child_fd)
	Have child process inherit a pipe for reading.
#define	GNUNET_process_option_inherit_wpipe(wpipe, child_fd)
	Have child process inherit a pipe for writing.
#define	GNUNET_process_option_inherit_lsock(lsock)
	Pass listen socket to child systemd-style.
#define	GNUNET_process_set_options(proc, ...)
	Set the requested options for the process.

Typedefs
typedef enum GNUNET_GenericReturnValue(*	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.
typedef void(*	GNUNET_OS_LineProcessor) (void *cls, const char *line)
	Type of a function to process a line of output.

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...
enum	GNUNET_ProcessOption { GNUNET_PROCESS_OPTION_END = 0 , GNUNET_PROCESS_OPTION_SET_ENVIRONMENT = 1 , GNUNET_PROCESS_OPTION_INHERIT_FD = 2 , GNUNET_PROCESS_OPTION_INHERIT_LSOCK = 3 }
	Possible options we can set for a process. More...

Functions
const struct GNUNET_OS_ProjectData *	GNUNET_OS_project_data_gnunet (void)
	Return default project data used by 'libgnunetutil' for GNUnet.
void	GNUNET_OS_init (const char *package_name, const struct GNUNET_OS_ProjectData *pd)
	Setup OS subsystem for the given project data and package.
char *	GNUNET_OS_installation_get_path (const struct GNUNET_OS_ProjectData *pd, 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.
char *	GNUNET_OS_get_libexec_binary_path (const struct GNUNET_OS_ProjectData *pd, 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.
char *	GNUNET_OS_get_suid_binary_path (const struct GNUNET_OS_ProjectData *pd, 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.
void	GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
	Enumerate all network interfaces.
void	GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
	Stop/kill a command.
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.
struct GNUNET_Process *	GNUNET_process_create (enum GNUNET_OS_InheritStdioFlags std_inheritance)
	Create a process handle.
enum GNUNET_GenericReturnValue	GNUNET_process_run_command_ap (struct GNUNET_Process *p, const char *filename, va_list va)
	Set the command and start a process.
enum GNUNET_GenericReturnValue	GNUNET_process_run_command_argv (struct GNUNET_Process *p, const char *filename, const char **argv)
	Set the command and start a process.
enum GNUNET_GenericReturnValue	GNUNET_process_run_command_va (struct GNUNET_Process *p, const char *filename,...)
	Set the command and start a process.
enum GNUNET_GenericReturnValue	GNUNET_process_run_command (struct GNUNET_Process *p, const char *command)
	Set the command and start a process.
enum GNUNET_GenericReturnValue	GNUNET_process_set_options_ (struct GNUNET_Process *proc, unsigned int num_options, const struct GNUNET_ProcessOptionValue options[])
	Set the requested options for the process.
enum GNUNET_GenericReturnValue	GNUNET_process_wait (struct GNUNET_Process *proc, bool blocking, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
	Wait for a process to terminate.
void	GNUNET_process_destroy (struct GNUNET_Process *proc)
	Cleans up process structure contents (OS-dependent) and deallocates it.
pid_t	GNUNET_process_get_pid (const struct GNUNET_Process *proc)
	Get the pid of the process in question.
enum GNUNET_GenericReturnValue	GNUNET_process_kill (struct GNUNET_Process *proc, int sig)
	Sends a signal to the process.
struct GNUNET_Process *	GNUNET_process_current (void)
	Get process structure for current process.
void	GNUNET_process_install_parent_control_handler (void)
	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.
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.
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.

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 418 of file gnunet_os_lib.h.

GNUNET_PROCESS_OPTIONS_ARRAY_MAX_SIZE

#define GNUNET_PROCESS_OPTIONS_ARRAY_MAX_SIZE   32

Maximum number of process options we can set in one pass.

Definition at line 588 of file gnunet_os_lib.h.

GNUNET_process_option_end_

#define GNUNET_process_option_end_

(

)

Value:

        (const struct GNUNET_ProcessOptionValue) \
        {                                        \
          .option = GNUNET_PROCESS_OPTION_END    \
        }

Terminate the list of the options.

Returns

the terminating object of struct GNUNET_ProcessOptionValue

Definition at line 659 of file gnunet_os_lib.h.

        {                                        \
          .option = GNUNET_PROCESS_OPTION_END    \
        }

GNUNET_process_option_set_environment

#define GNUNET_process_option_set_environment	(		k,
			v
	)

Value:

        (const struct GNUNET_ProcessOptionValue)           \
        {                                                  \
          .option = GNUNET_PROCESS_OPTION_SET_ENVIRONMENT, \
          .details.set_environment.key = k,                \
          .details.set_environment.value = v               \
        }

Set environment variable in child process.

Parameters

k	name of the variable
v	value to set, NULL to clear

Returns

the option

Definition at line 672 of file gnunet_os_lib.h.

        {                                                  \
          .option = GNUNET_PROCESS_OPTION_SET_ENVIRONMENT, \
          .details.set_environment.key = k,                \
          .details.set_environment.value = v               \
        }

GNUNET_process_option_inherit_fd

#define GNUNET_process_option_inherit_fd	(		p,
			c
	)

Value:

        (const struct GNUNET_ProcessOptionValue)               \
        {                                                      \
          .option = GNUNET_PROCESS_OPTION_INHERIT_FD,          \
          .details.inherit_fd.target_fd = c,                   \
          .details.inherit_fd.parent_fd = p                    \
        }

Have child process inherit a file descriptor.

The ownership over the file descriptor is afterwards with the process handle.

Parameters

p	open file descriptor in this process
c	target file descriptor in the child process

Returns

the terminating object of struct GNUNET_ProcessOptionValue

Definition at line 689 of file gnunet_os_lib.h.

        {                                                      \
          .option = GNUNET_PROCESS_OPTION_INHERIT_FD,          \
          .details.inherit_fd.target_fd = c,                   \
          .details.inherit_fd.parent_fd = p                    \
        }

GNUNET_process_option_inherit_rpipe

#define GNUNET_process_option_inherit_rpipe	(		rpipe,
			child_fd
	)

Value:

        (const struct GNUNET_ProcessOptionValue)               \
        {                                                      \
          .option = GNUNET_PROCESS_OPTION_INHERIT_FD,          \
          .details.inherit_fd.target_fd = child_fd,            \
          .details.inherit_fd.parent_fd                        \
            = GNUNET_DISK_internal_file_handle (               \
                GNUNET_DISK_pipe_detach_end (rpipe,            \
                                             GNUNET_DISK_PIPE_END_READ)) \
        }

Have child process inherit a pipe for reading.

The read-end is detached from the pipe.

Parameters

rpipe	open pipe in this process the child should read from
child_fd	target file descriptor in the child process

Returns

the terminating object of struct GNUNET_ProcessOptionValue

Definition at line 705 of file gnunet_os_lib.h.

        {                                                      \
          .option = GNUNET_PROCESS_OPTION_INHERIT_FD,          \
          .details.inherit_fd.target_fd = child_fd,            \
          .details.inherit_fd.parent_fd                        \
            = GNUNET_DISK_internal_file_handle (               \
                GNUNET_DISK_pipe_detach_end (rpipe,            \
                                             GNUNET_DISK_PIPE_END_READ)) \
        }

GNUNET_process_option_inherit_wpipe

#define GNUNET_process_option_inherit_wpipe	(		wpipe,
			child_fd
	)

Value:

        (const struct GNUNET_ProcessOptionValue)               \
        {                                                      \
          .option = GNUNET_PROCESS_OPTION_INHERIT_FD,          \
          .details.inherit_fd.target_fd = child_fd,            \
          .details.inherit_fd.parent_fd \
            = GNUNET_DISK_internal_file_handle ( \
                GNUNET_DISK_pipe_detach_end (wpipe, \
                                             GNUNET_DISK_PIPE_END_WRITE)) \
        }

Have child process inherit a pipe for writing.

The write-end is detached from the pipe.

Parameters

wpipe	open pipe in this process the child should write to
child_fd	target file descriptor in the child process

Returns

the terminating object of struct GNUNET_ProcessOptionValue

Definition at line 724 of file gnunet_os_lib.h.

        {                                                      \
          .option = GNUNET_PROCESS_OPTION_INHERIT_FD,          \
          .details.inherit_fd.target_fd = child_fd,            \
          .details.inherit_fd.parent_fd \
            = GNUNET_DISK_internal_file_handle ( \
                GNUNET_DISK_pipe_detach_end (wpipe, \
                                             GNUNET_DISK_PIPE_END_WRITE)) \
        }

GNUNET_process_option_inherit_lsock

#define GNUNET_process_option_inherit_lsock

(

lsock

)

Value:

        (const struct GNUNET_ProcessOptionValue)          \
        {                                                 \
          .option = GNUNET_PROCESS_OPTION_INHERIT_LSOCK,  \
          .details.inherit_lsock = lsock                  \
        }

Pass listen socket to child systemd-style.

The ownership over the file descriptor remains with the caller!

Parameters

lsock

open listen socket to pass to the child

Returns

the option

Definition at line 743 of file gnunet_os_lib.h.

        {                                                 \
          .option = GNUNET_PROCESS_OPTION_INHERIT_LSOCK,  \
          .details.inherit_lsock = lsock                  \
        }

GNUNET_process_set_options

#define GNUNET_process_set_options	(		proc,
			...
	)

Value:

        GNUNET_process_set_options_ (                     \
          proc,                                           \
          GNUNET_PROCESS_OPTIONS_ARRAY_MAX_SIZE,          \
          ((const struct GNUNET_ProcessOptionValue[])     \
           {__VA_ARGS__, GNUNET_process_option_end_ () }  \
          ))

Set the requested options for the process.

If any option fail other options may be or may be not applied.

It should be used with helpers that creates required options, for example:

GNUNET_process_set_options ( proc, GNUNET_process_option_std_inheritance_(si));

Parameters

proc	the process to set the options for
...	the list of the options, each option must be created by helpers GNUNET_process_option_NAME(VALUE)

Returns

GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR on internal error

Definition at line 789 of file gnunet_os_lib.h.

           {__VA_ARGS__, GNUNET_process_option_end_ () }  \
          ))

Typedef Documentation

GNUNET_OS_NetworkInterfaceProcessor

typedef enum GNUNET_GenericReturnValue(* 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 367 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 434 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 74 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 121 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 176 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
};

GNUNET_ProcessOption

enum GNUNET_ProcessOption

Possible options we can set for a process.

Enumerator
GNUNET_PROCESS_OPTION_END	End of list of options.
GNUNET_PROCESS_OPTION_SET_ENVIRONMENT	Option to set environment variables.
GNUNET_PROCESS_OPTION_INHERIT_FD	Option to inherit file descriptors.
GNUNET_PROCESS_OPTION_INHERIT_LSOCK	Option to inherit a listen socket systemd-style.

Definition at line 561 of file gnunet_os_lib.h.

{
  GNUNET_PROCESS_OPTION_END = 0,
 
  GNUNET_PROCESS_OPTION_SET_ENVIRONMENT = 1,
 
  GNUNET_PROCESS_OPTION_INHERIT_FD = 2,
 
  GNUNET_PROCESS_OPTION_INHERIT_LSOCK = 3
};

Function Documentation

GNUNET_OS_project_data_gnunet()

const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_gnunet

(

void

)

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

Definition at line 82 of file os_installation.c.

{
  return &default_pd;
}

References default_pd.

Referenced by auto_config_cb(), client_connect_cb(), communicator_start(), create_unique_cfgs(), enable(), enable(), GN_request_connection_reversal(), GNUNET_CADET_open_port(), GNUNET_FS_directory_scan_start(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(), handle_auto_result(), handle_autoconfig_request(), handle_helper_init(), init(), init(), init(), iter_check_config(), load_member(), load_member_session(), load_member_session_next(), load_operation(), load_plugin(), main(), main(), main(), netjail_start_run(), restart_nat_server(), return_agpl(), run(), run(), run(), run(), run(), run(), run(), run(), run(), run(), save_member(), save_member_session(), save_operation(), service_start(), set_cont(), start_arm_service(), start_helper(), start_peer_run(), start_process(), and transport_communicator_start().

Here is the caller graph for this function:

GNUNET_OS_init()

void GNUNET_OS_init	(	const char *	package_name,
		const struct GNUNET_OS_ProjectData *	pd
	)

Setup OS subsystem for the given project data and package.

Initializes GNU Gettext.

Parameters

package_name	name of the package for GNU gettext
pd	project data to use to determine paths

Definition at line 89 of file os_installation.c.

{
  char *path;
 
  path = GNUNET_OS_installation_get_path (pd,
                                          GNUNET_OS_IPK_LOCALEDIR);
  if (NULL != path)
    bindtextdomain (package_name,
                    path);
  GNUNET_free (path);
}

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

Here is the call graph for this function:

GNUNET_OS_installation_get_path()

char * GNUNET_OS_installation_get_path	(	const struct GNUNET_OS_ProjectData *	pd,
		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

pd	project data to use to determine paths
dirkind	what kind of directory is desired?

Returns

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

Definition at line 434 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 (pd);
 
  /* 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 (pd);
  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,
                       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,
                         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,
                         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,
                     pd->project_dirname);
    break;
 
  case GNUNET_OS_IPK_DATADIR:
    GNUNET_asprintf (&dirname,
                     DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR
                     "%s" DIR_SEPARATOR_STR,
                     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,
                     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,
                       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,
                                      true))
      {
        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,
                         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,
                         pd->project_dirname);
        GNUNET_asprintf (&tmp,
                         "%s%s",
                         execpath,
                         dirname);
      }
      if ((NULL != tmp) &&
          (GNUNET_YES ==
           GNUNET_DISK_directory_test (tmp,
                                       true)))
      {
        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,
                     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 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 dump_os_ipk(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_load(), GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_init(), GNUNET_PLUGIN_load_all(), GNUNET_PROGRAM_run2(), GNUNET_SERVICE_run_(), main(), netjail_start_run(), open_library(), run(), run(), 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 struct GNUNET_OS_ProjectData *	pd,
		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

pd	project data to use to determine paths
progname	name of the binary

Returns

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

Definition at line 681 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 (pd,
                                                  GNUNET_OS_IPK_LIBEXECDIR);
  if (NULL == libexecdir)
    return GNUNET_strdup (progname);
  GNUNET_asprintf (&binary,
                   "%s%s",
                   libexecdir,
                   progname);
  cache = libexecdir;
  return binary;
}

References 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_get_suid_binary_path(), service_start(), start_arm_service(), start_helper(), start_peer_run(), start_process(), test_icmp_client(), and test_icmp_server().

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_OS_ProjectData *	pd,
		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

pd	project data to use to determine paths
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 712 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 (pd,
                                              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;
}

References 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 GN_request_connection_reversal(), restart_nat_server(), run(), run(), and run().

Here is the call graph for this function:

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(), run_scan(), scan(), and test_local_ip().

Here is the call graph for this function:

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

Definition at line 224 of file os_priority.c.

{
  if (NULL != cmd->proc)
  {
    GNUNET_assert (NULL != cmd->rtask);
    GNUNET_SCHEDULER_cancel (cmd->rtask);
  }
  GNUNET_break (GNUNET_OK ==
                GNUNET_process_kill (cmd->eip,
                                     SIGKILL));
  GNUNET_break (GNUNET_OK ==
                GNUNET_process_wait (cmd->eip,
                                     true,
                                     NULL,
                                     NULL));
  GNUNET_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_process_destroy(), GNUNET_process_kill(), GNUNET_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 306 of file os_priority.c.

{
  struct GNUNET_OS_CommandHandle *cmd;
  struct GNUNET_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_process_create (GNUNET_OS_INHERIT_STD_NONE);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_process_set_options (
                   eip,
                   GNUNET_process_option_inherit_wpipe (opipe,
                                                        STDOUT_FILENO)));
  if (GNUNET_OK !=
      GNUNET_process_run_command_ap (eip,
                                     binary,
                                     ap))
  {
    GNUNET_process_destroy (eip);
    va_end (ap);
    GNUNET_DISK_pipe_close (opipe);
    return NULL;
  }
  va_end (ap);
  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_assert, 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_OK, GNUNET_OS_INHERIT_STD_NONE, GNUNET_process_create(), GNUNET_process_destroy(), GNUNET_process_option_inherit_wpipe, GNUNET_process_run_command_ap(), GNUNET_process_set_options, GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_relative_to_absolute(), GNUNET_OS_CommandHandle::off, 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_process_create()

struct GNUNET_Process * GNUNET_process_create

(

enum GNUNET_OS_InheritStdioFlags

std_inheritance

)

Create a process handle.

Does not yet start it!

Returns

process handle

Definition at line 462 of file os_process.c.

{
  struct GNUNET_Process *p;
 
  p = GNUNET_new (struct GNUNET_Process);
  p->pid = -1;
  p->std_inheritance = std_inheritance;
  return p;
}

References GNUNET_new, p, GNUNET_Process::pid, and GNUNET_Process::std_inheritance.

Referenced by communicator_start(), exec_bash_script_run(), GN_request_connection_reversal(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_OS_command_run(), GNUNET_PQ_exec_sql(), handle_uri(), netjail_start_run(), restart_nat_server(), run(), run(), service_start(), start_arm_service(), start_helper(), start_peer_run(), start_process(), and work().

Here is the caller graph for this function:

GNUNET_process_run_command_ap()

enum GNUNET_GenericReturnValue GNUNET_process_run_command_ap	(	struct GNUNET_Process *	p,
		const char *	filename,
		va_list	va
	)

Set the command and start a process.

Client must pass the filename and arguments. Can only be called once per struct GNUNET_Process. Should be called after setting options (if there are any).

Parameters

[in,out]	p	process handle for the process to setup
	filename	name of the binary. It is valid to have the arguments in this string when they are separated by spaces.
	va	process arguments, usually including filename as argv[0] again. Should all be of type const char *. The last argument MUST be NULL.

Returns

GNUNET_OK on success

Definition at line 866 of file os_process.c.

{
  va_list ap;
  const char *av;
  int argc;
 
  if (GNUNET_SYSERR ==
      GNUNET_OS_check_helper_binary (filename,
                                     GNUNET_NO,
                                     NULL))
    return GNUNET_SYSERR; /* not executable */
  GNUNET_assert (NULL == p->argv);
  p->filename = GNUNET_strdup (filename);
  argc = 0;
  va_copy (ap,
           va);
  while (NULL != va_arg (ap,
                         const char *))
    argc++;
  va_end (ap);
  p->argv = GNUNET_new_array (argc + 1,
                              char *);
  argc = 0;
  va_copy (ap,
           va);
  while (NULL != (av = va_arg (ap,
                               const char *)))
    p->argv[argc++] = GNUNET_strdup (av);
  va_end (ap);
  return process_start (p);
}

References GNUNET_Process::argv, filename, GNUNET_Process::filename, GNUNET_assert, GNUNET_new_array, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_strdup, GNUNET_SYSERR, p, and process_start().

Referenced by GNUNET_OS_command_run(), and GNUNET_process_run_command_va().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_process_run_command_argv()

enum GNUNET_GenericReturnValue GNUNET_process_run_command_argv	(	struct GNUNET_Process *	p,
		const char *	filename,
		const char **	argv
	)

Set the command and start a process.

Client must pass the filename and arguments. Can only be called once per struct GNUNET_Process. Should be called after setting options (if there are any).

Parameters

[in,out]	p	process handle for the process to setup
	filename	name of the binary. It is valid to have the arguments in this string when they are separated by spaces.
	argv	process arguments, array MUST be NULL-terminated

Returns

GNUNET_OK on success

Definition at line 840 of file os_process.c.

{
  int argc;
 
  if (GNUNET_SYSERR ==
      GNUNET_OS_check_helper_binary (filename,
                                     GNUNET_NO,
                                     NULL))
    return GNUNET_SYSERR; /* not executable */
  GNUNET_assert (NULL == p->argv);
  p->filename = GNUNET_strdup (filename);
  argc = 0;
  while (NULL != argv[argc])
    argc++;
  p->argv = GNUNET_new_array (argc + 1,
                              char *);
  for (argc = 0; NULL != argv[argc]; argc++)
    p->argv[argc] = GNUNET_strdup (argv[argc]);
  return process_start (p);
}

References GNUNET_Process::argv, filename, GNUNET_Process::filename, GNUNET_assert, GNUNET_new_array, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_strdup, GNUNET_SYSERR, p, and process_start().

Referenced by exec_bash_script_run(), start_helper(), and work().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_process_run_command_va()

enum GNUNET_GenericReturnValue GNUNET_process_run_command_va	(	struct GNUNET_Process *	p,
		const char *	filename,
			...
	)

Set the command and start a process.

Client must pass the filename and arguments. Can only be called once per struct GNUNET_Process. Should be called after setting options (if there are any).

Parameters

[in,out]	p	process handle for the process to setup
	filename	name of the binary. It is valid to have the arguments in this string when they are separated by spaces.
	...	the process arguments, usually including filename as argv[0] again. Should all be of type const char *. The last argument MUST be NULL.

Returns

GNUNET_OK on success

Definition at line 903 of file os_process.c.

{
  enum GNUNET_GenericReturnValue ret;
  va_list ap;
 
  va_start (ap,
            filename);
  ret = GNUNET_process_run_command_ap (p,
                                       filename,
                                       ap);
  va_end (ap);
  return ret;
}

References filename, GNUNET_process_run_command_ap(), p, and ret.

Referenced by communicator_start(), GN_request_connection_reversal(), GNUNET_PQ_exec_sql(), netjail_start_run(), restart_nat_server(), run(), run(), service_start(), start_peer_run(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_process_run_command()

enum GNUNET_GenericReturnValue GNUNET_process_run_command	(	struct GNUNET_Process *	p,
		const char *	command
	)

Set the command and start a process.

Client must pass the full command, which must include the filename and arguments. Can only be called once per struct GNUNET_Process. Should be called after setting options (if there are any).

Parameters

[in,out]	p	process handle for the process to setup
	command	the command-line to run; quoting with '"' is supported to not separate arguments on whitespace; similarly, you can use '"' to escape quotes

Returns

GNUNET_OK on success

Definition at line 921 of file os_process.c.

{
  char *cmd = GNUNET_strdup (command);
  size_t len = strlen (command);
  size_t cnt = 1;
  size_t start = 0;
  bool quote_on = false;
  size_t i;
  size_t skip = 0;
 
  GNUNET_assert (NULL == p->argv);
  for (i=0; i<len; i++)
  {
    char c = cmd[i];
 
    switch (c)
    {
    case '"':
      quote_on = ! quote_on;
      break;
    case '\\':
      i++;
      break;
    case ' ':
      if (! quote_on)
        cnt++;
      while (' ' == cmd[i + 1])
        i++;
      break;
    }
  }
 
  p->argv = GNUNET_new_array (cnt + 1,
                              char *);
  cnt = 0;
  for (i=0; i<len; i++)
  {
    char c = cmd[i];
 
    switch (c)
    {
    case '"':
      quote_on = ! quote_on;
      skip++;
      break;
    case ' ':
      if ( (! quote_on) &&
           (i != start) )
      {
        p->argv[cnt] = GNUNET_strndup (&cmd[start],
                                       i - start - skip);
        cnt++;
        skip = 0;
      }
      while (' ' == cmd[i + 1])
        i++;
      if (! quote_on)
        start = i + 1;
      break;
    case '\\':
      i++;
      skip++;
      cmd[i - skip] = cmd[i];
      break;
    default:
      cmd[i - skip] = c;
      break;
    }
  }
  if (i != start)
    p->argv[cnt] = GNUNET_strndup (&cmd[start],
                                   i - start);
  GNUNET_free (cmd);
  if (quote_on)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Cmd `%s' has imbalanced quotes\n",
                cmd);
  }
  if (NULL == p->argv[0])
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Empty command specified, cannot execute\n");
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR ==
      GNUNET_OS_check_helper_binary (p->argv[0],
                                     GNUNET_NO,
                                     NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Specified binary `%s' is not executable\n",
                p->argv[0]);
    return GNUNET_SYSERR;
  }
  p->filename = GNUNET_strdup (p->argv[0]);
  return process_start (p);
}

References GNUNET_Process::argv, GNUNET_Process::filename, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_new_array, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_strdup, GNUNET_strndup, GNUNET_SYSERR, p, process_start(), and start.

Referenced by GNUNET_NAT_mini_get_external_ipv4_(), handle_uri(), start_arm_service(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_process_set_options_()

enum GNUNET_GenericReturnValue GNUNET_process_set_options_	(	struct GNUNET_Process *	proc,
		unsigned int	num_options,
		const struct GNUNET_ProcessOptionValue	options[]
	)

Set the requested options for the process.

If any option fail other options may be or may be not applied. Options must be set before calling the "GNUNET_process_run_command()" family of functions.

Parameters

[in,out]	proc	the process to set the options for
	num_options	maximum length of the options array
	options	array of options, possibly terminated early

Returns

GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR on internal error

Definition at line 1023 of file os_process.c.

{
  for (unsigned int i=0; i<num_options; i++)
  {
    const struct GNUNET_ProcessOptionValue *ov = &options[i];
 
    switch (ov->option)
    {
    case GNUNET_PROCESS_OPTION_END:
      return GNUNET_OK;
    case GNUNET_PROCESS_OPTION_SET_ENVIRONMENT:
      {
        struct EnviEntry ee = {
          .key = GNUNET_strdup (ov->details.set_environment.key)
        };
 
        if (NULL != ov->details.set_environment.value)
          ee.value = GNUNET_strdup (ov->details.set_environment.value);
        GNUNET_array_append (proc->envs,
                             proc->envs_size,
                             ee);
      }
      continue;
    case GNUNET_PROCESS_OPTION_INHERIT_FD:
      {
        struct ProcessFileMapEntry pme = {
          .target_fd = ov->details.inherit_fd.target_fd,
          .parent_fd = ov->details.inherit_fd.parent_fd,
          .owned = true
        };
 
        GNUNET_array_append (proc->map,
                             proc->map_size,
                             pme);
      }
      continue;
    case GNUNET_PROCESS_OPTION_INHERIT_LSOCK:
      {
        struct ProcessFileMapEntry pme = {
          .target_fd = -1, /* any */
          .parent_fd = ov->details.inherit_lsock,
          .systemd_listen_socket = true,
          .owned = false
        };
 
        GNUNET_array_append (proc->map,
                             proc->map_size,
                             pme);
      }
      continue;
    }
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_ProcessOptionValue::details, GNUNET_Process::envs, GNUNET_Process::envs_size, GNUNET_array_append, GNUNET_break, GNUNET_OK, GNUNET_PROCESS_OPTION_END, GNUNET_PROCESS_OPTION_INHERIT_FD, GNUNET_PROCESS_OPTION_INHERIT_LSOCK, GNUNET_PROCESS_OPTION_SET_ENVIRONMENT, GNUNET_strdup, GNUNET_SYSERR, GNUNET_ProcessOptionValue::inherit_fd, GNUNET_ProcessOptionValue::inherit_lsock, GNUNET_ProcessOptionValue::key, EnviEntry::key, GNUNET_Process::map, GNUNET_Process::map_size, GNUNET_ProcessOptionValue::option, options, GNUNET_ProcessOptionValue::parent_fd, GNUNET_ProcessOptionValue::set_environment, GNUNET_ProcessOptionValue::target_fd, ProcessFileMapEntry::target_fd, GNUNET_ProcessOptionValue::value, and EnviEntry::value.

GNUNET_process_wait()

enum GNUNET_GenericReturnValue GNUNET_process_wait	(	struct GNUNET_Process *	proc,
		bool	blocking,
		enum GNUNET_OS_ProcessStatusType *	type,
		unsigned long *	code
	)

Wait for a process to terminate.

Retrieve the status of a process. This function may be called repeatedly, it will always return the last status of the process.

Parameters

	proc	pointer to process structure
	blocking	true to wait for the process to terminate
[out]	type	set to process status type
[out]	code	return code/signal number

Returns

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

Definition at line 1085 of file os_process.c.

{
  pid_t ret;
  int status;
 
  if (-1 == proc->pid)
  {
    if (NULL != type)
      *type = proc->exit_type;
    if (NULL != code)
      *code = proc->exit_code;
    return GNUNET_OK;
  }
  while (proc->pid !=
         (ret = waitpid (proc->pid,
                         &status,
                         blocking ? 0 : WNOHANG)))
  {
    if ( (! blocking) &&
         (EINTR == errno) )
    {
      ret = 0;
      break;
    }
    if (EINTR != errno)
      break;
  }
  if (0 == ret)
  {
    if (NULL != type)
      *type = GNUNET_OS_PROCESS_RUNNING;
    if (NULL != code)
      *code = 0;
    return GNUNET_NO;
  }
#ifdef WIFCONTINUED
  if ( (proc->pid == ret) &&
       (WIFCONTINUED (status)) )
  {
    if (NULL != type)
      *type = GNUNET_OS_PROCESS_RUNNING;
    if (NULL != code)
      *code = 0;
    return GNUNET_NO;
  }
#endif
  if (proc->pid != ret)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "waitpid");
    return GNUNET_SYSERR;
  }
  /* process did exit! */
  proc->pid = -1;
  if (WIFEXITED (status))
  {
    proc->exit_type = GNUNET_OS_PROCESS_EXITED;
    proc->exit_code = WEXITSTATUS (status);
  }
  else if (WIFSIGNALED (status))
  {
    proc->exit_type = GNUNET_OS_PROCESS_SIGNALED;
    proc->exit_code = WTERMSIG (status);
  }
  else if (WIFSTOPPED (status))
  {
    proc->exit_type = GNUNET_OS_PROCESS_SIGNALED;
    proc->exit_code = WSTOPSIG (status);
  }
  else
  {
    proc->exit_type = GNUNET_OS_PROCESS_UNKNOWN;
    proc->exit_code = 0;
  }
  if (NULL != type)
    *type = proc->exit_type;
  if (NULL != code)
    *code = proc->exit_code;
  return GNUNET_OK;
}

References GNUNET_Process::exit_code, GNUNET_Process::exit_type, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_OK, GNUNET_OS_PROCESS_EXITED, GNUNET_OS_PROCESS_RUNNING, GNUNET_OS_PROCESS_SIGNALED, GNUNET_OS_PROCESS_UNKNOWN, GNUNET_SYSERR, LOG_STRERROR, GNUNET_Process::pid, ret, status, and type.

Referenced by exec_bash_script_cleanup(), GN_request_connection_reversal(), GN_stop_gnunet_nat_server_(), GNUNET_HELPER_wait(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_stop(), GNUNET_PQ_exec_sql(), maint_child_death(), maint_child_death(), maint_child_death(), maint_child_death(), nat_server_read(), netjail_start_cleanup(), run(), shutdown_process(), and start_peer_cleanup().

Here is the caller graph for this function:

GNUNET_process_destroy()

void GNUNET_process_destroy

(

struct GNUNET_Process *

proc

)

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

Does NOT kill a running process.

Parameters

[in]

proc

pointer to process structure

Definition at line 363 of file os_process.c.

{
  if (NULL != proc->control_pipe)
    GNUNET_DISK_file_close (proc->control_pipe);
  GNUNET_free (proc->filename);
  for (unsigned int i = 0; i < proc->envs_size; i++)
  {
    GNUNET_free (proc->envs[i].key);
    GNUNET_free (proc->envs[i].value);
  }
  GNUNET_free (proc->envs);
  for (unsigned int i = 0; i < proc->map_size; i++)
  {
    struct ProcessFileMapEntry *me = &proc->map[i];
    int pfd = me->parent_fd;
 
    if (-1 == pfd)
      continue;
    if (! me->owned)
      continue;
    GNUNET_break (0 == close (pfd));
  }
  GNUNET_free (proc->map);
  for (unsigned int i = 0; NULL != proc->argv[i]; i++)
    GNUNET_free (proc->argv[i]);
  GNUNET_free (proc->argv);
  GNUNET_free (proc);
}

References GNUNET_Process::argv, GNUNET_Process::control_pipe, GNUNET_Process::envs, GNUNET_Process::envs_size, GNUNET_Process::filename, GNUNET_break, GNUNET_DISK_file_close(), GNUNET_free, EnviEntry::key, GNUNET_Process::map, GNUNET_Process::map_size, me, and EnviEntry::value.

Referenced by child_completed_callback(), child_completed_callback(), communicator_start(), exec_bash_script_cleanup(), GN_request_connection_reversal(), GN_stop_gnunet_nat_server_(), GNUNET_HELPER_wait(), GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_run(), GNUNET_OS_command_stop(), GNUNET_PQ_exec_sql(), maint_child_death(), maint_child_death(), maint_child_death(), nat_server_read(), netjail_start_cleanup(), restart_nat_server(), run(), run(), service_start(), shutdown_process(), start_arm_service(), start_peer_cleanup(), start_peer_run(), start_process(), wait_child(), and work().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_process_get_pid()

pid_t GNUNET_process_get_pid

(

const struct GNUNET_Process *

proc

)

Get the pid of the process in question.

Parameters

proc	the process to get the pid of

Returns

the current process id, -1 if the process is not running (both not yet started and already terminated with status)

Definition at line 356 of file os_process.c.

{
  return proc->pid;
}

References GNUNET_Process::pid.

Referenced by maint_child_death().

Here is the caller graph for this function:

GNUNET_process_kill()

enum GNUNET_GenericReturnValue GNUNET_process_kill	(	struct GNUNET_Process *	proc,
		int	sig
	)

Sends a signal to the process.

Parameters

proc	pointer to process structure
sig	signal

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 307 of file os_process.c.

{
  if (NULL != proc->control_pipe)
  {
    char csig = (char) sig;
    ssize_t iret;
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sending signal %d to pid: %u via pipe\n",
         sig,
         proc->pid);
    iret = GNUNET_DISK_file_write (proc->control_pipe,
                                   &csig,
                                   sizeof(csig));
    if (sizeof(csig) == iret)
      return GNUNET_OK;
  }
  /* pipe failed or non-existent, try other methods */
  if (-1 == proc->pid)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Refusing to send signal %d process `%s': not running\n",
         sig,
         proc->filename);
    return GNUNET_NO; /* -1 means process is not running, refuse... */
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending signal %d to pid: %u via system call\n",
       sig,
       proc->pid);
  {
    int ret;
 
    ret = kill (proc->pid,
                sig);
    if (0 != ret)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
                           "kill");
    }
    return (0 == ret)
    ? GNUNET_OK
    : GNUNET_SYSERR;
  }
}

References GNUNET_Process::control_pipe, GNUNET_Process::filename, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, LOG, GNUNET_Process::pid, and ret.

Referenced by do_stop_task(), exec_bash_script_cleanup(), GN_stop_gnunet_nat_server_(), GNUNET_HELPER_kill(), GNUNET_NAT_mini_get_external_ipv4_cancel_(), GNUNET_OS_command_stop(), handle_stop(), maint_child_death(), nat_server_read(), netjail_start_cleanup(), shutdown_process(), shutdown_program(), shutdown_task(), signal_run(), and start_peer_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_process_current()

struct GNUNET_Process * GNUNET_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

Definition at line 299 of file os_process.c.

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

References current_process, and GNUNET_Process::pid.

GNUNET_process_install_parent_control_handler()

void GNUNET_process_install_parent_control_handler

(

void

)

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.

Definition at line 223 of file os_process.c.

{
  const char *env_buf;
  char *env_buf_end;
  struct GNUNET_DISK_FileHandle *control_pipe;
  uint64_t pipe_fd;
 
  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);
    setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
    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);
    setenv (GNUNET_OS_CONTROL_PIPE,
            "",
            1);
    return;
  }
  if (pipe_fd >= FD_SETSIZE)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
         env_buf);
    setenv (GNUNET_OS_CONTROL_PIPE,
            "",
            1);
    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);
    setenv (GNUNET_OS_CONTROL_PIPE,
            "",
            1);
    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);
  setenv (GNUNET_OS_CONTROL_PIPE,
          "",
          1);
}

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.

Here is the call graph for this function:

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 111 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);
    setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
    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);
    setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
    return;
  }
  if (pipe_fd >= FD_SETSIZE)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
         env_buf);
    setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
    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);
    setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
    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);
  setenv (GNUNET_OS_CONTROL_PIPE, "", 1);
}

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 758 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 _, get_path_from_PATH(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_strdup, GNUNET_STRINGS_path_is_absolute(), GNUNET_SYSERR, GNUNET_YES, LOG, LOG_STRERROR_FILE, and p.

Referenced by GNUNET_NAT_mini_get_external_ipv4_(), GNUNET_NAT_mini_map_start(), GNUNET_process_run_command(), GNUNET_process_run_command_ap(), GNUNET_process_run_command_argv(), handle_autoconfig_request(), netjail_start_run(), restart_nat_server(), run(), run(), run(), run(), 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: