add nonstring attribute to silence warning
[oweals/gnunet.git] / src / util / os_priority.c
1 /*
2      This file is part of GNUnet
3      Copyright (C) 2002, 2003, 2004, 2005, 2006, 2011 GNUnet e.V.
4
5      GNUnet is free software: you can redistribute it and/or modify it
6      under the terms of the GNU Affero General Public License as published
7      by the Free Software Foundation, either version 3 of the License,
8      or (at your option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      Affero General Public License for more details.
14     
15      You should have received a copy of the GNU Affero General Public License
16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18      SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
21 /**
22  * @file util/os_priority.c
23  * @brief Methods to set process priority
24  * @author Nils Durner
25  */
26
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "disk.h"
30 #include <unistr.h>
31
32 #define LOG(kind,...) GNUNET_log_from (kind, "util-os-priority", __VA_ARGS__)
33
34 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-os-priority", syscall)
35
36 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-os-priority", syscall, filename)
37
38 #define GNUNET_OS_CONTROL_PIPE "GNUNET_OS_CONTROL_PIPE"
39
40
41 struct GNUNET_OS_Process
42 {
43   /**
44    * PID of the process.
45    */
46   pid_t pid;
47
48 #if WINDOWS
49   /**
50    * Process handle.
51    */
52   HANDLE handle;
53 #endif
54
55   /**
56    * Pipe we use to signal the process.
57    * NULL if unused, or if process was deemed uncontrollable.
58    */
59   struct GNUNET_DISK_FileHandle *control_pipe;
60 };
61
62
63 /**
64  * Handle for 'this' process.
65  */
66 static struct GNUNET_OS_Process current_process;
67
68 /**
69  * Handle for the #parent_control_handler() Task.
70  */
71 static struct GNUNET_SCHEDULER_Task *pch;
72
73 /**
74  * Handle for the #shutdown_pch() Task.
75  */
76 static struct GNUNET_SCHEDULER_Task *spch;
77
78
79 /**
80  * This handler is called on shutdown to remove the #pch.
81  *
82  * @param cls the `struct GNUNET_DISK_FileHandle` of the control pipe
83  */
84 static void
85 shutdown_pch (void *cls)
86 {
87   struct GNUNET_DISK_FileHandle *control_pipe = cls;
88
89   GNUNET_SCHEDULER_cancel (pch);
90   pch = NULL;
91   GNUNET_DISK_file_close (control_pipe);
92   control_pipe = NULL;
93 }
94
95
96 /**
97  * This handler is called when there are control data to be read on the pipe
98  *
99  * @param cls the `struct GNUNET_DISK_FileHandle` of the control pipe
100  */
101 static void
102 parent_control_handler (void *cls)
103 {
104   struct GNUNET_DISK_FileHandle *control_pipe = cls;
105   char sig;
106   char *pipe_fd;
107   ssize_t ret;
108
109   pch = NULL;
110   ret = GNUNET_DISK_file_read (control_pipe,
111                                &sig,
112                                sizeof (sig));
113   if (sizeof (sig) != ret)
114   {
115     if (-1 == ret)
116       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
117                     "GNUNET_DISK_file_read");
118     LOG (GNUNET_ERROR_TYPE_DEBUG,
119          "Closing control pipe\n");
120     GNUNET_DISK_file_close (control_pipe);
121     control_pipe = NULL;
122     GNUNET_SCHEDULER_cancel (spch);
123     spch = NULL;
124     return;
125   }
126   pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE);
127   GNUNET_assert ( (NULL == pipe_fd) ||
128                   (strlen (pipe_fd) <= 0) );
129   LOG (GNUNET_ERROR_TYPE_DEBUG,
130        "Got control code %d from parent via pipe %s\n",
131        sig,
132        pipe_fd);
133   pch = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
134                                         control_pipe,
135                                         &parent_control_handler,
136                                         control_pipe);
137   GNUNET_SIGNAL_raise ((int) sig);
138 }
139
140
141 /**
142  * Task that connects this process to its parent via pipe;
143  * essentially, the parent control handler will read signal numbers
144  * from the #GNUNET_OS_CONTROL_PIPE (as given in an environment
145  * variable) and raise those signals.
146  *
147  * @param cls closure (unused)
148  */
149 void
150 GNUNET_OS_install_parent_control_handler (void *cls)
151 {
152   const char *env_buf;
153   char *env_buf_end;
154   struct GNUNET_DISK_FileHandle *control_pipe;
155   uint64_t pipe_fd;
156
157   (void) cls;
158   if (NULL != pch)
159   {
160     /* already done, we've been called twice... */
161     GNUNET_break (0);
162     return;
163   }
164   env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
165   if ( (NULL == env_buf) || (strlen (env_buf) <= 0) )
166   {
167     LOG (GNUNET_ERROR_TYPE_DEBUG,
168          "Not installing a handler because $%s is empty\n",
169          GNUNET_OS_CONTROL_PIPE);
170     putenv (GNUNET_OS_CONTROL_PIPE "=");
171     return;
172   }
173   errno = 0;
174   pipe_fd = strtoull (env_buf, &env_buf_end, 16);
175   if ((0 != errno) || (env_buf == env_buf_end))
176   {
177     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
178                        "strtoull",
179                        env_buf);
180     putenv (GNUNET_OS_CONTROL_PIPE "=");
181     return;
182   }
183 #if !defined (WINDOWS)
184   if (pipe_fd >= FD_SETSIZE)
185 #else
186   if ((FILE_TYPE_UNKNOWN == GetFileType ((HANDLE) (uintptr_t) pipe_fd))
187       && (0 != GetLastError ()))
188 #endif
189   {
190     LOG (GNUNET_ERROR_TYPE_ERROR,
191          "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n",
192          env_buf);
193     putenv (GNUNET_OS_CONTROL_PIPE "=");
194     return;
195   }
196 #if WINDOWS
197   control_pipe = GNUNET_DISK_get_handle_from_w32_handle ((HANDLE) (uintptr_t) pipe_fd);
198 #else
199   control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd);
200 #endif
201   if (NULL == control_pipe)
202   {
203     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
204                        "open",
205                        env_buf);
206     putenv (GNUNET_OS_CONTROL_PIPE "=");
207     return;
208   }
209   LOG (GNUNET_ERROR_TYPE_DEBUG,
210        "Adding parent control handler pipe `%s' to the scheduler\n",
211        env_buf);
212   pch = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
213                                         control_pipe,
214                                         &parent_control_handler,
215                                         control_pipe);
216   spch = GNUNET_SCHEDULER_add_shutdown (&shutdown_pch,
217                                         control_pipe);
218   putenv (GNUNET_OS_CONTROL_PIPE "=");
219 }
220
221
222 /**
223  * Get process structure for current process
224  *
225  * The pointer it returns points to static memory location and must
226  * not be deallocated/closed.
227  *
228  * @return pointer to the process sturcutre for this process
229  */
230 struct GNUNET_OS_Process *
231 GNUNET_OS_process_current ()
232 {
233 #if WINDOWS
234   current_process.pid = GetCurrentProcessId ();
235   current_process.handle = GetCurrentProcess ();
236 #else
237   current_process.pid = 0;
238 #endif
239   return &current_process;
240 }
241
242
243 /**
244  * Sends a signal to the process
245  *
246  * @param proc pointer to process structure
247  * @param sig signal
248  * @return 0 on success, -1 on error
249  */
250 int
251 GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc,
252                         int sig)
253 {
254   int ret;
255   char csig;
256
257   csig = (char) sig;
258   if (NULL != proc->control_pipe)
259   {
260     LOG (GNUNET_ERROR_TYPE_DEBUG,
261          "Sending signal %d to pid: %u via pipe\n",
262          sig,
263          proc->pid);
264     ret = GNUNET_DISK_file_write (proc->control_pipe,
265                                   &csig,
266                                   sizeof (csig));
267     if (sizeof (csig) == ret)
268       return 0;
269   }
270   /* pipe failed or non-existent, try other methods */
271   switch (sig)
272   {
273 #if !defined (WINDOWS)
274   case SIGHUP:
275 #endif
276   case SIGINT:
277   case SIGKILL:
278   case SIGTERM:
279 #if (SIGTERM != GNUNET_TERM_SIG)
280   case GNUNET_TERM_SIG:
281 #endif
282 #if defined(WINDOWS) && !defined(__CYGWIN__)
283     {
284       DWORD exitcode;
285       int must_kill = GNUNET_YES;
286       if (0 != GetExitCodeProcess (proc->handle, &exitcode))
287         must_kill = (exitcode == STILL_ACTIVE) ? GNUNET_YES : GNUNET_NO;
288       if (GNUNET_YES == must_kill)
289       {
290         if (0 == SafeTerminateProcess (proc->handle, 0, 0))
291         {
292           DWORD error_code = GetLastError ();
293           if ( (error_code != WAIT_TIMEOUT) &&
294                (error_code != ERROR_PROCESS_ABORTED) )
295           {
296             LOG ((error_code == ERROR_ACCESS_DENIED) ?
297                  GNUNET_ERROR_TYPE_INFO : GNUNET_ERROR_TYPE_WARNING,
298                  "SafeTermiateProcess failed with code %lu\n",
299                  error_code);
300             /* The problem here is that a process that is already dying
301              * might cause SafeTerminateProcess to fail with
302              * ERROR_ACCESS_DENIED, but the process WILL die eventually.
303              * If we really had a permissions problem, hanging up (which
304              * is what will happen in process_wait() in that case) is
305              * a valid option.
306              */
307             if (ERROR_ACCESS_DENIED == error_code)
308             {
309               errno = 0;
310             }
311             else
312             {
313               SetErrnoFromWinError (error_code);
314               return -1;
315             }
316           }
317         }
318       }
319     }
320     return 0;
321 #else
322     LOG (GNUNET_ERROR_TYPE_DEBUG,
323          "Sending signal %d to pid: %u via system call\n",
324          sig,
325          proc->pid);
326     return PLIBC_KILL (proc->pid, sig);
327 #endif
328   default:
329 #if defined (WINDOWS)
330     errno = EINVAL;
331     return -1;
332 #else
333     LOG (GNUNET_ERROR_TYPE_DEBUG,
334          "Sending signal %d to pid: %u via system call\n",
335          sig,
336          proc->pid);
337     return PLIBC_KILL (proc->pid, sig);
338 #endif
339   }
340 }
341
342
343 /**
344  * Get the pid of the process in question
345  *
346  * @param proc the process to get the pid of
347  *
348  * @return the current process id
349  */
350 pid_t
351 GNUNET_OS_process_get_pid (struct GNUNET_OS_Process * proc)
352 {
353   return proc->pid;
354 }
355
356
357 /**
358  * Cleans up process structure contents (OS-dependent) and deallocates
359  * it.
360  *
361  * @param proc pointer to process structure
362  */
363 void
364 GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc)
365 {
366   if (NULL != proc->control_pipe)
367     GNUNET_DISK_file_close (proc->control_pipe);
368 #if defined (WINDOWS)
369   if (NULL != proc->handle)
370     CloseHandle (proc->handle);
371 #endif
372   GNUNET_free (proc);
373 }
374
375
376 #if WINDOWS
377 #include "gnunet_signal_lib.h"
378
379 extern GNUNET_SIGNAL_Handler w32_sigchld_handler;
380
381 /**
382  * Make seaspider happy.
383  */
384 #define DWORD_WINAPI DWORD WINAPI
385
386
387 /**
388  * @brief Waits for a process to terminate and invokes the SIGCHLD handler
389  * @param proc pointer to process structure
390  */
391 static DWORD_WINAPI
392 child_wait_thread (void *arg)
393 {
394   struct GNUNET_OS_Process *proc = (struct GNUNET_OS_Process *) arg;
395
396   WaitForSingleObject (proc->handle, INFINITE);
397
398   if (w32_sigchld_handler)
399     w32_sigchld_handler ();
400
401   return 0;
402 }
403 #endif
404
405
406 #if MINGW
407 static char *
408 CreateCustomEnvTable (char **vars)
409 {
410   char *win32_env_table;
411   char *ptr;
412   char **var_ptr;
413   char *result;
414   char *result_ptr;
415   size_t tablesize = 0;
416   size_t items_count = 0;
417   size_t n_found = 0;
418   size_t n_var;
419   char *index = NULL;
420   size_t c;
421   size_t var_len;
422   char *var;
423   char *val;
424
425   win32_env_table = GetEnvironmentStringsA ();
426   if (NULL == win32_env_table)
427     return NULL;
428   for (c = 0, var_ptr = vars; *var_ptr; var_ptr += 2, c++) ;
429   n_var = c;
430   index = GNUNET_malloc (sizeof (char *) * n_var);
431   for (c = 0; c < n_var; c++)
432     index[c] = 0;
433   for (items_count = 0, ptr = win32_env_table; ptr[0] != 0; items_count++)
434   {
435     size_t len = strlen (ptr);
436     int found = 0;
437
438     for (var_ptr = vars; *var_ptr; var_ptr++)
439     {
440       var = *var_ptr++;
441       val = *var_ptr;
442       var_len = strlen (var);
443       if (strncmp (var, ptr, var_len) == 0)
444       {
445         found = 1;
446         index[c] = 1;
447         tablesize += var_len + strlen (val) + 1;
448         break;
449       }
450     }
451     if (!found)
452       tablesize += len + 1;
453     ptr += len + 1;
454   }
455   for (n_found = 0, c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
456   {
457     var = *var_ptr++;
458     val = *var_ptr;
459     if (index[c] != 1)
460       n_found += strlen (var) + strlen (val) + 1;
461   }
462   result = GNUNET_malloc (tablesize + n_found + 1);
463   for (result_ptr = result, ptr = win32_env_table; ptr[0] != 0;)
464   {
465     size_t len = strlen (ptr);
466     int found = 0;
467
468     for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
469     {
470       var = *var_ptr++;
471       val = *var_ptr;
472       var_len = strlen (var);
473       if (strncmp (var, ptr, var_len) == 0)
474       {
475         found = 1;
476         break;
477       }
478     }
479     if (!found)
480     {
481       strcpy (result_ptr, ptr);
482       result_ptr += len + 1;
483     }
484     else
485     {
486       strcpy (result_ptr, var);
487       result_ptr += var_len;
488       strcpy (result_ptr, val);
489       result_ptr += strlen (val) + 1;
490     }
491     ptr += len + 1;
492   }
493   for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
494   {
495     var = *var_ptr++;
496     val = *var_ptr;
497     var_len = strlen (var);
498     if (index[c] != 1)
499     {
500       strcpy (result_ptr, var);
501       result_ptr += var_len;
502       strcpy (result_ptr, val);
503       result_ptr += strlen (val) + 1;
504     }
505   }
506   FreeEnvironmentStrings (win32_env_table);
507   GNUNET_free (index);
508   *result_ptr = 0;
509   return result;
510 }
511
512 #else
513
514 /**
515  * Open '/dev/null' and make the result the given
516  * file descriptor.
517  *
518  * @param target_fd desired FD to point to /dev/null
519  * @param flags open flags (O_RDONLY, O_WRONLY)
520  */
521 static void
522 open_dev_null (int target_fd,
523                int flags)
524 {
525   int fd;
526
527   fd = open ("/dev/null", flags);
528   if (-1 == fd)
529   {
530     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
531                               "open",
532                               "/dev/null");
533     return;
534   }
535   if (fd == target_fd)
536     return;
537   if (-1 == dup2 (fd, target_fd))
538   {
539     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
540     (void) close (fd);
541     return;
542   }
543   GNUNET_break (0 == close (fd));
544 }
545 #endif
546
547
548 /**
549  * Start a process.
550  *
551  * @param pipe_control should a pipe be used to send signals to the child?
552  * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags controlling which
553  *        std handles of the parent are inherited by the child.
554  *        pipe_stdin and pipe_stdout take priority over std_inheritance
555  *        (when they are non-NULL).
556  * @param pipe_stdin pipe to use to send input to child process (or NULL)
557  * @param pipe_stdout pipe to use to get output from child process (or NULL)
558  * @param pipe_stderr pipe to use for stderr for child process (or NULL)
559  * @param lsocks array of listen sockets to dup systemd-style (or NULL);
560  *         must be NULL on platforms where dup is not supported
561  * @param filename name of the binary
562  * @param argv NULL-terminated list of arguments to the process
563  * @return process ID of the new process, -1 on error
564  */
565 static struct GNUNET_OS_Process *
566 start_process (int pipe_control,
567                enum GNUNET_OS_InheritStdioFlags std_inheritance,
568                struct GNUNET_DISK_PipeHandle *pipe_stdin,
569                struct GNUNET_DISK_PipeHandle *pipe_stdout,
570                struct GNUNET_DISK_PipeHandle *pipe_stderr,
571                const SOCKTYPE *lsocks,
572                const char *filename,
573                char *const argv[])
574 {
575 #ifndef MINGW
576   pid_t ret;
577   char fds[16];
578   struct GNUNET_OS_Process *gnunet_proc;
579   struct GNUNET_DISK_FileHandle *childpipe_read;
580   struct GNUNET_DISK_FileHandle *childpipe_write;
581   int childpipe_read_fd;
582   int i;
583   int j;
584   int k;
585   int tgt;
586   int flags;
587   int *lscp;
588   unsigned int ls;
589   int fd_stdout_write;
590   int fd_stdout_read;
591   int fd_stderr_write;
592   int fd_stderr_read;
593   int fd_stdin_read;
594   int fd_stdin_write;
595
596   if (GNUNET_SYSERR ==
597       GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
598     return NULL; /* not executable */
599   if (GNUNET_YES == pipe_control)
600   {
601     struct GNUNET_DISK_PipeHandle *childpipe;
602     int dup_childpipe_read_fd = -1;
603
604     childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO,
605                                   GNUNET_YES, GNUNET_NO);
606     if (NULL == childpipe)
607       return NULL;
608     childpipe_read = GNUNET_DISK_pipe_detach_end (childpipe,
609                                                   GNUNET_DISK_PIPE_END_READ);
610     childpipe_write = GNUNET_DISK_pipe_detach_end (childpipe,
611                                                    GNUNET_DISK_PIPE_END_WRITE);
612     GNUNET_DISK_pipe_close (childpipe);
613     if ( (NULL == childpipe_read) ||
614          (NULL == childpipe_write) ||
615          (GNUNET_OK !=
616           GNUNET_DISK_internal_file_handle_ (childpipe_read,
617                                              &childpipe_read_fd,
618                                              sizeof (int))) ||
619          (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd))))
620     {
621       if (NULL != childpipe_read)
622         GNUNET_DISK_file_close (childpipe_read);
623       if (NULL != childpipe_write)
624         GNUNET_DISK_file_close (childpipe_write);
625       if (0 <= dup_childpipe_read_fd)
626         close (dup_childpipe_read_fd);
627       return NULL;
628     }
629     childpipe_read_fd = dup_childpipe_read_fd;
630     GNUNET_DISK_file_close (childpipe_read);
631   }
632   else
633   {
634     childpipe_write = NULL;
635     childpipe_read_fd = -1;
636   }
637   if (NULL != pipe_stdin)
638   {
639     GNUNET_assert (GNUNET_OK ==
640                    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
641                                                       (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
642                                                       &fd_stdin_read, sizeof (int)));
643     GNUNET_assert (GNUNET_OK ==
644                    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
645                                                       (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE),
646                                                       &fd_stdin_write, sizeof (int)));
647   }
648   if (NULL != pipe_stdout)
649   {
650     GNUNET_assert (GNUNET_OK ==
651                    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
652                                                       (pipe_stdout,
653                                                        GNUNET_DISK_PIPE_END_WRITE),
654                                                       &fd_stdout_write, sizeof (int)));
655     GNUNET_assert (GNUNET_OK ==
656                    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
657                                                       (pipe_stdout, GNUNET_DISK_PIPE_END_READ),
658                                                       &fd_stdout_read, sizeof (int)));
659   }
660   if (NULL != pipe_stderr)
661   {
662     GNUNET_assert (GNUNET_OK ==
663                    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
664                                                       (pipe_stderr,
665                                                        GNUNET_DISK_PIPE_END_READ),
666                                                       &fd_stderr_read, sizeof (int)));
667     GNUNET_assert (GNUNET_OK ==
668                    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
669                                                       (pipe_stderr,
670                                                        GNUNET_DISK_PIPE_END_WRITE),
671                                                       &fd_stderr_write, sizeof (int)));
672   }
673   lscp = NULL;
674   ls = 0;
675   if (NULL != lsocks)
676   {
677     i = 0;
678     while (-1 != (k = lsocks[i++]))
679       GNUNET_array_append (lscp, ls, k);
680     GNUNET_array_append (lscp, ls, -1);
681   }
682 #if DARWIN
683   /* see https://gnunet.org/vfork */
684   ret = vfork ();
685 #else
686   ret = fork ();
687 #endif
688   if (-1 == ret)
689   {
690     int eno = errno;
691     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
692     GNUNET_array_grow (lscp, ls, 0);
693     if (NULL != childpipe_write)
694       GNUNET_DISK_file_close (childpipe_write);
695     if (0 <= childpipe_read_fd)
696       close (childpipe_read_fd);
697     errno = eno;
698     return NULL;
699   }
700   if (0 != ret)
701   {
702     unsetenv (GNUNET_OS_CONTROL_PIPE);
703     gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
704     gnunet_proc->pid = ret;
705     gnunet_proc->control_pipe = childpipe_write;
706     if (GNUNET_YES == pipe_control)
707     {
708       close (childpipe_read_fd);
709     }
710     GNUNET_array_grow (lscp, ls, 0);
711     return gnunet_proc;
712   }
713   if (0 <= childpipe_read_fd)
714   {
715     char fdbuf[100];
716 #ifndef DARWIN
717     /* due to vfork, we must NOT free memory on DARWIN! */
718     GNUNET_DISK_file_close (childpipe_write);
719 #endif
720     snprintf (fdbuf, 100, "%x", childpipe_read_fd);
721     setenv (GNUNET_OS_CONTROL_PIPE, fdbuf, 1);
722   }
723   else
724     unsetenv (GNUNET_OS_CONTROL_PIPE);
725   if (NULL != pipe_stdin)
726   {
727     GNUNET_break (0 == close (fd_stdin_write));
728     if (-1 == dup2 (fd_stdin_read, 0))
729       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
730     GNUNET_break (0 == close (fd_stdin_read));
731   }
732   else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN))
733   {
734     GNUNET_break (0 == close (0));
735     open_dev_null (0, O_RDONLY);
736   }
737   if (NULL != pipe_stdout)
738   {
739     GNUNET_break (0 == close (fd_stdout_read));
740     if (-1 == dup2 (fd_stdout_write, 1))
741       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
742     GNUNET_break (0 == close (fd_stdout_write));
743   }
744   else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT))
745   {
746     GNUNET_break (0 == close (1));
747     open_dev_null (1, O_WRONLY);
748   }
749   if (NULL != pipe_stderr)
750   {
751     GNUNET_break (0 == close (fd_stderr_read));
752     if (-1 == dup2 (fd_stderr_write, 2))
753       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
754     GNUNET_break (0 == close (fd_stderr_write));
755   }
756   else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR))
757   {
758     GNUNET_break (0 == close (2));
759     open_dev_null (2, O_WRONLY);
760   }
761   if (NULL != lscp)
762   {
763     /* read systemd documentation... */
764     i = 0;
765     tgt = 3;
766     while (-1 != lscp[i])
767     {
768       j = i + 1;
769       while (-1 != lscp[j])
770       {
771         if (lscp[j] == tgt)
772         {
773           /* dup away */
774           k = dup (lscp[j]);
775           GNUNET_assert (-1 != k);
776           GNUNET_assert (0 == close (lscp[j]));
777           lscp[j] = k;
778           break;
779         }
780         j++;
781       }
782       if (lscp[i] != tgt)
783       {
784         /* Bury any existing FD, no matter what; they should all be closed
785          * on exec anyway and the important onces have been dup'ed away */
786         (void) close (tgt);
787         GNUNET_assert (-1 != dup2 (lscp[i], tgt));
788       }
789       /* unset close-on-exec flag */
790       flags = fcntl (tgt, F_GETFD);
791       GNUNET_assert (flags >= 0);
792       flags &= ~FD_CLOEXEC;
793       fflush (stderr);
794       (void) fcntl (tgt, F_SETFD, flags);
795       tgt++;
796       i++;
797     }
798     GNUNET_snprintf (fds, sizeof (fds), "%u", i);
799     setenv ("LISTEN_FDS", fds, 1);
800   }
801 #ifndef DARWIN
802   /* due to vfork, we must NOT free memory on DARWIN! */
803   GNUNET_array_grow (lscp, ls, 0);
804 #endif
805   execvp (filename, argv);
806   LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
807   _exit (1);
808 #else
809   struct GNUNET_DISK_FileHandle *childpipe_read;
810   struct GNUNET_DISK_FileHandle *childpipe_write;
811   HANDLE childpipe_read_handle;
812   char **arg;
813   char **non_const_argv;
814   unsigned int cmdlen;
815   char *cmd;
816   char *idx;
817   STARTUPINFOW start;
818   PROCESS_INFORMATION proc;
819   int argcount = 0;
820   struct GNUNET_OS_Process *gnunet_proc;
821   char path[MAX_PATH + 1];
822   char *our_env[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
823   char *env_block = NULL;
824   char *pathbuf;
825   DWORD pathbuf_len;
826   DWORD alloc_len;
827   char *self_prefix;
828   char *bindir;
829   char *libdir;
830   char *ptr;
831   char *non_const_filename;
832   char win_path[MAX_PATH + 1];
833   struct GNUNET_DISK_PipeHandle *lsocks_pipe;
834   const struct GNUNET_DISK_FileHandle *lsocks_write_fd;
835   HANDLE lsocks_read;
836   HANDLE lsocks_write;
837   wchar_t *wpath;
838   wchar_t *wcmd;
839   size_t wpath_len;
840   size_t wcmd_len;
841   int env_off;
842   int fail;
843   long lRet;
844   HANDLE stdin_handle;
845   HANDLE stdout_handle;
846   HANDLE stdih, stdoh, stdeh;
847   DWORD stdif, stdof, stdef;
848   BOOL bresult;
849   DWORD error_code;
850   DWORD create_no_window;
851
852   if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
853     return NULL; /* not executable */
854
855   /* Search in prefix dir (hopefully - the directory from which
856    * the current module was loaded), bindir and libdir, then in PATH
857    */
858   self_prefix = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_SELF_PREFIX);
859   bindir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_BINDIR);
860   libdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
861
862   pathbuf_len = GetEnvironmentVariableA ("PATH", (char *) &pathbuf, 0);
863
864   alloc_len =
865       pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
866       strlen (libdir);
867
868   pathbuf = GNUNET_malloc (alloc_len * sizeof (char));
869
870   ptr = pathbuf;
871   ptr += sprintf (pathbuf, "%s;%s;%s;", self_prefix, bindir, libdir);
872   GNUNET_free (self_prefix);
873   GNUNET_free (bindir);
874   GNUNET_free (libdir);
875
876   alloc_len = GetEnvironmentVariableA ("PATH", ptr, pathbuf_len);
877   if (alloc_len != pathbuf_len - 1)
878   {
879     GNUNET_free (pathbuf);
880     errno = ENOSYS;             /* PATH changed on the fly. What kind of error is that? */
881     return NULL;
882   }
883
884   cmdlen = strlen (filename);
885   if ( (cmdlen < 5) || (0 != strcmp (&filename[cmdlen - 4], ".exe")) )
886     GNUNET_asprintf (&non_const_filename, "%s.exe", filename);
887   else
888     GNUNET_asprintf (&non_const_filename, "%s", filename);
889
890   /* It could be in POSIX form, convert it to a DOS path early on */
891   if (ERROR_SUCCESS != (lRet = plibc_conv_to_win_path (non_const_filename, win_path)))
892   {
893     SetErrnoFromWinError (lRet);
894     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "plibc_conv_to_win_path",
895                        non_const_filename);
896     GNUNET_free (non_const_filename);
897     GNUNET_free (pathbuf);
898     return NULL;
899   }
900   GNUNET_free (non_const_filename);
901   non_const_filename = GNUNET_strdup (win_path);
902    /* Check that this is the full path. If it isn't, search. */
903   /* FIXME: convert it to wchar_t and use SearchPathW?
904    * Remember: arguments to _start_process() are technically in UTF-8...
905    */
906   if (non_const_filename[1] == ':')
907   {
908     snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename);
909     LOG (GNUNET_ERROR_TYPE_DEBUG,
910         "Using path `%s' as-is. PATH is %s\n", path, ptr);
911   }
912   else if (!SearchPathA
913            (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char),
914             path, NULL))
915   {
916     SetErrnoFromWinError (GetLastError ());
917     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath",
918                        non_const_filename);
919     GNUNET_free (non_const_filename);
920     GNUNET_free (pathbuf);
921     return NULL;
922   }
923   else
924     LOG (GNUNET_ERROR_TYPE_DEBUG,
925         "Found `%s' in PATH `%s'\n", path, pathbuf);
926   GNUNET_free (pathbuf);
927   GNUNET_free (non_const_filename);
928
929   /* Count the number of arguments */
930   arg = (char **) argv;
931   while (*arg)
932   {
933     arg++;
934     argcount++;
935   }
936
937   /* Allocate a copy argv */
938   non_const_argv = GNUNET_malloc (sizeof (char *) * (argcount + 1));
939
940   /* Copy all argv strings */
941   argcount = 0;
942   arg = (char **) argv;
943   while (*arg)
944   {
945     if (arg == argv)
946       non_const_argv[argcount] = GNUNET_strdup (path);
947     else
948       non_const_argv[argcount] = GNUNET_strdup (*arg);
949     arg++;
950     argcount++;
951   }
952   non_const_argv[argcount] = NULL;
953
954   /* Count cmd len */
955   cmdlen = 1;
956   arg = non_const_argv;
957   while (*arg)
958   {
959     cmdlen = cmdlen + strlen (*arg) + 4;
960     arg++;
961   }
962
963   /* Allocate and create cmd */
964   cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
965   arg = non_const_argv;
966   while (*arg)
967   {
968     char arg_last_char = (*arg)[strlen (*arg) - 1];
969     idx += sprintf (idx, "\"%s%s\"%s", *arg,
970         arg_last_char == '\\' ? "\\" : "", *(arg + 1) ? " " : "");
971     arg++;
972   }
973
974   while (argcount > 0)
975     GNUNET_free (non_const_argv[--argcount]);
976   GNUNET_free (non_const_argv);
977
978   memset (&start, 0, sizeof (start));
979   start.cb = sizeof (start);
980   if ((pipe_stdin != NULL) || (pipe_stdout != NULL) || (std_inheritance != 0))
981     start.dwFlags |= STARTF_USESTDHANDLES;
982
983   stdih = GetStdHandle (STD_INPUT_HANDLE);
984   GetHandleInformation (stdih, &stdif);
985   if (pipe_stdin != NULL)
986   {
987     GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
988                                        (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
989                                        &stdin_handle, sizeof (HANDLE));
990     start.hStdInput = stdin_handle;
991   }
992   else if (stdih)
993   {
994     if (std_inheritance & GNUNET_OS_INHERIT_STD_IN)
995     {
996       SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 1);
997       if (pipe_stdin == NULL)
998         start.hStdInput = stdih;
999     }
1000     else
1001       SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 0);
1002   }
1003
1004
1005   stdoh = GetStdHandle (STD_OUTPUT_HANDLE);
1006   GetHandleInformation (stdoh, &stdof);
1007   if (NULL != pipe_stdout)
1008   {
1009     GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
1010                                        (pipe_stdout,
1011                                         GNUNET_DISK_PIPE_END_WRITE),
1012                                        &stdout_handle, sizeof (HANDLE));
1013     start.hStdOutput = stdout_handle;
1014   }
1015   else if (stdoh)
1016   {
1017     if (std_inheritance & GNUNET_OS_INHERIT_STD_OUT)
1018     {
1019       SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 1);
1020       if (pipe_stdout == NULL)
1021         start.hStdOutput = stdoh;
1022     }
1023     else
1024       SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 0);
1025   }
1026
1027   stdeh = GetStdHandle (STD_ERROR_HANDLE);
1028   GetHandleInformation (stdeh, &stdef);
1029   if (stdeh)
1030   {
1031     if (std_inheritance & GNUNET_OS_INHERIT_STD_ERR)
1032     {
1033       SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 1);
1034       start.hStdError = stdeh;
1035     }
1036     else
1037       SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 0);
1038   }
1039
1040   if (GNUNET_YES == pipe_control)
1041   {
1042     struct GNUNET_DISK_PipeHandle *childpipe;
1043     childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
1044     if (NULL == childpipe)
1045       return NULL;
1046     childpipe_read = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ);
1047     childpipe_write = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE);
1048     GNUNET_DISK_pipe_close (childpipe);
1049     if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
1050         (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
1051         &childpipe_read_handle, sizeof (HANDLE))))
1052     {
1053       if (childpipe_read)
1054         GNUNET_DISK_file_close (childpipe_read);
1055       if (childpipe_write)
1056         GNUNET_DISK_file_close (childpipe_write);
1057       GNUNET_free (cmd);
1058       return NULL;
1059     }
1060     /* Unlike *nix variant, we don't dup the handle, so can't close
1061      * filehandle right now.
1062      */
1063     SetHandleInformation (childpipe_read_handle, HANDLE_FLAG_INHERIT, 1);
1064   }
1065   else
1066   {
1067     childpipe_read = NULL;
1068     childpipe_write = NULL;
1069   }
1070
1071   if (lsocks != NULL && lsocks[0] != INVALID_SOCKET)
1072   {
1073     lsocks_pipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
1074
1075     if (lsocks_pipe == NULL)
1076     {
1077       GNUNET_free (cmd);
1078       GNUNET_DISK_pipe_close (lsocks_pipe);
1079       if (GNUNET_YES == pipe_control)
1080       {
1081         GNUNET_DISK_file_close (childpipe_write);
1082         GNUNET_DISK_file_close (childpipe_read);
1083       }
1084       return NULL;
1085     }
1086     lsocks_write_fd = GNUNET_DISK_pipe_handle (lsocks_pipe,
1087         GNUNET_DISK_PIPE_END_WRITE);
1088     GNUNET_DISK_internal_file_handle_ (lsocks_write_fd,
1089                                        &lsocks_write, sizeof (HANDLE));
1090     GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
1091                                        (lsocks_pipe, GNUNET_DISK_PIPE_END_READ),
1092                                        &lsocks_read, sizeof (HANDLE));
1093   }
1094   else
1095   {
1096     lsocks_pipe = NULL;
1097     lsocks_write_fd = NULL;
1098   }
1099
1100   env_off = 0;
1101   if (GNUNET_YES == pipe_control)
1102   {
1103     GNUNET_asprintf (&our_env[env_off++], "%s=", GNUNET_OS_CONTROL_PIPE);
1104     GNUNET_asprintf (&our_env[env_off++], "%p", childpipe_read_handle);
1105   }
1106   if ( (lsocks != NULL) && (lsocks[0] != INVALID_SOCKET))
1107   {
1108     /*This will tell the child that we're going to send lsocks over the pipe*/
1109     GNUNET_asprintf (&our_env[env_off++], "%s=", "GNUNET_OS_READ_LSOCKS");
1110     GNUNET_asprintf (&our_env[env_off++], "%lu", lsocks_read);
1111   }
1112   our_env[env_off++] = NULL;
1113   env_block = CreateCustomEnvTable (our_env);
1114   while (0 > env_off)
1115     GNUNET_free_non_null (our_env[--env_off]);
1116
1117   wpath_len = 0;
1118   if (NULL == (wpath = u8_to_u16 ((uint8_t *) path, 1 + strlen (path), NULL, &wpath_len)))
1119   {
1120     LOG (GNUNET_ERROR_TYPE_DEBUG,
1121         "Failed to convert `%s' from UTF-8 to UTF-16: %d\n", path, errno);
1122     GNUNET_free (env_block);
1123     GNUNET_free (cmd);
1124     if (lsocks_pipe)
1125       GNUNET_DISK_pipe_close (lsocks_pipe);
1126     if (GNUNET_YES == pipe_control)
1127     {
1128       GNUNET_DISK_file_close (childpipe_write);
1129       GNUNET_DISK_file_close (childpipe_read);
1130     }
1131     return NULL;
1132   }
1133
1134   wcmd_len = 0;
1135   if (NULL == (wcmd = u8_to_u16 ((uint8_t *) cmd, 1 + strlen (cmd), NULL, &wcmd_len)))
1136   {
1137     LOG (GNUNET_ERROR_TYPE_DEBUG,
1138          "Failed to convert `%s' from UTF-8 to UTF-16: %d\n",
1139          cmd,
1140          errno);
1141     GNUNET_free (env_block);
1142     GNUNET_free (cmd);
1143     free (wpath);
1144     if (lsocks_pipe)
1145       GNUNET_DISK_pipe_close (lsocks_pipe);
1146     if (GNUNET_YES == pipe_control)
1147     {
1148       GNUNET_DISK_file_close (childpipe_write);
1149       GNUNET_DISK_file_close (childpipe_read);
1150     }
1151     return NULL;
1152   }
1153
1154   create_no_window = 0;
1155   {
1156     HANDLE console_input = CreateFile ("CONIN$", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1157     if (INVALID_HANDLE_VALUE == console_input)
1158       create_no_window = CREATE_NO_WINDOW;
1159     else
1160       CloseHandle (console_input);
1161   }
1162
1163   bresult = CreateProcessW (wpath, wcmd, NULL, NULL, GNUNET_YES,
1164        create_no_window | CREATE_SUSPENDED, env_block, NULL, &start, &proc);
1165   error_code = GetLastError ();
1166
1167   if ((NULL == pipe_stdin) && (stdih))
1168     SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, stdif);
1169
1170
1171   if ((NULL == pipe_stdout) && (stdoh))
1172     SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, stdof);
1173
1174   if (stdeh)
1175     SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, stdef);
1176
1177   if (!bresult)
1178     LOG (GNUNET_ERROR_TYPE_ERROR,
1179          "CreateProcess(%s, %s) failed: %lu\n",
1180          path,
1181          cmd,
1182          error_code);
1183
1184   GNUNET_free (env_block);
1185   GNUNET_free (cmd);
1186   free (wpath);
1187   free (wcmd);
1188   if (GNUNET_YES == pipe_control)
1189   {
1190     GNUNET_DISK_file_close (childpipe_read);
1191   }
1192
1193   if (!bresult)
1194   {
1195     if (GNUNET_YES == pipe_control)
1196     {
1197       GNUNET_DISK_file_close (childpipe_write);
1198     }
1199     if (NULL != lsocks)
1200       GNUNET_DISK_pipe_close (lsocks_pipe);
1201     SetErrnoFromWinError (error_code);
1202     return NULL;
1203   }
1204
1205   gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
1206   gnunet_proc->pid = proc.dwProcessId;
1207   gnunet_proc->handle = proc.hProcess;
1208   gnunet_proc->control_pipe = childpipe_write;
1209
1210   CreateThread (NULL, 64000, &child_wait_thread, (void *) gnunet_proc, 0, NULL);
1211
1212   ResumeThread (proc.hThread);
1213   CloseHandle (proc.hThread);
1214
1215   if ( (NULL == lsocks) || (INVALID_SOCKET == lsocks[0]) )
1216     return gnunet_proc;
1217
1218   GNUNET_DISK_pipe_close_end (lsocks_pipe, GNUNET_DISK_PIPE_END_READ);
1219
1220   /* This is a replacement for "goto error" that doesn't use goto */
1221   fail = 1;
1222   do
1223   {
1224     ssize_t wrote;
1225     uint64_t size;
1226     uint64_t count;
1227     unsigned int i;
1228
1229     /* Tell the number of sockets */
1230     for (count = 0; lsocks && lsocks[count] != INVALID_SOCKET; count++);
1231
1232     wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count));
1233     if (sizeof (count) != wrote)
1234     {
1235       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1236                   "Failed to write %u count bytes to the child: %lu\n",
1237                   sizeof (count), GetLastError ());
1238       break;
1239     }
1240     for (i = 0; lsocks && lsocks[i] != INVALID_SOCKET; i++)
1241     {
1242       WSAPROTOCOL_INFOA pi;
1243       /* Get a socket duplication info */
1244       if (SOCKET_ERROR == WSADuplicateSocketA (lsocks[i], gnunet_proc->pid, &pi))
1245       {
1246         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1247                     "Failed to duplicate an socket[%u]: %lu\n", i,
1248                     GetLastError ());
1249         break;
1250       }
1251       /* Synchronous I/O is not nice, but we can't schedule this:
1252        * lsocks will be closed/freed by the caller soon, and until
1253        * the child creates a duplicate, closing a socket here will
1254        * close it for good.
1255        */
1256       /* Send the size of the structure
1257        * (the child might be built with different headers...)
1258        */
1259       size = sizeof (pi);
1260       wrote = GNUNET_DISK_file_write (lsocks_write_fd, &size, sizeof (size));
1261       if (sizeof (size) != wrote)
1262       {
1263         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1264                     "Failed to write %u size[%u] bytes to the child: %lu\n",
1265                     sizeof (size), i, GetLastError ());
1266         break;
1267       }
1268       /* Finally! Send the data */
1269       wrote = GNUNET_DISK_file_write (lsocks_write_fd, &pi, sizeof (pi));
1270       if (sizeof (pi) != wrote)
1271       {
1272         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1273                     "Failed to write %u socket[%u] bytes to the child: %lu\n",
1274                     sizeof (pi), i, GetLastError ());
1275         break;
1276       }
1277     }
1278     /* This will block us until the child makes a final read or closes
1279      * the pipe (hence no 'wrote' check), since we have to wait for it
1280      * to duplicate the last socket, before we return and start closing
1281      * our own copies)
1282      */
1283     wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count));
1284     fail = 0;
1285   }
1286   while (fail);
1287
1288   GNUNET_DISK_file_sync (lsocks_write_fd);
1289   GNUNET_DISK_pipe_close (lsocks_pipe);
1290
1291   if (fail)
1292   {
1293     /* If we can't pass on the socket(s), the child will block forever,
1294      * better put it out of its misery.
1295      */
1296     SafeTerminateProcess (gnunet_proc->handle, 0, 0);
1297     CloseHandle (gnunet_proc->handle);
1298     if (NULL != gnunet_proc->control_pipe)
1299       GNUNET_DISK_file_close (gnunet_proc->control_pipe);
1300     GNUNET_free (gnunet_proc);
1301     return NULL;
1302   }
1303   return gnunet_proc;
1304 #endif
1305 }
1306
1307
1308 /**
1309  * Start a process.
1310  *
1311  * @param pipe_control should a pipe be used to send signals to the child?
1312  * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1313  * @param pipe_stdin pipe to use to send input to child process (or NULL)
1314  * @param pipe_stdout pipe to use to get output from child process (or NULL)
1315  * @param pipe_stderr pipe to use to get output from child process (or NULL)
1316  * @param filename name of the binary
1317  * @param argv NULL-terminated array of arguments to the process
1318  * @return pointer to process structure of the new process, NULL on error
1319  */
1320 struct GNUNET_OS_Process *
1321 GNUNET_OS_start_process_vap (int pipe_control,
1322                              enum GNUNET_OS_InheritStdioFlags std_inheritance,
1323                              struct GNUNET_DISK_PipeHandle *pipe_stdin,
1324                              struct GNUNET_DISK_PipeHandle *pipe_stdout,
1325                              struct GNUNET_DISK_PipeHandle *pipe_stderr,
1326                              const char *filename,
1327                              char *const argv[])
1328 {
1329   return start_process (pipe_control,
1330                         std_inheritance,
1331                         pipe_stdin,
1332                         pipe_stdout,
1333                         pipe_stderr,
1334                         NULL,
1335                         filename,
1336                         argv);
1337 }
1338
1339
1340 /**
1341  * Start a process.
1342  *
1343  * @param pipe_control should a pipe be used to send signals to the child?
1344  * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1345  * @param pipe_stdin pipe to use to send input to child process (or NULL)
1346  * @param pipe_stdout pipe to use to get output from child process (or NULL)
1347  * @param pipe_stderr pipe to use to get output from child process (or NULL)
1348  * @param filename name of the binary
1349  * @param va NULL-terminated list of arguments to the process
1350  * @return pointer to process structure of the new process, NULL on error
1351  */
1352 struct GNUNET_OS_Process *
1353 GNUNET_OS_start_process_va (int pipe_control,
1354                             enum GNUNET_OS_InheritStdioFlags std_inheritance,
1355                             struct GNUNET_DISK_PipeHandle *pipe_stdin,
1356                             struct GNUNET_DISK_PipeHandle *pipe_stdout,
1357                             struct GNUNET_DISK_PipeHandle *pipe_stderr,
1358                             const char *filename, va_list va)
1359 {
1360   struct GNUNET_OS_Process *ret;
1361   va_list ap;
1362   char **argv;
1363   int argc;
1364
1365   argc = 0;
1366   va_copy (ap, va);
1367   while (NULL != va_arg (ap, char *))
1368     argc++;
1369   va_end (ap);
1370   argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
1371   argc = 0;
1372   va_copy (ap, va);
1373   while (NULL != (argv[argc] = va_arg (ap, char *)))
1374     argc++;
1375   va_end (ap);
1376   ret = GNUNET_OS_start_process_vap (pipe_control,
1377                                      std_inheritance,
1378                                      pipe_stdin,
1379                                      pipe_stdout,
1380                                      pipe_stderr,
1381                                      filename,
1382                                      argv);
1383   GNUNET_free (argv);
1384   return ret;
1385 }
1386
1387
1388 /**
1389  * Start a process.
1390  *
1391  * @param pipe_control should a pipe be used to send signals to the child?
1392  * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1393  * @param pipe_stdin pipe to use to send input to child process (or NULL)
1394  * @param pipe_stdout pipe to use to get output from child process (or NULL)
1395  * @param filename name of the binary
1396  * @param ... NULL-terminated list of arguments to the process
1397  * @return pointer to process structure of the new process, NULL on error
1398  */
1399 struct GNUNET_OS_Process *
1400 GNUNET_OS_start_process (int pipe_control,
1401                          enum GNUNET_OS_InheritStdioFlags std_inheritance,
1402                          struct GNUNET_DISK_PipeHandle *pipe_stdin,
1403                          struct GNUNET_DISK_PipeHandle *pipe_stdout,
1404                          struct GNUNET_DISK_PipeHandle *pipe_stderr,
1405                          const char *filename, ...)
1406 {
1407   struct GNUNET_OS_Process *ret;
1408   va_list ap;
1409
1410   va_start (ap, filename);
1411   ret = GNUNET_OS_start_process_va (pipe_control,
1412                                     std_inheritance,
1413                                     pipe_stdin,
1414                                     pipe_stdout,
1415                                     pipe_stderr,
1416                                     filename,
1417                                     ap);
1418   va_end (ap);
1419   return ret;
1420 }
1421
1422
1423 /**
1424  * Start a process.
1425  *
1426  * @param pipe_control should a pipe be used to send signals to the child?
1427  * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags controlling which
1428  *        std handles of the parent are inherited by the child.
1429  *        pipe_stdin and pipe_stdout take priority over std_inheritance
1430  *        (when they are non-NULL).
1431  * @param lsocks array of listen sockets to dup systemd-style (or NULL);
1432  *         must be NULL on platforms where dup is not supported
1433  * @param filename name of the binary
1434  * @param argv NULL-terminated list of arguments to the process
1435  * @return process ID of the new process, -1 on error
1436  */
1437 struct GNUNET_OS_Process *
1438 GNUNET_OS_start_process_v (int pipe_control,
1439                            enum GNUNET_OS_InheritStdioFlags std_inheritance,
1440                            const SOCKTYPE *lsocks,
1441                            const char *filename,
1442                            char *const argv[])
1443 {
1444   return start_process (pipe_control,
1445                         std_inheritance,
1446                         NULL,
1447                         NULL,
1448                         NULL,
1449                         lsocks,
1450                         filename,
1451                         argv);
1452 }
1453
1454
1455 /**
1456  * Start a process.  This function is similar to the GNUNET_OS_start_process_*
1457  * except that the filename and arguments can have whole strings which contain
1458  * the arguments.  These arguments are to be separated by spaces and are parsed
1459  * in the order they appear.  Arguments containing spaces can be used by
1460  * quoting them with @em ".
1461  *
1462  * @param pipe_control should a pipe be used to send signals to the child?
1463  * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1464  * @param lsocks array of listen sockets to dup systemd-style (or NULL);
1465  *         must be NULL on platforms where dup is not supported
1466  * @param filename name of the binary.  It is valid to have the arguments
1467  *         in this string when they are separated by spaces.
1468  * @param ... more arguments.  Should be of type `char *`.  It is valid
1469  *         to have the arguments in these strings when they are separated by
1470  *         spaces.  The last argument MUST be NULL.
1471  * @return pointer to process structure of the new process, NULL on error
1472  */
1473 struct GNUNET_OS_Process *
1474 GNUNET_OS_start_process_s (int pipe_control,
1475                            unsigned int std_inheritance,
1476                            const SOCKTYPE * lsocks,
1477                            const char *filename, ...)
1478 {
1479   va_list ap;
1480   char **argv;
1481   unsigned int argv_size;
1482   const char *arg;
1483   const char *rpos;
1484   char *pos;
1485   char *cp;
1486   const char *last;
1487   struct GNUNET_OS_Process *proc;
1488   char *binary_path;
1489   int quote_on;
1490   unsigned int i;
1491   size_t len;
1492
1493   argv_size = 1;
1494   va_start (ap, filename);
1495   arg = filename;
1496   last = NULL;
1497   do
1498   {
1499     rpos = arg;
1500     quote_on = 0;
1501     while ('\0' != *rpos)
1502     {
1503       if ('"' == *rpos)
1504       {
1505         if (1 == quote_on)
1506           quote_on = 0;
1507         else
1508           quote_on = 1;
1509       }
1510       if ( (' ' == *rpos) && (0 == quote_on) )
1511       {
1512         if (NULL != last)
1513           argv_size++;
1514         last = NULL;
1515         rpos++;
1516         while (' ' == *rpos)
1517           rpos++;
1518       }
1519       if ( (NULL == last) && ('\0' != *rpos) ) // FIXME: == or !=?
1520         last = rpos;
1521       if ('\0' != *rpos)
1522         rpos++;
1523     }
1524     if (NULL != last)
1525       argv_size++;
1526   }
1527   while (NULL != (arg = (va_arg (ap, const char*))));
1528   va_end (ap);
1529
1530   argv = GNUNET_malloc (argv_size * sizeof (char *));
1531   argv_size = 0;
1532   va_start (ap, filename);
1533   arg = filename;
1534   last = NULL;
1535   do
1536   {
1537     cp = GNUNET_strdup (arg);
1538     quote_on = 0;
1539     pos = cp;
1540     while ('\0' != *pos)
1541     {
1542       if ('"' == *pos)
1543       {
1544         if (1 == quote_on)
1545           quote_on = 0;
1546         else
1547           quote_on = 1;
1548       }
1549       if ( (' ' == *pos) && (0 == quote_on) )
1550       {
1551         *pos = '\0';
1552         if (NULL != last)
1553           argv[argv_size++] = GNUNET_strdup (last);
1554         last = NULL;
1555         pos++;
1556         while (' ' == *pos)
1557           pos++;
1558       }
1559       if ( (NULL == last) && ('\0' != *pos)) // FIXME: == or !=?
1560         last = pos;
1561       if ('\0' != *pos)
1562         pos++;
1563     }
1564     if (NULL != last)
1565       argv[argv_size++] = GNUNET_strdup (last);
1566     last = NULL;
1567     GNUNET_free (cp);
1568   }
1569   while (NULL != (arg = (va_arg (ap, const char*))));
1570   va_end (ap);
1571   argv[argv_size] = NULL;
1572
1573   for(i = 0; i < argv_size; i++)
1574   {
1575     len = strlen (argv[i]);
1576     if ( (argv[i][0] == '"') && (argv[i][len-1] == '"'))
1577     {
1578       memmove (&argv[i][0], &argv[i][1], len - 2);
1579       argv[i][len-2] = '\0';
1580     }
1581   }
1582   binary_path = argv[0];
1583   proc = GNUNET_OS_start_process_v (pipe_control, std_inheritance, lsocks,
1584                                     binary_path, argv);
1585   while (argv_size > 0)
1586     GNUNET_free (argv[--argv_size]);
1587   GNUNET_free (argv);
1588   return proc;
1589 }
1590
1591
1592 /**
1593  * Retrieve the status of a process, waiting on it if dead.
1594  * Nonblocking version.
1595  *
1596  * @param proc process ID
1597  * @param type status type
1598  * @param code return code/signal number
1599  * @param options WNOHANG if non-blocking is desired
1600  * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise
1601  */
1602 static int
1603 process_status (struct GNUNET_OS_Process *proc,
1604                 enum GNUNET_OS_ProcessStatusType *type,
1605                 unsigned long *code,
1606                 int options)
1607 {
1608 #ifndef MINGW
1609   int status;
1610   int ret;
1611
1612   GNUNET_assert (0 != proc);
1613   ret = waitpid (proc->pid, &status, options);
1614   if (ret < 0)
1615   {
1616     LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
1617                   "waitpid");
1618     return GNUNET_SYSERR;
1619   }
1620   if (0 == ret)
1621   {
1622     *type = GNUNET_OS_PROCESS_RUNNING;
1623     *code = 0;
1624     return GNUNET_NO;
1625   }
1626   if (proc->pid != ret)
1627   {
1628     LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
1629     return GNUNET_SYSERR;
1630   }
1631   if (WIFEXITED (status))
1632   {
1633     *type = GNUNET_OS_PROCESS_EXITED;
1634     *code = WEXITSTATUS (status);
1635   }
1636   else if (WIFSIGNALED (status))
1637   {
1638     *type = GNUNET_OS_PROCESS_SIGNALED;
1639     *code = WTERMSIG (status);
1640   }
1641   else if (WIFSTOPPED (status))
1642   {
1643     *type = GNUNET_OS_PROCESS_SIGNALED;
1644     *code = WSTOPSIG (status);
1645   }
1646 #ifdef WIFCONTINUED
1647   else if (WIFCONTINUED (status))
1648   {
1649     *type = GNUNET_OS_PROCESS_RUNNING;
1650     *code = 0;
1651   }
1652 #endif
1653   else
1654   {
1655     *type = GNUNET_OS_PROCESS_UNKNOWN;
1656     *code = 0;
1657   }
1658 #else
1659 #ifndef WNOHANG
1660 #define WNOHANG  42 /* just a flag for W32, purely internal at this point */
1661 #endif
1662
1663   HANDLE h;
1664   DWORD c, error_code, ret;
1665
1666   h = proc->handle;
1667   ret = proc->pid;
1668   if (h == NULL || ret == 0)
1669   {
1670     LOG (GNUNET_ERROR_TYPE_WARNING,
1671          "Invalid process information {%d, %08X}\n",
1672          ret, h);
1673     return GNUNET_SYSERR;
1674   }
1675   if (h == NULL)
1676     h = GetCurrentProcess ();
1677
1678   if (WNOHANG != options)
1679   {
1680     if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
1681     {
1682       SetErrnoFromWinError (GetLastError ());
1683       return GNUNET_SYSERR;
1684     }
1685   }
1686   SetLastError (0);
1687   ret = GetExitCodeProcess (h, &c);
1688   error_code = GetLastError ();
1689   if (ret == 0 || error_code != NO_ERROR)
1690   {
1691     SetErrnoFromWinError (error_code);
1692     LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
1693     return GNUNET_SYSERR;
1694   }
1695   if (STILL_ACTIVE == c)
1696   {
1697     *type = GNUNET_OS_PROCESS_RUNNING;
1698     *code = 0;
1699     return GNUNET_NO;
1700   }
1701   *type = GNUNET_OS_PROCESS_EXITED;
1702   *code = c;
1703 #endif
1704
1705   return GNUNET_OK;
1706 }
1707
1708
1709 /**
1710  * Retrieve the status of a process, waiting on it if dead.
1711  * Nonblocking version.
1712  *
1713  * @param proc process ID
1714  * @param type status type
1715  * @param code return code/signal number
1716  * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise
1717  */
1718 int
1719 GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
1720                           enum GNUNET_OS_ProcessStatusType *type,
1721                           unsigned long *code)
1722 {
1723   return process_status (proc,
1724                          type,
1725                          code,
1726                          WNOHANG);
1727 }
1728
1729
1730 /**
1731  * Retrieve the status of a process, waiting on it if dead.
1732  * Blocking version.
1733  *
1734  * @param proc pointer to process structure
1735  * @param type status type
1736  * @param code return code/signal number
1737  * @return #GNUNET_OK on success, #GNUNET_NO if the process is still running, #GNUNET_SYSERR otherwise
1738  */
1739 int
1740 GNUNET_OS_process_wait_status (struct GNUNET_OS_Process *proc,
1741                                enum GNUNET_OS_ProcessStatusType *type,
1742                                unsigned long *code)
1743 {
1744   return process_status (proc,
1745                          type,
1746                          code,
1747                          0);
1748 }
1749
1750
1751 /**
1752  * Wait for a process to terminate. The return code is discarded.
1753  * You must not use #GNUNET_OS_process_status() on the same process
1754  * after calling this function!  This function is blocking and should
1755  * thus only be used if the child process is known to have terminated
1756  * or to terminate very soon.
1757  *
1758  * @param proc pointer to process structure
1759  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
1760  */
1761 int
1762 GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
1763 {
1764 #ifndef MINGW
1765   pid_t pid = proc->pid;
1766   pid_t ret;
1767
1768   while ( (pid != (ret = waitpid (pid, NULL, 0))) &&
1769           (EINTR == errno) ) ;
1770   if (pid != ret)
1771   {
1772     LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
1773                   "waitpid");
1774     return GNUNET_SYSERR;
1775   }
1776   return GNUNET_OK;
1777 #else
1778   HANDLE h;
1779
1780   h = proc->handle;
1781   if (NULL == h)
1782   {
1783     LOG (GNUNET_ERROR_TYPE_WARNING,
1784          "Invalid process information {%d, %08X}\n",
1785          proc->pid, h);
1786     return GNUNET_SYSERR;
1787   }
1788   if (NULL == h)
1789     h = GetCurrentProcess ();
1790
1791   if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
1792   {
1793     SetErrnoFromWinError (GetLastError ());
1794     return GNUNET_SYSERR;
1795   }
1796   return GNUNET_OK;
1797 #endif
1798 }
1799
1800
1801 /**
1802  * Handle to a command.
1803  */
1804 struct GNUNET_OS_CommandHandle
1805 {
1806
1807   /**
1808    * Process handle.
1809    */
1810   struct GNUNET_OS_Process *eip;
1811
1812   /**
1813    * Handle to the output pipe.
1814    */
1815   struct GNUNET_DISK_PipeHandle *opipe;
1816
1817   /**
1818    * Read-end of output pipe.
1819    */
1820   const struct GNUNET_DISK_FileHandle *r;
1821
1822   /**
1823    * Function to call on each line of output.
1824    */
1825   GNUNET_OS_LineProcessor proc;
1826
1827   /**
1828    * Closure for @e proc.
1829    */
1830   void *proc_cls;
1831
1832   /**
1833    * Buffer for the output.
1834    */
1835   char buf[1024];
1836
1837   /**
1838    * Task reading from pipe.
1839    */
1840   struct GNUNET_SCHEDULER_Task *rtask;
1841
1842   /**
1843    * When to time out.
1844    */
1845   struct GNUNET_TIME_Absolute timeout;
1846
1847   /**
1848    * Current read offset in buf.
1849    */
1850   size_t off;
1851 };
1852
1853
1854 /**
1855  * Stop/kill a command.  Must ONLY be called either from
1856  * the callback after 'NULL' was passed for 'line' *OR*
1857  * from an independent task (not within the line processor).
1858  *
1859  * @param cmd handle to the process
1860  */
1861 void
1862 GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
1863 {
1864   if (NULL != cmd->proc)
1865   {
1866     GNUNET_assert (NULL != cmd->rtask);
1867     GNUNET_SCHEDULER_cancel (cmd->rtask);
1868   }
1869   (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
1870   GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (cmd->eip));
1871   GNUNET_OS_process_destroy (cmd->eip);
1872   GNUNET_DISK_pipe_close (cmd->opipe);
1873   GNUNET_free (cmd);
1874 }
1875
1876
1877 /**
1878  * Read from the process and call the line processor.
1879  *
1880  * @param cls the `struct GNUNET_OS_CommandHandle *`
1881  */
1882 static void
1883 cmd_read (void *cls)
1884 {
1885   struct GNUNET_OS_CommandHandle *cmd = cls;
1886   const struct GNUNET_SCHEDULER_TaskContext *tc;
1887   GNUNET_OS_LineProcessor proc;
1888   char *end;
1889   ssize_t ret;
1890
1891   cmd->rtask = NULL;
1892   tc = GNUNET_SCHEDULER_get_task_context ();
1893   if (GNUNET_YES !=
1894       GNUNET_NETWORK_fdset_handle_isset (tc->read_ready,
1895                                          cmd->r))
1896   {
1897     /* timeout */
1898     proc = cmd->proc;
1899     cmd->proc = NULL;
1900     proc (cmd->proc_cls, NULL);
1901     return;
1902   }
1903   ret = GNUNET_DISK_file_read (cmd->r,
1904                                &cmd->buf[cmd->off],
1905                                sizeof (cmd->buf) - cmd->off);
1906   if (ret <= 0)
1907   {
1908     if ((cmd->off > 0) && (cmd->off < sizeof (cmd->buf)))
1909     {
1910       cmd->buf[cmd->off] = '\0';
1911       cmd->proc (cmd->proc_cls, cmd->buf);
1912     }
1913     proc = cmd->proc;
1914     cmd->proc = NULL;
1915     proc (cmd->proc_cls, NULL);
1916     return;
1917   }
1918   end = memchr (&cmd->buf[cmd->off], '\n', ret);
1919   cmd->off += ret;
1920   while (NULL != end)
1921   {
1922     *end = '\0';
1923     cmd->proc (cmd->proc_cls, cmd->buf);
1924     memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
1925     cmd->off -= (end + 1 - cmd->buf);
1926     end = memchr (cmd->buf, '\n', cmd->off);
1927   }
1928   cmd->rtask
1929     = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
1930                                       (cmd->timeout),
1931                                       cmd->r,
1932                                       &cmd_read, cmd);
1933 }
1934
1935
1936 /**
1937  * Run the given command line and call the given function
1938  * for each line of the output.
1939  *
1940  * @param proc function to call for each line of the output
1941  * @param proc_cls closure for @a proc
1942  * @param timeout when to time out
1943  * @param binary command to run
1944  * @param ... arguments to command
1945  * @return NULL on error
1946  */
1947 struct GNUNET_OS_CommandHandle *
1948 GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc,
1949                        void *proc_cls,
1950                        struct GNUNET_TIME_Relative timeout,
1951                        const char *binary,
1952                        ...)
1953 {
1954   struct GNUNET_OS_CommandHandle *cmd;
1955   struct GNUNET_OS_Process *eip;
1956   struct GNUNET_DISK_PipeHandle *opipe;
1957   va_list ap;
1958
1959   opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES,
1960                             GNUNET_NO, GNUNET_YES);
1961   if (NULL == opipe)
1962     return NULL;
1963   va_start (ap, binary);
1964   /* redirect stdout, don't inherit stderr/stdin */
1965   eip = GNUNET_OS_start_process_va (GNUNET_NO, 0, NULL,
1966                                     opipe, NULL, binary,
1967                                     ap);
1968   va_end (ap);
1969   if (NULL == eip)
1970   {
1971     GNUNET_DISK_pipe_close (opipe);
1972     return NULL;
1973   }
1974   GNUNET_DISK_pipe_close_end (opipe, GNUNET_DISK_PIPE_END_WRITE);
1975   cmd = GNUNET_new (struct GNUNET_OS_CommandHandle);
1976   cmd->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1977   cmd->eip = eip;
1978   cmd->opipe = opipe;
1979   cmd->proc = proc;
1980   cmd->proc_cls = proc_cls;
1981   cmd->r = GNUNET_DISK_pipe_handle (opipe,
1982                                     GNUNET_DISK_PIPE_END_READ);
1983   cmd->rtask = GNUNET_SCHEDULER_add_read_file (timeout,
1984                                                cmd->r,
1985                                                &cmd_read,
1986                                                cmd);
1987   return cmd;
1988 }
1989
1990
1991 /* end of os_priority.c */