2 This file is part of GNUnet
3 (C) 2002, 2003, 2004, 2005, 2006, 2011 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
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 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file util/os_priority.c
23 * @brief Methods to set process priority
28 #include "gnunet_util_lib.h"
32 #define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
34 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
36 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
38 #define GNUNET_OS_CONTROL_PIPE "GNUNET_OS_CONTROL_PIPE"
41 struct GNUNET_OS_Process
56 * Pipe we use to signal the process.
57 * NULL if unused, or if process was deemed uncontrollable.
59 struct GNUNET_DISK_FileHandle *control_pipe;
64 * Handle for 'this' process.
66 static struct GNUNET_OS_Process current_process;
70 * This handler is called when there are control data to be read on the pipe
72 * @param cls the 'struct GNUNET_DISK_FileHandle' of the control pipe
73 * @param tc scheduler context
76 parent_control_handler (void *cls,
77 const struct GNUNET_SCHEDULER_TaskContext *tc)
79 struct GNUNET_DISK_FileHandle *control_pipe = cls;
84 LOG (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n", __FUNCTION__,
86 if (0 != (tc->reason &
87 (GNUNET_SCHEDULER_REASON_SHUTDOWN | GNUNET_SCHEDULER_REASON_TIMEOUT)))
89 GNUNET_DISK_file_close (control_pipe);
93 ret = GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig));
94 if (sizeof (sig) != ret)
97 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
98 LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing control pipe\n");
99 GNUNET_DISK_file_close (control_pipe);
103 pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE);
104 GNUNET_assert ( (NULL == pipe_fd) || (strlen (pipe_fd) <= 0) );
105 LOG (GNUNET_ERROR_TYPE_DEBUG,
106 "Got control code %d from parent via pipe %s\n", sig, pipe_fd);
107 GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
108 control_pipe, &parent_control_handler,
115 * Task that connects this process to its parent via pipe;
116 * essentially, the parent control handler will read signal numbers
117 * from the 'GNUNET_OS_CONTROL_PIPE' (as given in an environment
118 * variable) and raise those signals.
120 * @param cls closure (unused)
121 * @param tc scheduler context (unused)
124 GNUNET_OS_install_parent_control_handler (void *cls,
126 GNUNET_SCHEDULER_TaskContext *tc)
130 struct GNUNET_DISK_FileHandle *control_pipe;
133 env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
134 if ( (NULL == env_buf) || (strlen (env_buf) <= 0) )
136 LOG (GNUNET_ERROR_TYPE_DEBUG,
137 "Not installing a handler because $%s is empty\n",
138 GNUNET_OS_CONTROL_PIPE);
139 putenv (GNUNET_OS_CONTROL_PIPE "=");
143 pipe_fd = strtoull (env_buf, &env_buf_end, 16);
144 if ((0 != errno) || (env_buf == env_buf_end))
146 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf);
147 putenv (GNUNET_OS_CONTROL_PIPE "=");
150 #if !defined (WINDOWS)
151 if (pipe_fd >= FD_SETSIZE)
153 if ((FILE_TYPE_UNKNOWN == GetFileType ((HANDLE) (uintptr_t) pipe_fd))
154 && (0 != GetLastError ()))
157 LOG (GNUNET_ERROR_TYPE_ERROR,
158 "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n", env_buf);
159 putenv (GNUNET_OS_CONTROL_PIPE "=");
163 control_pipe = GNUNET_DISK_get_handle_from_w32_handle ((HANDLE) (uintptr_t) pipe_fd);
165 control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd);
167 if (NULL == control_pipe)
169 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
170 putenv (GNUNET_OS_CONTROL_PIPE "=");
173 LOG (GNUNET_ERROR_TYPE_DEBUG,
174 "Adding parent control handler pipe `%s' to the scheduler\n", env_buf);
175 GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, control_pipe,
176 &parent_control_handler, control_pipe);
177 putenv (GNUNET_OS_CONTROL_PIPE "=");
182 * Get process structure for current process
184 * The pointer it returns points to static memory location and must not be
187 * @return pointer to the process sturcutre for this process
189 struct GNUNET_OS_Process *
190 GNUNET_OS_process_current ()
193 current_process.pid = GetCurrentProcessId ();
194 current_process.handle = GetCurrentProcess ();
196 current_process.pid = 0;
198 return ¤t_process;
203 * Sends a signal to the process
205 * @param proc pointer to process structure
207 * @return 0 on success, -1 on error
210 GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
216 if (NULL != proc->control_pipe)
218 LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending signal %d to pid: %u via pipe\n", sig, proc->pid);
219 ret = GNUNET_DISK_file_write (proc->control_pipe, &csig, sizeof (csig));
220 if (sizeof (csig) == ret)
223 /* pipe failed or non-existent, try other methods */
226 #if !defined (WINDOWS)
232 #if (SIGTERM != GNUNET_TERM_SIG)
233 case GNUNET_TERM_SIG:
235 #if defined(WINDOWS) && !defined(__CYGWIN__)
238 int must_kill = GNUNET_YES;
239 if (0 != GetExitCodeProcess (proc->handle, &exitcode))
240 must_kill = (exitcode == STILL_ACTIVE) ? GNUNET_YES : GNUNET_NO;
241 if (GNUNET_YES == must_kill)
242 if (0 == SafeTerminateProcess (proc->handle, 0, 0))
244 DWORD error_code = GetLastError ();
245 if ((error_code != WAIT_TIMEOUT) && (error_code != ERROR_PROCESS_ABORTED))
247 LOG ((error_code == ERROR_ACCESS_DENIED) ?
248 GNUNET_ERROR_TYPE_INFO : GNUNET_ERROR_TYPE_WARNING,
249 "SafeTermiateProcess failed with code %lu\n", error_code);
250 /* The problem here is that a process that is already dying
251 * might cause SafeTerminateProcess to fail with
252 * ERROR_ACCESS_DENIED, but the process WILL die eventually.
253 * If we really had a permissions problem, hanging up (which
254 * is what will happen in process_wait() in that case) is
257 if (ERROR_ACCESS_DENIED == error_code)
263 SetErrnoFromWinError (error_code);
271 LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending signal %d to pid: %u via system call\n", sig, proc->pid);
272 return PLIBC_KILL (proc->pid, sig);
275 #if defined (WINDOWS)
279 LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending signal %d to pid: %u via system call\n", sig, proc->pid);
280 return PLIBC_KILL (proc->pid, sig);
286 * Get the pid of the process in question
288 * @param proc the process to get the pid of
290 * @return the current process id
293 GNUNET_OS_process_get_pid (struct GNUNET_OS_Process * proc)
300 * Cleans up process structure contents (OS-dependent) and deallocates it
302 * @param proc pointer to process structure
305 GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc)
307 if (NULL != proc->control_pipe)
308 GNUNET_DISK_file_close (proc->control_pipe);
309 #if defined (WINDOWS)
310 if (proc->handle != NULL)
311 CloseHandle (proc->handle);
317 #include "gnunet_signal_lib.h"
319 extern GNUNET_SIGNAL_Handler w32_sigchld_handler;
322 * Make seaspider happy.
324 #define DWORD_WINAPI DWORD WINAPI
327 * @brief Waits for a process to terminate and invokes the SIGCHLD handler
328 * @param proc pointer to process structure
331 child_wait_thread (void *arg)
333 struct GNUNET_OS_Process *proc = (struct GNUNET_OS_Process *) arg;
335 WaitForSingleObject (proc->handle, INFINITE);
337 if (w32_sigchld_handler)
338 w32_sigchld_handler ();
347 CreateCustomEnvTable (char **vars)
349 char *win32_env_table;
354 size_t tablesize = 0;
355 size_t items_count = 0;
364 win32_env_table = GetEnvironmentStringsA ();
365 if (NULL == win32_env_table)
367 for (c = 0, var_ptr = vars; *var_ptr; var_ptr += 2, c++) ;
369 index = GNUNET_malloc (sizeof (char *) * n_var);
370 for (c = 0; c < n_var; c++)
372 for (items_count = 0, ptr = win32_env_table; ptr[0] != 0; items_count++)
374 size_t len = strlen (ptr);
377 for (var_ptr = vars; *var_ptr; var_ptr++)
381 var_len = strlen (var);
382 if (strncmp (var, ptr, var_len) == 0)
386 tablesize += var_len + strlen (val) + 1;
391 tablesize += len + 1;
394 for (n_found = 0, c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
399 n_found += strlen (var) + strlen (val) + 1;
401 result = GNUNET_malloc (tablesize + n_found + 1);
402 for (result_ptr = result, ptr = win32_env_table; ptr[0] != 0;)
404 size_t len = strlen (ptr);
407 for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
411 var_len = strlen (var);
412 if (strncmp (var, ptr, var_len) == 0)
420 strcpy (result_ptr, ptr);
421 result_ptr += len + 1;
425 strcpy (result_ptr, var);
426 result_ptr += var_len;
427 strcpy (result_ptr, val);
428 result_ptr += strlen (val) + 1;
432 for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
436 var_len = strlen (var);
439 strcpy (result_ptr, var);
440 result_ptr += var_len;
441 strcpy (result_ptr, val);
442 result_ptr += strlen (val) + 1;
445 FreeEnvironmentStrings (win32_env_table);
454 * Open '/dev/null' and make the result the given
457 * @param target_fd desired FD to point to /dev/null
458 * @param flags open flags (O_RDONLY, O_WRONLY)
461 open_dev_null (int target_fd,
466 fd = open ("/dev/null", flags);
469 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", "/dev/null");
474 if (-1 == dup2 (fd, target_fd))
476 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
480 GNUNET_break (0 == close (fd));
488 * @param pipe_control should a pipe be used to send signals to the child?
489 * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags controlling which
490 * std handles of the parent are inherited by the child.
491 * pipe_stdin and pipe_stdout take priority over std_inheritance
492 * (when they are non-NULL).
493 * @param pipe_stdin pipe to use to send input to child process (or NULL)
494 * @param pipe_stdout pipe to use to get output from child process (or NULL)
495 * @param lsocks array of listen sockets to dup systemd-style (or NULL);
496 * must be NULL on platforms where dup is not supported
497 * @param filename name of the binary
498 * @param argv NULL-terminated list of arguments to the process
499 * @return process ID of the new process, -1 on error
501 static struct GNUNET_OS_Process *
502 start_process (int pipe_control,
503 enum GNUNET_OS_InheritStdioFlags std_inheritance,
504 struct GNUNET_DISK_PipeHandle *pipe_stdin,
505 struct GNUNET_DISK_PipeHandle *pipe_stdout,
506 const SOCKTYPE *lsocks,
507 const char *filename,
513 struct GNUNET_OS_Process *gnunet_proc;
514 struct GNUNET_DISK_FileHandle *childpipe_read;
515 struct GNUNET_DISK_FileHandle *childpipe_write;
516 int childpipe_read_fd;
529 if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
530 return NULL; /* not executable */
531 if (GNUNET_YES == pipe_control)
533 struct GNUNET_DISK_PipeHandle *childpipe;
534 int dup_childpipe_read_fd = -1;
536 childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
537 if (NULL == childpipe)
539 childpipe_read = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ);
540 childpipe_write = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE);
541 GNUNET_DISK_pipe_close (childpipe);
542 if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
543 (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
544 &childpipe_read_fd, sizeof (int))) ||
545 (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd))))
547 if (NULL != childpipe_read)
548 GNUNET_DISK_file_close (childpipe_read);
549 if (NULL != childpipe_write)
550 GNUNET_DISK_file_close (childpipe_write);
551 if (0 <= dup_childpipe_read_fd)
552 close (dup_childpipe_read_fd);
555 childpipe_read_fd = dup_childpipe_read_fd;
556 GNUNET_DISK_file_close (childpipe_read);
560 childpipe_write = NULL;
561 childpipe_read_fd = -1;
563 if (NULL != pipe_stdout)
565 GNUNET_assert (GNUNET_OK ==
566 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
568 GNUNET_DISK_PIPE_END_WRITE),
569 &fd_stdout_write, sizeof (int)));
570 GNUNET_assert (GNUNET_OK ==
571 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
572 (pipe_stdout, GNUNET_DISK_PIPE_END_READ),
573 &fd_stdout_read, sizeof (int)));
575 if (NULL != pipe_stdin)
577 GNUNET_assert (GNUNET_OK ==
578 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
579 (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
580 &fd_stdin_read, sizeof (int)));
581 GNUNET_assert (GNUNET_OK ==
582 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
583 (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE),
584 &fd_stdin_write, sizeof (int)));
591 while (-1 != (k = lsocks[i++]))
592 GNUNET_array_append (lscp, ls, k);
593 GNUNET_array_append (lscp, ls, -1);
596 /* see https://gnunet.org/vfork */
604 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
605 GNUNET_array_grow (lscp, ls, 0);
606 if (NULL != childpipe_write)
607 GNUNET_DISK_file_close (childpipe_write);
608 if (0 <= childpipe_read_fd)
609 close (childpipe_read_fd);
615 unsetenv (GNUNET_OS_CONTROL_PIPE);
616 gnunet_proc = GNUNET_new (struct GNUNET_OS_Process);
617 gnunet_proc->pid = ret;
618 gnunet_proc->control_pipe = childpipe_write;
619 if (GNUNET_YES == pipe_control)
621 close (childpipe_read_fd);
623 GNUNET_array_grow (lscp, ls, 0);
626 if (0 <= childpipe_read_fd)
630 /* due to vfork, we must NOT free memory on DARWIN! */
631 GNUNET_DISK_file_close (childpipe_write);
633 snprintf (fdbuf, 100, "%x", childpipe_read_fd);
634 setenv (GNUNET_OS_CONTROL_PIPE, fdbuf, 1);
637 unsetenv (GNUNET_OS_CONTROL_PIPE);
638 if (NULL != pipe_stdin)
640 GNUNET_break (0 == close (fd_stdin_write));
641 if (-1 == dup2 (fd_stdin_read, 0))
642 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
643 GNUNET_break (0 == close (fd_stdin_read));
645 else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN))
647 GNUNET_break (0 == close (0));
648 open_dev_null (0, O_RDONLY);
650 if (NULL != pipe_stdout)
652 GNUNET_break (0 == close (fd_stdout_read));
653 if (-1 == dup2 (fd_stdout_write, 1))
654 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
655 GNUNET_break (0 == close (fd_stdout_write));
657 else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT))
659 GNUNET_break (0 == close (1));
660 open_dev_null (1, O_WRONLY);
662 if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR))
664 GNUNET_break (0 == close (2));
665 open_dev_null (2, O_WRONLY);
669 /* read systemd documentation... */
672 while (-1 != lscp[i])
675 while (-1 != lscp[j])
681 GNUNET_assert (-1 != k);
682 GNUNET_assert (0 == close (lscp[j]));
690 /* Bury any existing FD, no matter what; they should all be closed
691 * on exec anyway and the important onces have been dup'ed away */
693 GNUNET_assert (-1 != dup2 (lscp[i], tgt));
695 /* unset close-on-exec flag */
696 flags = fcntl (tgt, F_GETFD);
697 GNUNET_assert (flags >= 0);
698 flags &= ~FD_CLOEXEC;
700 (void) fcntl (tgt, F_SETFD, flags);
704 GNUNET_snprintf (fds, sizeof (fds), "%u", i);
705 setenv ("LISTEN_FDS", fds, 1);
708 /* due to vfork, we must NOT free memory on DARWIN! */
709 GNUNET_array_grow (lscp, ls, 0);
711 execvp (filename, argv);
712 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
715 struct GNUNET_DISK_FileHandle *childpipe_read;
716 struct GNUNET_DISK_FileHandle *childpipe_write;
717 HANDLE childpipe_read_handle;
719 char **non_const_argv;
724 PROCESS_INFORMATION proc;
726 struct GNUNET_OS_Process *gnunet_proc;
727 char path[MAX_PATH + 1];
728 char *our_env[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
729 char *env_block = NULL;
737 char *non_const_filename;
738 char win_path[MAX_PATH + 1];
739 struct GNUNET_DISK_PipeHandle *lsocks_pipe;
740 const struct GNUNET_DISK_FileHandle *lsocks_write_fd;
751 HANDLE stdout_handle;
752 HANDLE stdih, stdoh, stdeh;
753 DWORD stdif, stdof, stdef;
757 if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL))
758 return NULL; /* not executable */
760 /* Search in prefix dir (hopefully - the directory from which
761 * the current module was loaded), bindir and libdir, then in PATH
763 self_prefix = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_SELF_PREFIX);
764 bindir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_BINDIR);
765 libdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
767 pathbuf_len = GetEnvironmentVariableA ("PATH", (char *) &pathbuf, 0);
770 pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
773 pathbuf = GNUNET_malloc (alloc_len * sizeof (char));
776 ptr += sprintf (pathbuf, "%s;%s;%s;", self_prefix, bindir, libdir);
777 GNUNET_free (self_prefix);
778 GNUNET_free (bindir);
779 GNUNET_free (libdir);
781 alloc_len = GetEnvironmentVariableA ("PATH", ptr, pathbuf_len);
782 if (alloc_len != pathbuf_len - 1)
784 GNUNET_free (pathbuf);
785 errno = ENOSYS; /* PATH changed on the fly. What kind of error is that? */
789 cmdlen = strlen (filename);
790 if ( (cmdlen < 5) || (0 != strcmp (&filename[cmdlen - 4], ".exe")) )
791 GNUNET_asprintf (&non_const_filename, "%s.exe", filename);
793 GNUNET_asprintf (&non_const_filename, "%s", filename);
795 /* It could be in POSIX form, convert it to a DOS path early on */
796 if (ERROR_SUCCESS != (lRet = plibc_conv_to_win_path (non_const_filename, win_path)))
798 SetErrnoFromWinError (lRet);
799 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "plibc_conv_to_win_path",
801 GNUNET_free (non_const_filename);
802 GNUNET_free (pathbuf);
805 GNUNET_free (non_const_filename);
806 non_const_filename = GNUNET_strdup (win_path);
807 /* Check that this is the full path. If it isn't, search. */
808 /* FIXME: convert it to wchar_t and use SearchPathW?
809 * Remember: arguments to _start_process() are technically in UTF-8...
811 if (non_const_filename[1] == ':')
813 snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename);
814 LOG (GNUNET_ERROR_TYPE_DEBUG,
815 "Using path `%s' as-is. PATH is %s\n", path, ptr);
817 else if (!SearchPathA
818 (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char),
821 SetErrnoFromWinError (GetLastError ());
822 LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath",
824 GNUNET_free (non_const_filename);
825 GNUNET_free (pathbuf);
829 LOG (GNUNET_ERROR_TYPE_DEBUG,
830 "Found `%s' in PATH `%s'\n", path, pathbuf);
831 GNUNET_free (pathbuf);
832 GNUNET_free (non_const_filename);
834 /* Count the number of arguments */
835 arg = (char **) argv;
842 /* Allocate a copy argv */
843 non_const_argv = GNUNET_malloc (sizeof (char *) * (argcount + 1));
845 /* Copy all argv strings */
847 arg = (char **) argv;
851 non_const_argv[argcount] = GNUNET_strdup (path);
853 non_const_argv[argcount] = GNUNET_strdup (*arg);
857 non_const_argv[argcount] = NULL;
861 arg = non_const_argv;
864 cmdlen = cmdlen + strlen (*arg) + 4;
868 /* Allocate and create cmd */
869 cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
870 arg = non_const_argv;
873 char arg_last_char = (*arg)[strlen (*arg) - 1];
874 idx += sprintf (idx, "\"%s%s\"%s", *arg,
875 arg_last_char == '\\' ? "\\" : "", *(arg + 1) ? " " : "");
880 GNUNET_free (non_const_argv[--argcount]);
881 GNUNET_free (non_const_argv);
883 memset (&start, 0, sizeof (start));
884 start.cb = sizeof (start);
885 if ((pipe_stdin != NULL) || (pipe_stdout != NULL) || (std_inheritance != 0))
886 start.dwFlags |= STARTF_USESTDHANDLES;
888 stdih = GetStdHandle (STD_INPUT_HANDLE);
889 GetHandleInformation (stdih, &stdif);
890 if (pipe_stdin != NULL)
892 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
893 (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
894 &stdin_handle, sizeof (HANDLE));
895 start.hStdInput = stdin_handle;
899 if (std_inheritance & GNUNET_OS_INHERIT_STD_IN)
901 SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 1);
902 if (pipe_stdin == NULL)
903 start.hStdInput = stdih;
906 SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 0);
910 stdoh = GetStdHandle (STD_OUTPUT_HANDLE);
911 GetHandleInformation (stdoh, &stdof);
912 if (NULL != pipe_stdout)
914 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
916 GNUNET_DISK_PIPE_END_WRITE),
917 &stdout_handle, sizeof (HANDLE));
918 start.hStdOutput = stdout_handle;
922 if (std_inheritance & GNUNET_OS_INHERIT_STD_OUT)
924 SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 1);
925 if (pipe_stdout == NULL)
926 start.hStdOutput = stdoh;
929 SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 0);
932 stdeh = GetStdHandle (STD_ERROR_HANDLE);
933 GetHandleInformation (stdeh, &stdef);
936 if (std_inheritance & GNUNET_OS_INHERIT_STD_ERR)
938 SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 1);
939 start.hStdError = stdeh;
942 SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 0);
945 if (GNUNET_YES == pipe_control)
947 struct GNUNET_DISK_PipeHandle *childpipe;
948 childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO);
949 if (NULL == childpipe)
951 childpipe_read = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ);
952 childpipe_write = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE);
953 GNUNET_DISK_pipe_close (childpipe);
954 if ((NULL == childpipe_read) || (NULL == childpipe_write) ||
955 (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read,
956 &childpipe_read_handle, sizeof (HANDLE))))
959 GNUNET_DISK_file_close (childpipe_read);
961 GNUNET_DISK_file_close (childpipe_write);
965 /* Unlike *nix variant, we don't dup the handle, so can't close
966 * filehandle right now.
968 SetHandleInformation (childpipe_read_handle, HANDLE_FLAG_INHERIT, 1);
972 childpipe_read = NULL;
973 childpipe_write = NULL;
976 if (lsocks != NULL && lsocks[0] != INVALID_SOCKET)
978 lsocks_pipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO);
980 if (lsocks_pipe == NULL)
983 GNUNET_DISK_pipe_close (lsocks_pipe);
984 if (GNUNET_YES == pipe_control)
986 GNUNET_DISK_file_close (childpipe_write);
987 GNUNET_DISK_file_close (childpipe_read);
991 lsocks_write_fd = GNUNET_DISK_pipe_handle (lsocks_pipe,
992 GNUNET_DISK_PIPE_END_WRITE);
993 GNUNET_DISK_internal_file_handle_ (lsocks_write_fd,
994 &lsocks_write, sizeof (HANDLE));
995 GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
996 (lsocks_pipe, GNUNET_DISK_PIPE_END_READ),
997 &lsocks_read, sizeof (HANDLE));
1003 if (GNUNET_YES == pipe_control)
1005 GNUNET_asprintf (&our_env[env_off++], "%s=", GNUNET_OS_CONTROL_PIPE);
1006 GNUNET_asprintf (&our_env[env_off++], "%p", childpipe_read_handle);
1008 if ( (lsocks != NULL) && (lsocks[0] != INVALID_SOCKET))
1010 /*This will tell the child that we're going to send lsocks over the pipe*/
1011 GNUNET_asprintf (&our_env[env_off++], "%s=", "GNUNET_OS_READ_LSOCKS");
1012 GNUNET_asprintf (&our_env[env_off++], "%lu", lsocks_read);
1014 our_env[env_off++] = NULL;
1015 env_block = CreateCustomEnvTable (our_env);
1017 GNUNET_free_non_null (our_env[--env_off]);
1020 if (NULL == (wpath = u8_to_u16 ((uint8_t *) path, 1 + strlen (path), NULL, &wpath_len)))
1022 LOG (GNUNET_ERROR_TYPE_DEBUG,
1023 "Failed to convert `%s' from UTF-8 to UTF-16: %d\n", path, errno);
1024 GNUNET_free (env_block);
1027 GNUNET_DISK_pipe_close (lsocks_pipe);
1028 if (GNUNET_YES == pipe_control)
1030 GNUNET_DISK_file_close (childpipe_write);
1031 GNUNET_DISK_file_close (childpipe_read);
1037 if (NULL == (wcmd = u8_to_u16 ((uint8_t *) cmd, 1 + strlen (cmd), NULL, &wcmd_len)))
1039 LOG (GNUNET_ERROR_TYPE_DEBUG,
1040 "Failed to convert `%s' from UTF-8 to UTF-16: %d\n", cmd, errno);
1041 GNUNET_free (env_block);
1045 GNUNET_DISK_pipe_close (lsocks_pipe);
1046 if (GNUNET_YES == pipe_control)
1048 GNUNET_DISK_file_close (childpipe_write);
1049 GNUNET_DISK_file_close (childpipe_read);
1054 bresult = CreateProcessW (wpath, wcmd, NULL, NULL, GNUNET_YES,
1055 CREATE_NO_WINDOW | CREATE_SUSPENDED, env_block, NULL, &start, &proc);
1056 error_code = GetLastError ();
1058 if ((NULL == pipe_stdin) && (stdih))
1059 SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, stdif);
1062 if ((NULL == pipe_stdout) && (stdoh))
1063 SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, stdof);
1066 SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, stdef);
1069 LOG (GNUNET_ERROR_TYPE_ERROR, "CreateProcess(%s, %s) failed: %lu\n", path, cmd, error_code);
1071 GNUNET_free (env_block);
1075 if (GNUNET_YES == pipe_control)
1077 GNUNET_DISK_file_close (childpipe_read);
1082 if (GNUNET_YES == pipe_control)
1084 GNUNET_DISK_file_close (childpipe_write);
1087 GNUNET_DISK_pipe_close (lsocks_pipe);
1088 SetErrnoFromWinError (error_code);
1092 gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process));
1093 gnunet_proc->pid = proc.dwProcessId;
1094 gnunet_proc->handle = proc.hProcess;
1095 gnunet_proc->control_pipe = childpipe_write;
1097 CreateThread (NULL, 64000, &child_wait_thread, (void *) gnunet_proc, 0, NULL);
1099 ResumeThread (proc.hThread);
1100 CloseHandle (proc.hThread);
1102 if ( (NULL == lsocks) || (INVALID_SOCKET == lsocks[0]) )
1105 GNUNET_DISK_pipe_close_end (lsocks_pipe, GNUNET_DISK_PIPE_END_READ);
1107 /* This is a replacement for "goto error" that doesn't use goto */
1116 /* Tell the number of sockets */
1117 for (count = 0; lsocks && lsocks[count] != INVALID_SOCKET; count++);
1119 wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count));
1120 if (sizeof (count) != wrote)
1122 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1123 "Failed to write %u count bytes to the child: %u\n",
1124 sizeof (count), GetLastError ());
1127 for (i = 0; lsocks && lsocks[i] != INVALID_SOCKET; i++)
1129 WSAPROTOCOL_INFOA pi;
1130 /* Get a socket duplication info */
1131 if (SOCKET_ERROR == WSADuplicateSocketA (lsocks[i], gnunet_proc->pid, &pi))
1133 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1134 "Failed to duplicate an socket[%llu]: %u\n", i,
1138 /* Synchronous I/O is not nice, but we can't schedule this:
1139 * lsocks will be closed/freed by the caller soon, and until
1140 * the child creates a duplicate, closing a socket here will
1141 * close it for good.
1143 /* Send the size of the structure
1144 * (the child might be built with different headers...)
1147 wrote = GNUNET_DISK_file_write (lsocks_write_fd, &size, sizeof (size));
1148 if (sizeof (size) != wrote)
1150 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1151 "Failed to write %u size[%llu] bytes to the child: %u\n",
1152 sizeof (size), i, GetLastError ());
1155 /* Finally! Send the data */
1156 wrote = GNUNET_DISK_file_write (lsocks_write_fd, &pi, sizeof (pi));
1157 if (sizeof (pi) != wrote)
1159 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1160 "Failed to write %u socket[%llu] bytes to the child: %u\n",
1161 sizeof (pi), i, GetLastError ());
1165 /* This will block us until the child makes a final read or closes
1166 * the pipe (hence no 'wrote' check), since we have to wait for it
1167 * to duplicate the last socket, before we return and start closing
1170 wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count));
1175 GNUNET_DISK_file_sync (lsocks_write_fd);
1176 GNUNET_DISK_pipe_close (lsocks_pipe);
1180 /* If we can't pass on the socket(s), the child will block forever,
1181 * better put it out of its misery.
1183 SafeTerminateProcess (gnunet_proc->handle, 0, 0);
1184 CloseHandle (gnunet_proc->handle);
1185 if (NULL != gnunet_proc->control_pipe)
1186 GNUNET_DISK_file_close (gnunet_proc->control_pipe);
1187 GNUNET_free (gnunet_proc);
1200 * @param pipe_control should a pipe be used to send signals to the child?
1201 * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1202 * @param pipe_stdin pipe to use to send input to child process (or NULL)
1203 * @param pipe_stdout pipe to use to get output from child process (or NULL)
1204 * @param filename name of the binary
1205 * @param argv NULL-terminated array of arguments to the process
1206 * @return pointer to process structure of the new process, NULL on error
1208 struct GNUNET_OS_Process *
1209 GNUNET_OS_start_process_vap (int pipe_control,
1210 enum GNUNET_OS_InheritStdioFlags std_inheritance,
1211 struct GNUNET_DISK_PipeHandle *pipe_stdin,
1212 struct GNUNET_DISK_PipeHandle *pipe_stdout,
1213 const char *filename,
1216 return start_process (pipe_control,
1229 * @param pipe_control should a pipe be used to send signals to the child?
1230 * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1231 * @param pipe_stdin pipe to use to send input to child process (or NULL)
1232 * @param pipe_stdout pipe to use to get output from child process (or NULL)
1233 * @param filename name of the binary
1234 * @param va NULL-terminated list of arguments to the process
1235 * @return pointer to process structure of the new process, NULL on error
1237 struct GNUNET_OS_Process *
1238 GNUNET_OS_start_process_va (int pipe_control,
1239 enum GNUNET_OS_InheritStdioFlags std_inheritance,
1240 struct GNUNET_DISK_PipeHandle *pipe_stdin,
1241 struct GNUNET_DISK_PipeHandle *pipe_stdout,
1242 const char *filename, va_list va)
1244 struct GNUNET_OS_Process *ret;
1251 while (NULL != va_arg (ap, char *))
1254 argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
1257 while (NULL != (argv[argc] = va_arg (ap, char *)))
1260 ret = GNUNET_OS_start_process_vap (pipe_control,
1274 * @param pipe_control should a pipe be used to send signals to the child?
1275 * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags
1276 * @param pipe_stdin pipe to use to send input to child process (or NULL)
1277 * @param pipe_stdout pipe to use to get output from child process (or NULL)
1278 * @param filename name of the binary
1279 * @param ... NULL-terminated list of arguments to the process
1280 * @return pointer to process structure of the new process, NULL on error
1282 struct GNUNET_OS_Process *
1283 GNUNET_OS_start_process (int pipe_control,
1284 enum GNUNET_OS_InheritStdioFlags std_inheritance,
1285 struct GNUNET_DISK_PipeHandle *pipe_stdin,
1286 struct GNUNET_DISK_PipeHandle *pipe_stdout,
1287 const char *filename, ...)
1289 struct GNUNET_OS_Process *ret;
1292 va_start (ap, filename);
1293 ret = GNUNET_OS_start_process_va (pipe_control, std_inheritance, pipe_stdin,
1294 pipe_stdout, filename, ap);
1303 * @param pipe_control should a pipe be used to send signals to the child?
1304 * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags controlling which
1305 * std handles of the parent are inherited by the child.
1306 * pipe_stdin and pipe_stdout take priority over std_inheritance
1307 * (when they are non-NULL).
1308 * @param lsocks array of listen sockets to dup systemd-style (or NULL);
1309 * must be NULL on platforms where dup is not supported
1310 * @param filename name of the binary
1311 * @param argv NULL-terminated list of arguments to the process
1312 * @return process ID of the new process, -1 on error
1314 struct GNUNET_OS_Process *
1315 GNUNET_OS_start_process_v (int pipe_control,
1316 enum GNUNET_OS_InheritStdioFlags std_inheritance,
1317 const SOCKTYPE *lsocks,
1318 const char *filename,
1321 return start_process (pipe_control,
1332 * Retrieve the status of a process, waiting on him if dead.
1333 * Nonblocking version.
1335 * @param proc process ID
1336 * @param type status type
1337 * @param code return code/signal number
1338 * @return GNUNET_OK on success, GNUNET_NO if the process is still running, GNUNET_SYSERR otherwise
1341 GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
1342 enum GNUNET_OS_ProcessStatusType *type,
1343 unsigned long *code)
1349 GNUNET_assert (0 != proc);
1350 ret = waitpid (proc->pid, &status, WNOHANG);
1353 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
1354 return GNUNET_SYSERR;
1358 *type = GNUNET_OS_PROCESS_RUNNING;
1362 if (proc->pid != ret)
1364 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
1365 return GNUNET_SYSERR;
1367 if (WIFEXITED (status))
1369 *type = GNUNET_OS_PROCESS_EXITED;
1370 *code = WEXITSTATUS (status);
1372 else if (WIFSIGNALED (status))
1374 *type = GNUNET_OS_PROCESS_SIGNALED;
1375 *code = WTERMSIG (status);
1377 else if (WIFSTOPPED (status))
1379 *type = GNUNET_OS_PROCESS_SIGNALED;
1380 *code = WSTOPSIG (status);
1383 else if (WIFCONTINUED (status))
1385 *type = GNUNET_OS_PROCESS_RUNNING;
1391 *type = GNUNET_OS_PROCESS_UNKNOWN;
1396 DWORD c, error_code, ret;
1400 if (h == NULL || ret == 0)
1402 LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid process information {%d, %08X}\n",
1404 return GNUNET_SYSERR;
1407 h = GetCurrentProcess ();
1410 ret = GetExitCodeProcess (h, &c);
1411 error_code = GetLastError ();
1412 if (ret == 0 || error_code != NO_ERROR)
1414 SetErrnoFromWinError (error_code);
1415 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
1416 return GNUNET_SYSERR;
1418 if (STILL_ACTIVE == c)
1420 *type = GNUNET_OS_PROCESS_RUNNING;
1424 *type = GNUNET_OS_PROCESS_EXITED;
1433 * Wait for a process
1435 * @param proc pointer to process structure
1436 * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
1439 GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
1442 pid_t pid = proc->pid;
1445 while ( (pid != (ret = waitpid (pid, NULL, 0))) &&
1446 (EINTR == errno) ) ;
1449 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
1450 return GNUNET_SYSERR;
1459 LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid process information {%d, %08X}\n",
1461 return GNUNET_SYSERR;
1464 h = GetCurrentProcess ();
1466 if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
1468 SetErrnoFromWinError (GetLastError ());
1469 return GNUNET_SYSERR;
1477 * Handle to a command.
1479 struct GNUNET_OS_CommandHandle
1485 struct GNUNET_OS_Process *eip;
1488 * Handle to the output pipe.
1490 struct GNUNET_DISK_PipeHandle *opipe;
1493 * Read-end of output pipe.
1495 const struct GNUNET_DISK_FileHandle *r;
1498 * Function to call on each line of output.
1500 GNUNET_OS_LineProcessor proc;
1503 * Closure for 'proc'.
1508 * Buffer for the output.
1513 * Task reading from pipe.
1515 GNUNET_SCHEDULER_TaskIdentifier rtask;
1520 struct GNUNET_TIME_Absolute timeout;
1523 * Current read offset in buf.
1530 * Stop/kill a command. Must ONLY be called either from
1531 * the callback after 'NULL' was passed for 'line' *OR*
1532 * from an independent task (not within the line processor).
1534 * @param cmd handle to the process
1537 GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
1539 if (NULL != cmd->proc)
1541 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cmd->rtask);
1542 GNUNET_SCHEDULER_cancel (cmd->rtask);
1544 (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
1545 GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (cmd->eip));
1546 GNUNET_OS_process_destroy (cmd->eip);
1547 GNUNET_DISK_pipe_close (cmd->opipe);
1553 * Read from the process and call the line processor.
1555 * @param cls the 'struct GNUNET_OS_CommandHandle'
1556 * @param tc scheduler context
1559 cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1561 struct GNUNET_OS_CommandHandle *cmd = cls;
1562 GNUNET_OS_LineProcessor proc;
1566 cmd->rtask = GNUNET_SCHEDULER_NO_TASK;
1567 if (GNUNET_YES != GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, cmd->r))
1569 /* timeout, shutdown, etc. */
1572 proc (cmd->proc_cls, NULL);
1576 GNUNET_DISK_file_read (cmd->r, &cmd->buf[cmd->off],
1577 sizeof (cmd->buf) - cmd->off);
1580 if ((cmd->off > 0) && (cmd->off < sizeof (cmd->buf)))
1582 cmd->buf[cmd->off] = '\0';
1583 cmd->proc (cmd->proc_cls, cmd->buf);
1587 proc (cmd->proc_cls, NULL);
1590 end = memchr (&cmd->buf[cmd->off], '\n', ret);
1595 cmd->proc (cmd->proc_cls, cmd->buf);
1596 memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
1597 cmd->off -= (end + 1 - cmd->buf);
1598 end = memchr (cmd->buf, '\n', cmd->off);
1601 GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
1602 (cmd->timeout), cmd->r, &cmd_read, cmd);
1607 * Run the given command line and call the given function
1608 * for each line of the output.
1610 * @param proc function to call for each line of the output
1611 * @param proc_cls closure for proc
1612 * @param timeout when to time out
1613 * @param binary command to run
1614 * @param ... arguments to command
1615 * @return NULL on error
1617 struct GNUNET_OS_CommandHandle *
1618 GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls,
1619 struct GNUNET_TIME_Relative timeout, const char *binary,
1622 struct GNUNET_OS_CommandHandle *cmd;
1623 struct GNUNET_OS_Process *eip;
1624 struct GNUNET_DISK_PipeHandle *opipe;
1627 opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES);
1630 va_start (ap, binary);
1631 /* redirect stdout, don't inherit stderr/stdin */
1632 eip = GNUNET_OS_start_process_va (GNUNET_NO, 0, NULL, opipe, binary, ap);
1636 GNUNET_DISK_pipe_close (opipe);
1639 GNUNET_DISK_pipe_close_end (opipe, GNUNET_DISK_PIPE_END_WRITE);
1640 cmd = GNUNET_malloc (sizeof (struct GNUNET_OS_CommandHandle));
1641 cmd->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1645 cmd->proc_cls = proc_cls;
1646 cmd->r = GNUNET_DISK_pipe_handle (opipe, GNUNET_DISK_PIPE_END_READ);
1647 cmd->rtask = GNUNET_SCHEDULER_add_read_file (timeout, cmd->r, &cmd_read, cmd);
1652 /* end of os_priority.c */