GNUnet  0.18.1
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_ProjectDataGNUNET_OS_project_data_default (void)
 Return default project data used by 'libgnunetutil' for GNUnet. More...
 
const struct GNUNET_OS_ProjectDataGNUNET_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_ProcessGNUNET_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_ProcessGNUNET_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_ProcessGNUNET_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_ProcessGNUNET_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_ProcessGNUNET_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_ProcessGNUNET_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_CommandHandleGNUNET_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
clsclosure
namename of the interface (can be NULL for unknown)
isDefaultis this presumably the default interface
addraddress of this interface (can be NULL for unknown or unassigned)
broadcast_addrthe broadcast address (can be NULL for unknown or unassigned)
netmaskthe network mask (can be NULL for unknown or unassigned)
addrlenlength 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
clsclosure
lineline 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

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.

73 {
78 
84 
90 
96 
102 
108 
113 };
@ GNUNET_OS_INHERIT_STD_IN
When this flag is set, the child process will inherit stdin of the parent.
Definition: gnunet_os_lib.h:83
@ GNUNET_OS_INHERIT_STD_ALL
Use this option to have all of the standard streams (stdin, stdout and stderror) be inherited.
@ GNUNET_OS_INHERIT_STD_OUT
When this flag is set, the child process will inherit stdout of the parent.
Definition: gnunet_os_lib.h:89
@ GNUNET_OS_INHERIT_STD_ERR
When this flag is set, the child process will inherit stderr of the parent.
Definition: gnunet_os_lib.h:95
@ GNUNET_OS_INHERIT_STD_NONE
No standard streams should be inherited.
Definition: gnunet_os_lib.h:77
@ 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_USE_PIPE_CONTROL
Should a pipe be used to send signals to the child?

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

126 {
131 
136 
141 
146 
151 
158 
163 
169 
174 };
@ GNUNET_OS_IPK_SELF_PREFIX
Return the installation directory of this application, not the one of the overall GNUnet installation...
@ GNUNET_OS_IPK_ICONDIR
Return the prefix of the path with application icons (share/icons/).
@ GNUNET_OS_IPK_DATADIR
Return the directory where data is installed (share/gnunet/)
@ GNUNET_OS_IPK_DOCDIR
Return the prefix of the path with documentation files, including the license (share/doc/gnunet/).
@ GNUNET_OS_IPK_LOCALEDIR
Return the directory where translations are installed (share/locale/)
@ GNUNET_OS_IPK_LIBDIR
Return the directory where libraries are installed.
@ GNUNET_OS_IPK_PREFIX
Return the "PREFIX" directory given to configure.
@ GNUNET_OS_IPK_BINDIR
Return the directory where the program binaries are installed.
@ GNUNET_OS_IPK_LIBEXECDIR
Return the directory where helper binaries are installed (lib/gnunet/libexec/)

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

181 {
187 
192 
197 
202 
207 };
@ GNUNET_OS_PROCESS_SIGNALED
The process was killed by a signal.
@ GNUNET_OS_PROCESS_EXITED
The process exited with a return code.
@ GNUNET_OS_PROCESS_UNKNOWN
The process is not known to the OS (or at least not one of our children).
@ GNUNET_OS_PROCESS_STOPPED
The process is paused (but could be resumed).
@ GNUNET_OS_PROCESS_RUNNING
The process is still running.

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 94 of file os_installation.c.

95 {
96  return &default_pd;
97 }
static const struct GNUNET_OS_ProjectData default_pd
Default project data used for installation path detection for GNUnet (core).

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 104 of file os_installation.c.

105 {
106  if (current_pd != gettextinit)
107  {
109 
110  if (NULL != path)
111  bindtextdomain (PACKAGE,
112  path);
113  GNUNET_free (path);
115  }
116  return current_pd;
117 }
#define bindtextdomain(Domainname, Dirname)
Definition: gettext.h:57
#define GNUNET_free(ptr)
Wrapper around free.
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,...
static const struct GNUNET_OS_ProjectData * gettextinit
PD for which gettext has been initialized last.
static const struct GNUNET_OS_ProjectData * current_pd
Which project data do we currently use for installation path detection? Never NULL.

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
pdproject data used to determine paths.

Definition at line 121 of file os_installation.c.

122 {
123  GNUNET_assert (NULL != pd);
124  current_pd = pd;
125  if (pd != gettextinit)
126  {
128 
129  if (NULL != path)
130  bindtextdomain (PACKAGE,
131  path);
132  GNUNET_free (path);
133  gettextinit = pd;
134  }
135 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

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
dirkindwhat 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 450 of file os_installation.c.

451 {
452  size_t n;
453  char *dirname;
454  char *execpath = NULL;
455  char *tmp;
456  char *multiarch;
457  char *libdir;
458  int isbasedir;
459 
460  /* if wanted, try to get the current app's bin/ */
461  if (dirkind == GNUNET_OS_IPK_SELF_PREFIX)
462  execpath = os_get_exec_path ();
463 
464  /* try to get GNUnet's bin/ or lib/, or if previous was unsuccessful some
465  * guess for the current app */
466  if (NULL == execpath)
467  execpath = os_get_gnunet_path ();
468  if (NULL == execpath)
469  return NULL;
470 
471  n = strlen (execpath);
472  if (0 == n)
473  {
474  /* should never happen, but better safe than sorry */
475  GNUNET_free (execpath);
476  return NULL;
477  }
478  /* remove filename itself */
479  while ((n > 1) && (DIR_SEPARATOR == execpath[n - 1]))
480  execpath[--n] = '\0';
481 
482  isbasedir = 1;
483  if ((n > 6) && ((0 == strcasecmp (&execpath[n - 6], "/lib32")) ||
484  (0 == strcasecmp (&execpath[n - 6], "/lib64"))))
485  {
486  if ((GNUNET_OS_IPK_LIBDIR != dirkind) &&
487  (GNUNET_OS_IPK_LIBEXECDIR != dirkind))
488  {
489  /* strip '/lib32' or '/lib64' */
490  execpath[n - 6] = '\0';
491  n -= 6;
492  }
493  else
494  isbasedir = 0;
495  }
496  else if ((n > 4) && ((0 == strcasecmp (&execpath[n - 4], "/bin")) ||
497  (0 == strcasecmp (&execpath[n - 4], "/lib"))))
498  {
499  /* strip '/bin' or '/lib' */
500  execpath[n - 4] = '\0';
501  n -= 4;
502  }
503  multiarch = NULL;
504  if (NULL != (libdir = strstr (execpath, "/lib/")))
505  {
506  /* test for multi-arch path of the form "PREFIX/lib/MULTIARCH/";
507  here we need to re-add 'multiarch' to lib and libexec paths later! */
508  multiarch = &libdir[5];
509  if (NULL == strchr (multiarch, '/'))
510  libdir[0] =
511  '\0'; /* Debian multiarch format, cut of from 'execpath' but preserve in multicarch */
512  else
513  multiarch =
514  NULL; /* maybe not, multiarch still has a '/', which is not OK */
515  }
516  /* in case this was a directory named foo-bin, remove "foo-" */
517  while ((n > 1) && (execpath[n - 1] == DIR_SEPARATOR))
518  execpath[--n] = '\0';
519  switch (dirkind)
520  {
523  dirname = GNUNET_strdup (DIR_SEPARATOR_STR);
524  break;
525 
528  break;
529 
531  if (isbasedir)
532  {
533  GNUNET_asprintf (&tmp,
534  "%s%s%s%s%s%s%s",
535  execpath,
536  DIR_SEPARATOR_STR "lib",
537  (NULL != multiarch) ? DIR_SEPARATOR_STR : "",
538  (NULL != multiarch) ? multiarch : "",
543  {
544  GNUNET_free (execpath);
545  return tmp;
546  }
547  GNUNET_free (tmp);
548  tmp = NULL;
549  dirname = NULL;
550  if (4 == sizeof(void *))
551  {
552  GNUNET_asprintf (&dirname,
554  "%s" DIR_SEPARATOR_STR,
556  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
557  }
558  if (8 == sizeof(void *))
559  {
560  GNUNET_asprintf (&dirname,
562  "%s" DIR_SEPARATOR_STR,
564  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
565  }
566 
567  if ((NULL != tmp) &&
569  {
570  GNUNET_free (execpath);
571  GNUNET_free (dirname);
572  return tmp;
573  }
574  GNUNET_free (tmp);
575  GNUNET_free (dirname);
576  }
577  GNUNET_asprintf (&dirname,
580  break;
581 
583  GNUNET_asprintf (&dirname,
585  "%s" DIR_SEPARATOR_STR,
587  break;
588 
591  "locale" DIR_SEPARATOR_STR);
592  break;
593 
596  "icons" DIR_SEPARATOR_STR);
597  break;
598 
600  GNUNET_asprintf (&dirname,
602  "doc" DIR_SEPARATOR_STR
603  "%s" DIR_SEPARATOR_STR,
605  break;
606 
608  if (isbasedir)
609  {
610  GNUNET_asprintf (&dirname,
612  "libexec" DIR_SEPARATOR_STR,
614  GNUNET_asprintf (&tmp,
615  "%s%s%s%s",
616  execpath,
618  (NULL != multiarch) ? multiarch : "",
619  dirname);
620  GNUNET_free (dirname);
622  {
623  GNUNET_free (execpath);
624  return tmp;
625  }
626  GNUNET_free (tmp);
627  tmp = NULL;
628  dirname = NULL;
629  if (4 == sizeof(void *))
630  {
631  GNUNET_asprintf (&dirname,
633  "%s" DIR_SEPARATOR_STR
634  "libexec" DIR_SEPARATOR_STR,
636  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
637  }
638  if (8 == sizeof(void *))
639  {
640  GNUNET_asprintf (&dirname,
642  "%s" DIR_SEPARATOR_STR
643  "libexec" DIR_SEPARATOR_STR,
645  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
646  }
647  if ((NULL != tmp) &&
649  {
650  GNUNET_free (execpath);
651  GNUNET_free (dirname);
652  return tmp;
653  }
654  GNUNET_free (tmp);
655  GNUNET_free (dirname);
656  }
657  GNUNET_asprintf (&dirname,
659  "libexec" DIR_SEPARATOR_STR,
661  break;
662 
663  default:
664  GNUNET_free (execpath);
665  return NULL;
666  }
667  GNUNET_asprintf (&tmp, "%s%s", execpath, dirname);
668  GNUNET_free (dirname);
669  GNUNET_free (execpath);
670  return tmp;
671 }
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:404
@ GNUNET_YES
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static char * os_get_gnunet_path(void)
get the path to GNUnet bin/ or lib/, preferring the lib/ path
static char * os_get_exec_path()
get the path to current app's bin/
#define DIR_SEPARATOR
Definition: platform.h:164
#define DIR_SEPARATOR_STR
Definition: platform.h:165
const char * project_dirname
Name of the project that is used in the "libexec" prefix, For example, "gnunet".

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
prognamename of the binary
Returns
full path to the binary, if possible, otherwise copy of 'progname'

Definition at line 683 of file os_installation.c.

684 {
685  static char *cache;
686  char *libexecdir;
687  char *binary;
688 
689  if ((DIR_SEPARATOR == progname[0]) ||
690  (GNUNET_YES ==
691  GNUNET_STRINGS_path_is_absolute (progname, GNUNET_NO, NULL, NULL)))
692  return GNUNET_strdup (progname);
693  if (NULL != cache)
694  libexecdir = cache;
695  else
697  if (NULL == libexecdir)
698  return GNUNET_strdup (progname);
699  GNUNET_asprintf (&binary, "%s%s", libexecdir, progname);
700  cache = libexecdir;
701  return binary;
702 }
static struct GNUNET_CONTAINER_MultiHashMap32 * cache
Hashmap to maintain cache.
@ GNUNET_NO
Definition: gnunet_common.h:98
enum GNUNET_GenericReturnValue GNUNET_STRINGS_path_is_absolute(const char *filename, int can_be_uri, int *r_is_uri, char **r_uri_scheme)
Check whether filename is absolute or not, and if it's an URI.
Definition: strings.c:959

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
cfgconfiguration to inspect
prognamename of the binary
Returns
full path to the binary, if possible, a copy of progname otherwise

Definition at line 718 of file os_installation.c.

720 {
721  static char *cache;
722  char *binary = NULL;
723  char *path = NULL;
724  size_t path_len;
725 
726  if (GNUNET_YES ==
727  GNUNET_STRINGS_path_is_absolute (progname, GNUNET_NO, NULL, NULL))
728  {
729  return GNUNET_strdup (progname);
730  }
731  if (NULL != cache)
732  path = cache;
733  else
735  "PATHS",
736  "SUID_BINARY_PATH",
737  &path);
738  if ((NULL == path) || (0 == strlen (path)))
739  {
740  if (NULL != path)
741  GNUNET_free (path);
742  cache = NULL;
743  return GNUNET_OS_get_libexec_binary_path (progname);
744  }
745  path_len = strlen (path);
746  GNUNET_asprintf (&binary,
747  "%s%s%s",
748  path,
749  (path[path_len - 1] == DIR_SEPARATOR) ? ""
751  progname);
752  cache = path;
753  return binary;
754 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
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 ...

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
procthe callback function
proc_clsclosure for proc

Definition at line 396 of file os_network.c.

398 {
399 #if HAVE_GETIFADDRS && HAVE_FREEIFADDRS
400  struct ifaddrs *ifa_first;
401  struct ifaddrs *ifa_ptr;
402  socklen_t alen;
403 
404  if (getifaddrs (&ifa_first) == 0)
405  {
406  for (ifa_ptr = ifa_first; ifa_ptr != NULL; ifa_ptr = ifa_ptr->ifa_next)
407  {
408  if ((ifa_ptr->ifa_name != NULL) && (ifa_ptr->ifa_addr != NULL) &&
409  ( (ifa_ptr->ifa_flags & IFF_UP) != 0) )
410  {
411  if ((ifa_ptr->ifa_addr->sa_family != AF_INET) &&
412  (ifa_ptr->ifa_addr->sa_family != AF_INET6))
413  continue;
414  if (ifa_ptr->ifa_addr->sa_family == AF_INET)
415  alen = sizeof(struct sockaddr_in);
416  else
417  alen = sizeof(struct sockaddr_in6);
418  if (GNUNET_OK !=
419  proc (proc_cls, ifa_ptr->ifa_name,
420  (0 == strcmp (ifa_ptr->ifa_name, GNUNET_DEFAULT_INTERFACE)),
421  ifa_ptr->ifa_addr, ifa_ptr->ifa_broadaddr,
422  ifa_ptr->ifa_netmask, alen))
423  break;
424  }
425  }
426  freeifaddrs (ifa_first);
427  }
428 #else
429  if (GNUNET_OK ==
430  try_ip (proc,
431  proc_cls))
432  return;
433  if (GNUNET_OK ==
434  try_ifconfig (proc,
435  proc_cls))
436  return;
438  "Failed to enumerate network interfaces\n");
439 #endif
440 }
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_BULK
static int try_ip(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Try to enumerate all network interfaces using 'ip'.
Definition: os_network.c:244
static int try_ifconfig(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Try to enumerate all network interfaces using 'ifconfig'.
Definition: os_network.c:51
#define LOG(kind,...)
Definition: os_network.c:34

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

202 {
203  current_process.pid = 0;
204  return &current_process;
205 }
static struct GNUNET_OS_Process current_process
Handle for 'this' process.
Definition: os_priority.c:61
pid_t pid
PID of the process.
Definition: os_priority.c:48

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
procpointer to process structure
sigsignal
Returns
0 on success, -1 on error

Definition at line 209 of file os_priority.c.

211 {
212  int ret;
213  char csig;
214 
215  csig = (char) sig;
216  if (NULL != proc->control_pipe)
217  {
219  "Sending signal %d to pid: %u via pipe\n",
220  sig,
221  proc->pid);
222  ret = GNUNET_DISK_file_write (proc->control_pipe, &csig, sizeof(csig));
223  if (sizeof(csig) == ret)
224  return 0;
225  }
226  /* pipe failed or non-existent, try other methods */
227  switch (sig)
228  {
229  case SIGHUP:
230  case SIGINT:
231  case SIGKILL:
232  case SIGTERM:
233 #if (SIGTERM != GNUNET_TERM_SIG)
234  case GNUNET_TERM_SIG:
235 #endif
237  "Sending signal %d to pid: %u via system call\n",
238  sig,
239  proc->pid);
240  return kill (proc->pid, sig);
241  default:
243  "Sending signal %d to pid: %u via system call\n",
244  sig,
245  proc->pid);
246  return kill (proc->pid, sig);
247  }
248 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:686
@ GNUNET_ERROR_TYPE_DEBUG
#define LOG(kind,...)
Definition: os_priority.c:32
#define GNUNET_TERM_SIG
The termination signal.
Definition: platform.h:233
struct GNUNET_DISK_FileHandle * control_pipe
Pipe we use to signal the process.
Definition: os_priority.c:54

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
procpointer to process structure

Definition at line 272 of file os_priority.c.

273 {
274  if (NULL != proc->control_pipe)
276 
277  GNUNET_free (proc);
278 }
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306

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
procthe process to get the pid of
Returns
the current process id

Definition at line 259 of file os_priority.c.

260 {
261  return proc->pid;
262 }

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_inheritancea set of GNUNET_OS_INHERIT_STD_* flags
pipe_stdinpipe to use to send input to child process (or NULL)
pipe_stdoutpipe to use to get output from child process (or NULL)
pipe_stderrpipe to use to get error output from child process (or NULL)
filenamename of the binary
argvNULL-terminated array of arguments to the process
Returns
pointer to process structure of the new process, NULL on error

Definition at line 579 of file os_priority.c.

585 {
586  return start_process (std_inheritance,
587  pipe_stdin,
588  pipe_stdout,
589  pipe_stderr,
590  NULL,
591  filename,
592  argv);
593 }
static char * filename
static struct GNUNET_OS_Process * start_process(enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const int *lsocks, const char *filename, char *const argv[])
Start a process.
Definition: os_priority.c:329

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_inheritancea set of GNUNET_OS_INHERIT_STD_* flags
pipe_stdinpipe to use to send input to child process (or NULL)
pipe_stdoutpipe to use to get output from child process (or NULL)
pipe_stderrpipe to use to get error output from child process (or NULL)
filenamename 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 632 of file os_priority.c.

638 {
639  struct GNUNET_OS_Process *ret;
640  va_list ap;
641 
642  va_start (ap, filename);
643  ret = GNUNET_OS_start_process_va (std_inheritance,
644  pipe_stdin,
645  pipe_stdout,
646  pipe_stderr,
647  filename,
648  ap);
649  va_end (ap);
650  return ret;
651 }
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.
Definition: os_priority.c:597

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_inheritancea set of GNUNET_OS_INHERIT_STD_* flags
pipe_stdinpipe to use to send input to child process (or NULL)
pipe_stdoutpipe to use to get output from child process (or NULL)
pipe_stderrpipe to use to get error output from child process (or NULL)
filenamename of the binary
vaNULL-terminated list of arguments to the process
Returns
pointer to process structure of the new process, NULL on error

Definition at line 597 of file os_priority.c.

603 {
604  struct GNUNET_OS_Process *ret;
605  va_list ap;
606  char **argv;
607  int argc;
608 
609  argc = 0;
610  va_copy (ap, va);
611  while (NULL != va_arg (ap, char *))
612  argc++;
613  va_end (ap);
614  argv = GNUNET_malloc (sizeof(char *) * (argc + 1));
615  argc = 0;
616  va_copy (ap, va);
617  while (NULL != (argv[argc] = va_arg (ap, char *)))
618  argc++;
619  va_end (ap);
620  ret = GNUNET_OS_start_process_vap (std_inheritance,
621  pipe_stdin,
622  pipe_stdout,
623  pipe_stderr,
624  filename,
625  argv);
626  GNUNET_free (argv);
627  return ret;
628 }
#define GNUNET_malloc(size)
Wrapper around malloc.
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.
Definition: os_priority.c:579

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_inheritancea set of GNUNET_OS_INHERIT_STD_* flags
lsocksarray of listen sockets to dup systemd-style (or NULL); must be NULL on platforms where dup is not supported
filenamename of the binary
argvNULL-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_inheritancea 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).
lsocksarray of listen sockets to dup systemd-style (or NULL); must be NULL on platforms where dup is not supported
filenamename of the binary
argvNULL-terminated list of arguments to the process
Returns
process ID of the new process, -1 on error

Definition at line 668 of file os_priority.c.

672 {
673  return start_process (std_inheritance,
674  NULL,
675  NULL,
676  NULL,
677  lsocks,
678  filename,
679  argv);
680 }

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_inheritancea set of GNUNET_OS_INHERIT_STD_* flags
lsocksarray of listen sockets to dup systemd-style (or NULL); must be NULL on platforms where dup is not supported
filenamename 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 701 of file os_priority.c.

705 {
706  va_list ap;
707  char **argv;
708  unsigned int argv_size;
709  const char *arg;
710  const char *rpos;
711  char *pos;
712  char *cp;
713  const char *last;
714  struct GNUNET_OS_Process *proc;
715  char *binary_path;
716  int quote_on;
717  unsigned int i;
718  size_t len;
719 
720  argv_size = 1;
721  va_start (ap, filename);
722  arg = filename;
723  last = NULL;
724  do
725  {
726  rpos = arg;
727  quote_on = 0;
728  while ('\0' != *rpos)
729  {
730  if ('"' == *rpos)
731  {
732  if (1 == quote_on)
733  quote_on = 0;
734  else
735  quote_on = 1;
736  }
737  if ((' ' == *rpos) && (0 == quote_on))
738  {
739  if (NULL != last)
740  argv_size++;
741  last = NULL;
742  rpos++;
743  while (' ' == *rpos)
744  rpos++;
745  }
746  if ((NULL == last) && ('\0' != *rpos)) // FIXME: == or !=?
747  last = rpos;
748  if ('\0' != *rpos)
749  rpos++;
750  }
751  if (NULL != last)
752  argv_size++;
753  }
754  while (NULL != (arg = (va_arg (ap, const char *))));
755  va_end (ap);
756 
757  argv = GNUNET_malloc (argv_size * sizeof(char *));
758  argv_size = 0;
759  va_start (ap, filename);
760  arg = filename;
761  last = NULL;
762  do
763  {
764  cp = GNUNET_strdup (arg);
765  quote_on = 0;
766  pos = cp;
767  while ('\0' != *pos)
768  {
769  if ('"' == *pos)
770  {
771  if (1 == quote_on)
772  quote_on = 0;
773  else
774  quote_on = 1;
775  }
776  if ((' ' == *pos) && (0 == quote_on))
777  {
778  *pos = '\0';
779  if (NULL != last)
780  argv[argv_size++] = GNUNET_strdup (last);
781  last = NULL;
782  pos++;
783  while (' ' == *pos)
784  pos++;
785  }
786  if ((NULL == last) && ('\0' != *pos)) // FIXME: == or !=?
787  last = pos;
788  if ('\0' != *pos)
789  pos++;
790  }
791  if (NULL != last)
792  argv[argv_size++] = GNUNET_strdup (last);
793  last = NULL;
794  GNUNET_free (cp);
795  }
796  while (NULL != (arg = (va_arg (ap, const char *))));
797  va_end (ap);
798  argv[argv_size] = NULL;
799 
800  for (i = 0; i < argv_size; i++)
801  {
802  len = strlen (argv[i]);
803  if ((argv[i][0] == '"') && (argv[i][len - 1] == '"'))
804  {
805  memmove (&argv[i][0], &argv[i][1], len - 2);
806  argv[i][len - 2] = '\0';
807  }
808  }
809  binary_path = argv[0];
810  proc = GNUNET_OS_start_process_v (std_inheritance,
811  lsocks,
812  binary_path,
813  argv);
814  while (argv_size > 0)
815  GNUNET_free_nz (argv[--argv_size]);
816  GNUNET_free (argv);
817  return proc;
818 }
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
#define GNUNET_free_nz(ptr)
Wrapper around free.
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.
Definition: os_priority.c:668

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
cmdhandle 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
cmdhandle to the process

Definition at line 1017 of file os_priority.c.

1018 {
1019  if (NULL != cmd->proc)
1020  {
1021  GNUNET_assert (NULL != cmd->rtask);
1023  }
1024  (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
1028  GNUNET_free (cmd);
1029 }
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
Closes an interprocess channel.
Definition: disk.c:1585
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
int GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
Wait for a process to terminate.
Definition: os_priority.c:941
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:272
int GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
Sends a signal to the process.
Definition: os_priority.c:209
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:943
struct GNUNET_DISK_PipeHandle * opipe
Handle to the output pipe.
Definition: os_priority.c:970
struct GNUNET_OS_Process * eip
Process handle.
Definition: os_priority.c:965
struct GNUNET_SCHEDULER_Task * rtask
Task reading from pipe.
Definition: os_priority.c:995
GNUNET_OS_LineProcessor proc
Function to call on each line of output.
Definition: os_priority.c:980

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
procfunction to call for each line of the output
proc_clsclosure for proc
timeoutwhen to time out
binarycommand to run
...arguments to command
Returns
NULL on error

Definition at line 1091 of file os_priority.c.

1096 {
1097  struct GNUNET_OS_CommandHandle *cmd;
1098  struct GNUNET_OS_Process *eip;
1099  struct GNUNET_DISK_PipeHandle *opipe;
1100  va_list ap;
1101 
1103  if (NULL == opipe)
1104  return NULL;
1105  va_start (ap, binary);
1106  /* redirect stdout, don't inherit stderr/stdin */
1107  eip =
1109  NULL,
1110  opipe,
1111  NULL,
1112  binary,
1113  ap);
1114  va_end (ap);
1115  if (NULL == eip)
1116  {
1117  GNUNET_DISK_pipe_close (opipe);
1118  return NULL;
1119  }
1121  cmd = GNUNET_new (struct GNUNET_OS_CommandHandle);
1123  cmd->eip = eip;
1124  cmd->opipe = opipe;
1125  cmd->proc = proc;
1126  cmd->proc_cls = proc_cls;
1128  cmd->rtask = GNUNET_SCHEDULER_add_read_file (timeout, cmd->r, &cmd_read, cmd);
1129  return cmd;
1130 }
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
const struct GNUNET_DISK_FileHandle * GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd n)
Get the handle to a particular pipe end.
Definition: disk.c:1616
enum GNUNET_GenericReturnValue GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p, enum GNUNET_DISK_PipeEnd end)
Closes one half of an interprocess channel.
Definition: disk.c:1532
struct GNUNET_DISK_PipeHandle * GNUNET_DISK_pipe(enum GNUNET_DISK_PipeFlags pf)
Creates an interprocess channel.
Definition: disk.c:1442
@ GNUNET_DISK_PF_BLOCKING_RW
Configure both pipe ends for blocking operations if set.
@ GNUNET_DISK_PIPE_END_WRITE
The writing-end of a pipe.
@ GNUNET_DISK_PIPE_END_READ
The reading-end of a pipe.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_file(struct GNUNET_TIME_Relative delay, const struct GNUNET_DISK_FileHandle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1624
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:315
static void cmd_read(void *cls)
Read from the process and call the line processor.
Definition: os_priority.c:1038
Handle used to manage a pipe.
Definition: disk.c:69
Handle to a command.
Definition: os_priority.c:961
struct GNUNET_TIME_Absolute timeout
When to time out.
Definition: os_priority.c:1000
void * proc_cls
Closure for proc.
Definition: os_priority.c:985
const struct GNUNET_DISK_FileHandle * r
Read-end of output pipe.
Definition: os_priority.c:975

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
procpointer to process structure
typestatus type
codereturn code/signal number
Returns
GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise

Nonblocking version.

Parameters
procprocess ID
typestatus type
codereturn code/signal number
Returns
GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise

Definition at line 701 of file os_priority.c.

907 {
908  return process_status (proc, type, code, WNOHANG);
909 }
static enum GNUNET_GenericReturnValue process_status(struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code, int options)
Retrieve the status of a process, waiting on it if dead.
Definition: os_priority.c:832
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

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
procpointer 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
procpointer to process structure
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 941 of file os_priority.c.

942 {
943  pid_t pid = proc->pid;
944  pid_t ret;
945 
946  while ((pid != (ret = waitpid (pid, NULL, 0))) && (EINTR == errno))
947  ;
948  if (pid != ret)
949  {
951  return GNUNET_SYSERR;
952  }
953  return GNUNET_OK;
954 }
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define LOG_STRERROR(kind, syscall)
Definition: os_priority.c:34

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
procpointer to process structure
typestatus type
codereturn code/signal number
Returns
GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise

Blocking version.

Parameters
procpointer to process structure
typestatus type
codereturn code/signal number
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 701 of file os_priority.c.

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

◆ 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
clsclosure (unused)

Definition at line 132 of file os_priority.c.

133 {
134  const char *env_buf;
135  char *env_buf_end;
136  struct GNUNET_DISK_FileHandle *control_pipe;
137  uint64_t pipe_fd;
138 
139  (void) cls;
140  if (NULL != pch)
141  {
142  /* already done, we've been called twice... */
143  GNUNET_break (0);
144  return;
145  }
146  env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
147  if ((NULL == env_buf) || (strlen (env_buf) <= 0))
148  {
150  "Not installing a handler because $%s is empty\n",
152  putenv (GNUNET_OS_CONTROL_PIPE "=");
153  return;
154  }
155  errno = 0;
156  pipe_fd = strtoull (env_buf, &env_buf_end, 16);
157  if ((0 != errno) || (env_buf == env_buf_end))
158  {
159  LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf);
160  putenv (GNUNET_OS_CONTROL_PIPE "=");
161  return;
162  }
163  if (pipe_fd >= FD_SETSIZE)
164  {
166  "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
167  env_buf);
168  putenv (GNUNET_OS_CONTROL_PIPE "=");
169  return;
170  }
171 
172  control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd);
173 
174  if (NULL == control_pipe)
175  {
176  LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
177  putenv (GNUNET_OS_CONTROL_PIPE "=");
178  return;
179  }
181  "Adding parent control handler pipe `%s' to the scheduler\n",
182  env_buf);
184  control_pipe,
186  control_pipe);
188  putenv (GNUNET_OS_CONTROL_PIPE "=");
189 }
char * getenv()
struct GNUNET_DISK_FileHandle * GNUNET_DISK_get_handle_from_int_fd(int fno)
Get a handle from a native integer FD.
Definition: disk.c:1328
@ GNUNET_ERROR_TYPE_ERROR
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1302
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_OS_CONTROL_PIPE
Definition: os_priority.c:40
static void parent_control_handler(void *cls)
This handler is called when there are control data to be read on the pipe.
Definition: os_priority.c:97
static struct GNUNET_SCHEDULER_Task * pch
Handle for the parent_control_handler() Task.
Definition: os_priority.c:66
#define LOG_STRERROR_FILE(kind, syscall, filename)
Definition: os_priority.c:37
static void shutdown_pch(void *cls)
This handler is called on shutdown to remove the pch.
Definition: os_priority.c:80
static struct GNUNET_SCHEDULER_Task * spch
Handle for the shutdown_pch() Task.
Definition: os_priority.c:71
Handle used to access files (and pipes).

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
binarythe name of the file to check. W32: must not have an .exe suffix.
check_suidinput 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.
paramsparameters 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 718 of file os_installation.c.

761 {
762  struct stat statbuf;
763  char *p;
764  char *pf;
765 
766  if ((GNUNET_YES ==
767  GNUNET_STRINGS_path_is_absolute (binary, GNUNET_NO, NULL, NULL)) ||
768  (0 == strncmp (binary, "./", 2)))
769  {
770  p = GNUNET_strdup (binary);
771  }
772  else
773  {
774  p = get_path_from_PATH (binary);
775  if (NULL != p)
776  {
777  GNUNET_asprintf (&pf, "%s/%s", p, binary);
778  GNUNET_free (p);
779  p = pf;
780  }
781  }
782 
783  if (NULL == p)
784  {
786  _ ("Could not find binary `%s' in PATH!\n"),
787  binary);
788  return GNUNET_SYSERR;
789  }
790  if (0 != access (p, X_OK))
791  {
793  GNUNET_free (p);
794  return GNUNET_SYSERR;
795  }
796 
797  if (0 == getuid ())
798  {
799  /* as we run as root, we don't insist on SUID */
800  GNUNET_free (p);
801  return GNUNET_YES;
802  }
803 
804  if (0 != stat (p, &statbuf))
805  {
807  GNUNET_free (p);
808  return GNUNET_SYSERR;
809  }
810  if (check_suid)
811  {
812  (void) params;
813  if ((0 != (statbuf.st_mode & S_ISUID)) && (0 == statbuf.st_uid))
814  {
815  GNUNET_free (p);
816  return GNUNET_YES;
817  }
819  _ ("Binary `%s' exists, but is not SUID\n"),
820  p);
821  /* binary exists, but not SUID */
822  }
823  GNUNET_free (p);
824  return GNUNET_NO;
825 }
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:37
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_INFO
static char * get_path_from_PATH(const char *binary)
Return the actual path to a file found in the current PATH environment variable.
#define LOG_STRERROR_FILE(kind, syscall, filename)
#define LOG(kind,...)
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

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: