X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Futil%2Fos_priority.c;h=5946f2b3d4b32ae4ad256a0859bb64631c906742;hb=72c8645af31896829b674b575c5375706f362a30;hp=55a728ce6eb0e892bf1807fb0a1fbd474b821451;hpb=16a6919a9f98ee9fa1fee9dd262906c321004a19;p=oweals%2Fgnunet.git diff --git a/src/util/os_priority.c b/src/util/os_priority.c index 55a728ce6..5946f2b3d 100644 --- a/src/util/os_priority.c +++ b/src/util/os_priority.c @@ -28,20 +28,45 @@ #include "gnunet_common.h" #include "gnunet_os_lib.h" #include "gnunet_scheduler_lib.h" +#include "gnunet_strings_lib.h" +#include "gnunet_crypto_lib.h" #include "disk.h" +#include + +#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__) + +#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall) + +#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename) #define GNUNET_OS_CONTROL_PIPE "GNUNET_OS_CONTROL_PIPE" + struct GNUNET_OS_Process { + /** + * PID of the process. + */ pid_t pid; + #if WINDOWS + /** + * Process handle. + */ HANDLE handle; #endif - int sig; + + /** + * Pipe we use to signal the process. + * NULL if unused, or if process was deemed uncontrollable. + */ struct GNUNET_DISK_FileHandle *control_pipe; }; + +/** + * Handle for 'this' process. + */ static struct GNUNET_OS_Process current_process; @@ -55,45 +80,49 @@ static void parent_control_handler (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { - struct GNUNET_DISK_FileHandle *control_pipe = - (struct GNUNET_DISK_FileHandle *) cls; - int sig; - -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n", - __FUNCTION__, tc->reason); -#endif - if (tc->reason & - (GNUNET_SCHEDULER_REASON_SHUTDOWN | GNUNET_SCHEDULER_REASON_TIMEOUT | - GNUNET_SCHEDULER_REASON_PREREQ_DONE)) + struct GNUNET_DISK_FileHandle *control_pipe = cls; + char sig; + char *pipe_fd; + ssize_t ret; + + LOG (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n", __FUNCTION__, + tc->reason); + if (0 != (tc->reason & + (GNUNET_SCHEDULER_REASON_SHUTDOWN | GNUNET_SCHEDULER_REASON_TIMEOUT))) { - GNUNET_DISK_npipe_close (control_pipe); + GNUNET_DISK_file_close (control_pipe); + control_pipe = NULL; + return; } - else + ret = GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig)); + if (sizeof (sig) != ret) { - if (GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig)) != - sizeof (sig)) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read"); - GNUNET_DISK_npipe_close (control_pipe); - } - else - { -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got control code %d from parent\n", - sig); -#endif - GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, - control_pipe, &parent_control_handler, - control_pipe); - raise (sig); - } + if (-1 == ret) + LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read"); + LOG (GNUNET_ERROR_TYPE_WARNING, "Closing control pipe\n"); + GNUNET_DISK_file_close (control_pipe); + control_pipe = NULL; + return; } + pipe_fd = getenv (GNUNET_OS_CONTROL_PIPE); + GNUNET_assert ( (NULL == pipe_fd) || (strlen (pipe_fd) <= 0) ); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Got control code %d from parent via pipe %s\n", sig, pipe_fd); + GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, + control_pipe, &parent_control_handler, + control_pipe); + raise ((int) sig); } /** - * Task that connects this process to its parent via pipe + * Task that connects this process to its parent via pipe; + * essentially, the parent control handler will read signal numbers + * from the 'GNUNET_OS_CONTROL_PIPE' (as given in an environment + * variable) and raise those signals. + * + * @param cls closure (unused) + * @param tc scheduler context (unused) */ void GNUNET_OS_install_parent_control_handler (void *cls, @@ -101,32 +130,55 @@ GNUNET_OS_install_parent_control_handler (void *cls, GNUNET_SCHEDULER_TaskContext *tc) { const char *env_buf; + char *env_buf_end; struct GNUNET_DISK_FileHandle *control_pipe; + uint64_t pipe_fd; env_buf = getenv (GNUNET_OS_CONTROL_PIPE); - if ((env_buf == NULL) || (strlen (env_buf) <= 0)) + if ( (NULL == env_buf) || (strlen (env_buf) <= 0) ) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Not installing a handler because $%s is empty\n", + GNUNET_OS_CONTROL_PIPE); + putenv (GNUNET_OS_CONTROL_PIPE "="); + return; + } + errno = 0; + pipe_fd = strtoull (env_buf, &env_buf_end, 16); + if ((0 != errno) || (env_buf == env_buf_end)) { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - _("Not installing a handler because $%s=%s\n"), - GNUNET_OS_CONTROL_PIPE, env_buf); + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "strtoull", env_buf); + putenv (GNUNET_OS_CONTROL_PIPE "="); return; } - control_pipe = - GNUNET_DISK_npipe_open (env_buf, GNUNET_DISK_OPEN_READ, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (control_pipe == NULL) +#if !defined (WINDOWS) + if (pipe_fd >= FD_SETSIZE) +#else + if ((FILE_TYPE_UNKNOWN == GetFileType ((HANDLE) (uintptr_t) pipe_fd)) + && (0 != GetLastError ())) +#endif { - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", env_buf); + LOG (GNUNET_ERROR_TYPE_ERROR, + "GNUNET_OS_CONTROL_PIPE `%s' contains garbage?\n", env_buf); + putenv (GNUNET_OS_CONTROL_PIPE "="); return; } -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Adding parent control handler pipe `%s' to the scheduler\n", - env_buf); +#if WINDOWS + control_pipe = GNUNET_DISK_get_handle_from_w32_handle ((HANDLE) (uintptr_t) pipe_fd); +#else + control_pipe = GNUNET_DISK_get_handle_from_int_fd ((int) pipe_fd); #endif + if (NULL == control_pipe) + { + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf); + putenv (GNUNET_OS_CONTROL_PIPE "="); + return; + } + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Adding parent control handler pipe `%s' to the scheduler\n", env_buf); GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, control_pipe, &parent_control_handler, control_pipe); + putenv (GNUNET_OS_CONTROL_PIPE "="); } @@ -151,104 +203,84 @@ GNUNET_OS_process_current () } +/** + * Sends a signal to the process + * + * @param proc pointer to process structure + * @param sig signal + * @return 0 on success, -1 on error + */ int GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig) { -#if ENABLE_WINDOWS_WORKAROUNDS - int res = 0; - int ret = 0; + int ret; + char csig; - ret = GNUNET_DISK_file_write (proc->control_pipe, &sig, sizeof (sig)); - if (ret != sizeof (sig)) + csig = (char) sig; + if (NULL != proc->control_pipe) { - if (errno == ECOMM) - { - /* Child process is not controllable via pipe */ -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Child process is not controllable, will kill it directly\n"); -#endif - } - else if (errno == EPIPE) - { -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Failed to write into control pipe, because pipe is invalid (the child is most likely dead)\n"); -#endif - } - else - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Failed to write into control pipe , errno is %d\n", errno); -#if WINDOWS && !defined(__CYGWIN__) - TerminateProcess (proc->handle, 0); -#else - PLIBC_KILL (proc->pid, sig); -#endif + LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending signal %d to pid: %u via pipe\n", sig, proc->pid); + ret = GNUNET_DISK_file_write (proc->control_pipe, &csig, sizeof (csig)); + if (sizeof (csig) == ret) + return 0; } - else + /* pipe failed or non-existent, try other methods */ + switch (sig) { -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Wrote control code into control pipe, now waiting\n"); +#if !defined (WINDOWS) + case SIGHUP: #endif - -#if WINDOWS - /* Give it 3 seconds to die, then kill it in a nice Windows-specific way */ - if (WaitForSingleObject (proc->handle, 3000) != WAIT_OBJECT_0) - TerminateProcess (proc->handle, 0); - res = 0; -#else - struct GNUNET_NETWORK_FDSet *rfds; - struct GNUNET_NETWORK_FDSet *efds; - - rfds = GNUNET_NETWORK_fdset_create (); - efds = GNUNET_NETWORK_fdset_create (); - - GNUNET_NETWORK_fdset_handle_set (rfds, proc->control_pipe); - GNUNET_NETWORK_fdset_handle_set (efds, proc->control_pipe); - - /* Ndurner thought this up, and i have no idea what it does. - * There's have never been any code to answer the shutdown call - * (write a single int into the pipe, so that this function can read it). - * On *nix select() will probably tell that pipe is ready - * for reading, once the other process shuts down, - * but the read () call will fail, triggering a kill () - * on the pid that is already dead. This will probably result in non-0 - * return from kill(), and therefore from this function. - */ - while (1) + case SIGINT: + case SIGKILL: + case SIGTERM: +#if defined(WINDOWS) && !defined(__CYGWIN__) { - ret = - GNUNET_NETWORK_socket_select (rfds, NULL, efds, - GNUNET_TIME_relative_multiply - (GNUNET_TIME_relative_get_unit (), - 5000)); - - if (ret < 1 || - GNUNET_NETWORK_fdset_handle_isset (efds, proc->control_pipe)) - { - /* Just to be sure */ - PLIBC_KILL (proc->pid, sig); - res = 0; - break; - } - else - { - if (GNUNET_DISK_file_read (proc->control_pipe, &ret, sizeof (ret)) != - GNUNET_OK) - res = PLIBC_KILL (proc->pid, sig); - - /* Child signaled shutdown is in progress */ - continue; - } + DWORD exitcode; + int must_kill = GNUNET_YES; + if (0 != GetExitCodeProcess (proc->handle, &exitcode)) + must_kill = (exitcode == STILL_ACTIVE) ? GNUNET_YES : GNUNET_NO; + if (GNUNET_YES == must_kill) + if (0 == SafeTerminateProcess (proc->handle, 0, 0)) + { + DWORD error_code = GetLastError (); + if ((error_code != WAIT_TIMEOUT) && (error_code != ERROR_PROCESS_ABORTED)) + { + LOG ((error_code == ERROR_ACCESS_DENIED) ? + GNUNET_ERROR_TYPE_INFO : GNUNET_ERROR_TYPE_WARNING, + "SafeTermiateProcess failed with code %lu\n", error_code); + /* The problem here is that a process that is already dying + * might cause SafeTerminateProcess to fail with + * ERROR_ACCESS_DENIED, but the process WILL die eventually. + * If we really had a permissions problem, hanging up (which + * is what will happen in process_wait() in that case) is + * a valid option. + */ + if (ERROR_ACCESS_DENIED == error_code) + { + errno = 0; + } + else + { + SetErrnoFromWinError (error_code); + return -1; + } + } + } } -#endif - } - - return res; + return 0; #else - return kill (proc->pid, sig); + LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending signal %d to pid: %u via system call\n", sig, proc->pid); + return PLIBC_KILL (proc->pid, sig); #endif + default: +#if defined (WINDOWS) + errno = EINVAL; + return -1; +#else + LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending signal %d to pid: %u via system call\n", sig, proc->pid); + return PLIBC_KILL (proc->pid, sig); +#endif + } } /** @@ -265,22 +297,23 @@ GNUNET_OS_process_get_pid (struct GNUNET_OS_Process * proc) } +/** + * Cleans up process structure contents (OS-dependent) and deallocates it + * + * @param proc pointer to process structure + */ void -GNUNET_OS_process_close (struct GNUNET_OS_Process *proc) +GNUNET_OS_process_destroy (struct GNUNET_OS_Process *proc) { -#if ENABLE_WINDOWS_WORKAROUNDS - if (proc->control_pipe) - GNUNET_DISK_npipe_close (proc->control_pipe); -#endif -// FIXME NILS -#ifdef WINDOWS + if (NULL != proc->control_pipe) + GNUNET_DISK_file_close (proc->control_pipe); +#if defined (WINDOWS) if (proc->handle != NULL) CloseHandle (proc->handle); #endif GNUNET_free (proc); } -// FIXME NILS #if WINDOWS #include "gnunet_signal_lib.h" @@ -296,7 +329,7 @@ extern GNUNET_SIGNAL_Handler w32_sigchld_handler; * @param proc pointer to process structure */ static DWORD_WINAPI -ChildWaitThread (void *arg) +child_wait_thread (void *arg) { struct GNUNET_OS_Process *proc = (struct GNUNET_OS_Process *) arg; @@ -309,122 +342,20 @@ ChildWaitThread (void *arg) } #endif -/** - * Set process priority - * - * @param proc pointer to process structure - * @param prio priority value - * @return GNUNET_OK on success, GNUNET_SYSERR on error - */ -int -GNUNET_OS_set_process_priority (struct GNUNET_OS_Process *proc, - enum GNUNET_SCHEDULER_Priority prio) -{ - int rprio; - - GNUNET_assert (prio < GNUNET_SCHEDULER_PRIORITY_COUNT); - if (prio == GNUNET_SCHEDULER_PRIORITY_KEEP) - return GNUNET_OK; - - /* convert to MINGW/Unix values */ - switch (prio) - { - case GNUNET_SCHEDULER_PRIORITY_UI: - case GNUNET_SCHEDULER_PRIORITY_URGENT: -#ifdef MINGW - rprio = HIGH_PRIORITY_CLASS; -#else - rprio = 0; -#endif - break; - - case GNUNET_SCHEDULER_PRIORITY_HIGH: -#ifdef MINGW - rprio = ABOVE_NORMAL_PRIORITY_CLASS; -#else - rprio = 5; -#endif - break; - - case GNUNET_SCHEDULER_PRIORITY_DEFAULT: -#ifdef MINGW - rprio = NORMAL_PRIORITY_CLASS; -#else - rprio = 7; -#endif - break; - - case GNUNET_SCHEDULER_PRIORITY_BACKGROUND: -#ifdef MINGW - rprio = BELOW_NORMAL_PRIORITY_CLASS; -#else - rprio = 10; -#endif - break; - - case GNUNET_SCHEDULER_PRIORITY_IDLE: -#ifdef MINGW - rprio = IDLE_PRIORITY_CLASS; -#else - rprio = 19; -#endif - break; - default: - GNUNET_assert (0); - return GNUNET_SYSERR; - } - - /* Set process priority */ -#ifdef MINGW - { - HANDLE h = proc->handle; - - GNUNET_assert (h != NULL); - SetPriorityClass (h, rprio); - } -#elif LINUX - pid_t pid; - - pid = proc->pid; - if ((0 == pid) || (pid == getpid ())) - { - int have = nice (0); - int delta = rprio - have; - - errno = 0; - if ((delta != 0) && (rprio == nice (delta)) && (errno != 0)) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, - "nice"); - return GNUNET_SYSERR; - } - } - else - { - if (0 != setpriority (PRIO_PROCESS, pid, rprio)) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, - "setpriority"); - return GNUNET_SYSERR; - } - } -#else -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK, - "Priority management not availabe for this platform\n"); -#endif -#endif - return GNUNET_OK; -} #if MINGW static char * CreateCustomEnvTable (char **vars) { - char *win32_env_table, *ptr, **var_ptr, *result, *result_ptr; + char *win32_env_table; + char *ptr; + char **var_ptr; + char *result; + char *result_ptr; size_t tablesize = 0; size_t items_count = 0; - size_t n_found = 0, n_var; + size_t n_found = 0; + size_t n_var; char *index = NULL; size_t c; size_t var_len; @@ -432,7 +363,7 @@ CreateCustomEnvTable (char **vars) char *val; win32_env_table = GetEnvironmentStringsA (); - if (win32_env_table == NULL) + if (NULL == win32_env_table) return NULL; for (c = 0, var_ptr = vars; *var_ptr; var_ptr += 2, c++) ; n_var = c; @@ -517,367 +448,74 @@ CreateCustomEnvTable (char **vars) *result_ptr = 0; return result; } -#endif +#else /** - * Start a process. + * Open '/dev/null' and make the result the given + * file descriptor. * - * @param pipe_stdin pipe to use to send input to child process (or NULL) - * @param pipe_stdout pipe to use to get output from child process (or NULL) - * @param filename name of the binary - * @param va NULL-terminated list of arguments to the process - * @return pointer to process structure of the new process, NULL on error + * @param target_fd desired FD to point to /dev/null + * @param flags open flags (O_RDONLY, O_WRONLY) */ -struct GNUNET_OS_Process * -GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin, - struct GNUNET_DISK_PipeHandle *pipe_stdout, - const char *filename, va_list va) +static void +open_dev_null (int target_fd, + int flags) { - va_list ap; - -#if ENABLE_WINDOWS_WORKAROUNDS - char *childpipename = NULL; - struct GNUNET_DISK_FileHandle *control_pipe = NULL; -#endif - struct GNUNET_OS_Process *gnunet_proc = NULL; - -#ifndef MINGW - pid_t ret; - char **argv; - int argc; - int fd_stdout_write; - int fd_stdout_read; - int fd_stdin_read; - int fd_stdin_write; - -#if ENABLE_WINDOWS_WORKAROUNDS - control_pipe = - GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (control_pipe == NULL) - return NULL; -#endif - - argc = 0; - va_copy (ap, va); - while (NULL != va_arg (ap, char *)) - argc++; - - va_end (ap); - argv = GNUNET_malloc (sizeof (char *) * (argc + 1)); - argc = 0; - va_copy (ap, va); - while (NULL != (argv[argc] = va_arg (ap, char *))) - argc++; - - va_end (ap); - if (pipe_stdout != NULL) - { - GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle - (pipe_stdout, - GNUNET_DISK_PIPE_END_WRITE), - &fd_stdout_write, sizeof (int)); - GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle - (pipe_stdout, GNUNET_DISK_PIPE_END_READ), - &fd_stdout_read, sizeof (int)); - } - if (pipe_stdin != NULL) - { - GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle - (pipe_stdin, GNUNET_DISK_PIPE_END_READ), - &fd_stdin_read, sizeof (int)); - GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle - (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE), - &fd_stdin_write, sizeof (int)); - } - -#if HAVE_WORKING_VFORK - ret = vfork (); -#else - ret = fork (); -#endif - if (ret != 0) - { - if (ret == -1) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork"); -#if ENABLE_WINDOWS_WORKAROUNDS - GNUNET_DISK_npipe_close (control_pipe); -#endif - } - else - { - -#if HAVE_WORKING_VFORK - /* let's hope vfork actually works; for some extreme cases (including - * a testcase) we need 'execvp' to have run before we return, since - * we may send a signal to the process next and we don't want it - * to be caught by OUR signal handler (but either by the default - * handler or the actual handler as installed by the process itself). */ -#else - /* let's give the child process a chance to run execvp, 1s should - * be plenty in practice */ - if (pipe_stdout != NULL) - GNUNET_DISK_pipe_close_end (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE); - if (pipe_stdin != NULL) - GNUNET_DISK_pipe_close_end (pipe_stdin, GNUNET_DISK_PIPE_END_READ); - sleep (1); -#endif - gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process)); - gnunet_proc->pid = ret; -#if ENABLE_WINDOWS_WORKAROUNDS - gnunet_proc->control_pipe = control_pipe; -#endif - } - GNUNET_free (argv); -#if ENABLE_WINDOWS_WORKAROUNDS - GNUNET_free (childpipename); -#endif - return gnunet_proc; - } - -#if ENABLE_WINDOWS_WORKAROUNDS - setenv (GNUNET_OS_CONTROL_PIPE, childpipename, 1); - GNUNET_free (childpipename); -#endif - - if (pipe_stdout != NULL) - { - GNUNET_break (0 == close (fd_stdout_read)); - if (-1 == dup2 (fd_stdout_write, 1)) - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2"); - GNUNET_break (0 == close (fd_stdout_write)); - } - - if (pipe_stdin != NULL) - { - - GNUNET_break (0 == close (fd_stdin_write)); - if (-1 == dup2 (fd_stdin_read, 0)) - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2"); - GNUNET_break (0 == close (fd_stdin_read)); - } - execvp (filename, argv); - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename); - _exit (1); -#else - char *arg; - unsigned int cmdlen; - char *cmd, *idx; - STARTUPINFO start; - PROCESS_INFORMATION proc; - - HANDLE stdin_handle; - HANDLE stdout_handle; - - char path[MAX_PATH + 1]; - - char *our_env[3] = { NULL, NULL, NULL }; - char *env_block = NULL; - char *pathbuf; - DWORD pathbuf_len, alloc_len; - char *self_prefix; - char *bindir; - char *libdir; - char *ptr; - char *non_const_filename; - - /* Search in prefix dir (hopefully - the directory from which - * the current module was loaded), bindir and libdir, then in PATH - */ - self_prefix = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_SELF_PREFIX); - bindir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_BINDIR); - libdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR); - - pathbuf_len = GetEnvironmentVariableA ("PATH", (char *) &pathbuf, 0); - - alloc_len = - pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 + - strlen (libdir); - - pathbuf = GNUNET_malloc (alloc_len * sizeof (char)); - - ptr = pathbuf; - ptr += sprintf (pathbuf, "%s;%s;%s;", self_prefix, bindir, libdir); - GNUNET_free (self_prefix); - GNUNET_free (bindir); - GNUNET_free (libdir); - - alloc_len = GetEnvironmentVariableA ("PATH", ptr, pathbuf_len); - GNUNET_assert (alloc_len == (pathbuf_len - 1)); - - cmdlen = strlen (filename); - if (cmdlen < 5 || strcmp (&filename[cmdlen - 4], ".exe") != 0) - GNUNET_asprintf (&non_const_filename, "%s.exe", filename); - else - GNUNET_asprintf (&non_const_filename, "%s", filename); - - /* Check that this is the full path. If it isn't, search. */ - if (non_const_filename[1] == ':') - snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename); - else if (!SearchPathA - (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char), - path, NULL)) - { - SetErrnoFromWinError (GetLastError ()); - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "SearchPath", - non_const_filename); - GNUNET_free (non_const_filename); - GNUNET_free (pathbuf); - return NULL; - } - GNUNET_free (pathbuf); - GNUNET_free (non_const_filename); - - cmdlen = 0; - va_copy (ap, va); - while (NULL != (arg = va_arg (ap, char *))) - { - if (cmdlen == 0) - cmdlen = cmdlen + strlen (path) + 3; - else - cmdlen = cmdlen + strlen (arg) + 3; - } - va_end (ap); + int fd; - cmd = idx = GNUNET_malloc (sizeof (char) * (cmdlen + 1)); - va_copy (ap, va); - while (NULL != (arg = va_arg (ap, char *))) + fd = open ("/dev/null", flags); + if (-1 == fd) { - if (idx == cmd) - idx += sprintf (idx, "\"%s\" ", path); - else - idx += sprintf (idx, "\"%s\" ", arg); - } - va_end (ap); - - memset (&start, 0, sizeof (start)); - start.cb = sizeof (start); - - if ((pipe_stdin != NULL) || (pipe_stdout != NULL)) - start.dwFlags |= STARTF_USESTDHANDLES; - - if (pipe_stdin != NULL) - { - GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle - (pipe_stdin, GNUNET_DISK_PIPE_END_READ), - &stdin_handle, sizeof (HANDLE)); - start.hStdInput = stdin_handle; - } - - if (pipe_stdout != NULL) - { - GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle - (pipe_stdout, - GNUNET_DISK_PIPE_END_WRITE), - &stdout_handle, sizeof (HANDLE)); - start.hStdOutput = stdout_handle; - } - - control_pipe = - GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (control_pipe == NULL) - { - GNUNET_free (cmd); - GNUNET_free (path); - return NULL; + GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", "/dev/null"); + return; } - -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Opened the parent end of the pipe `%s'\n", childpipename); -#endif - - GNUNET_asprintf (&our_env[0], "%s=", GNUNET_OS_CONTROL_PIPE); - GNUNET_asprintf (&our_env[1], "%s", childpipename); - our_env[2] = NULL; - env_block = CreateCustomEnvTable (our_env); - GNUNET_free (our_env[0]); - GNUNET_free (our_env[1]); - - if (!CreateProcessA - (path, cmd, NULL, NULL, TRUE, DETACHED_PROCESS | CREATE_SUSPENDED, - env_block, NULL, &start, &proc)) + if (fd == target_fd) + return; + if (-1 == dup2 (fd, target_fd)) { - SetErrnoFromWinError (GetLastError ()); - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "CreateProcess", path); - GNUNET_free (env_block); - GNUNET_free (cmd); - return NULL; + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2"); + (void) close (fd); + return; } - - GNUNET_free (env_block); - - gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process)); - gnunet_proc->pid = proc.dwProcessId; - gnunet_proc->handle = proc.hProcess; - gnunet_proc->control_pipe = control_pipe; - - CreateThread (NULL, 64000, ChildWaitThread, (void *) gnunet_proc, 0, NULL); - - ResumeThread (proc.hThread); - CloseHandle (proc.hThread); - - GNUNET_free (cmd); - - return gnunet_proc; -#endif + GNUNET_break (0 == close (fd)); } +#endif /** * Start a process. * + * @param pipe_control should a pipe be used to send signals to the child? + * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags controlling which + * std handles of the parent are inherited by the child. + * pipe_stdin and pipe_stdout take priority over std_inheritance + * (when they are non-NULL). * @param pipe_stdin pipe to use to send input to child process (or NULL) * @param pipe_stdout pipe to use to get output from child process (or NULL) - * @param filename name of the binary - * @param ... NULL-terminated list of arguments to the process - * - * @return pointer to process structure of the new process, NULL on error - * - */ -struct GNUNET_OS_Process * -GNUNET_OS_start_process (struct GNUNET_DISK_PipeHandle *pipe_stdin, - struct GNUNET_DISK_PipeHandle *pipe_stdout, - const char *filename, ...) -{ - struct GNUNET_OS_Process *ret; - va_list ap; - - va_start (ap, filename); - ret = GNUNET_OS_start_process_va (pipe_stdin, pipe_stdout, filename, ap); - va_end (ap); - return ret; -} - - -/** - * Start a process. - * * @param lsocks array of listen sockets to dup systemd-style (or NULL); * must be NULL on platforms where dup is not supported * @param filename name of the binary * @param argv NULL-terminated list of arguments to the process * @return process ID of the new process, -1 on error */ -struct GNUNET_OS_Process * -GNUNET_OS_start_process_v (const int *lsocks, const char *filename, - char *const argv[]) +static struct GNUNET_OS_Process * +start_process (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + const SOCKTYPE *lsocks, + const char *filename, + char *const argv[]) { -#if ENABLE_WINDOWS_WORKAROUNDS - struct GNUNET_DISK_FileHandle *control_pipe = NULL; - char *childpipename = NULL; -#endif - #ifndef MINGW pid_t ret; char lpid[16]; char fds[16]; - struct GNUNET_OS_Process *gnunet_proc = NULL; + struct GNUNET_OS_Process *gnunet_proc; + struct GNUNET_DISK_FileHandle *childpipe_read; + struct GNUNET_DISK_FileHandle *childpipe_write; + int childpipe_read_fd; int i; int j; int k; @@ -885,72 +523,150 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename, int flags; int *lscp; unsigned int ls; + int fd_stdout_write; + int fd_stdout_read; + int fd_stdin_read; + int fd_stdin_write; -#if ENABLE_WINDOWS_WORKAROUNDS - control_pipe = - GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (control_pipe == NULL) - return NULL; -#endif - + if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL)) + return NULL; /* not executable */ + if (GNUNET_YES == pipe_control) + { + struct GNUNET_DISK_PipeHandle *childpipe; + int dup_childpipe_read_fd = -1; + + childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO); + if (NULL == childpipe) + return NULL; + childpipe_read = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ); + childpipe_write = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE); + GNUNET_DISK_pipe_close (childpipe); + if ((NULL == childpipe_read) || (NULL == childpipe_write) || + (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read, + &childpipe_read_fd, sizeof (int))) || + (-1 == (dup_childpipe_read_fd = dup (childpipe_read_fd)))) + { + if (NULL != childpipe_read) + GNUNET_DISK_file_close (childpipe_read); + if (NULL != childpipe_write) + GNUNET_DISK_file_close (childpipe_write); + if (0 <= dup_childpipe_read_fd) + close (dup_childpipe_read_fd); + return NULL; + } + childpipe_read_fd = dup_childpipe_read_fd; + GNUNET_DISK_file_close (childpipe_read); + } + else + { + childpipe_write = NULL; + childpipe_read_fd = -1; + } + if (NULL != pipe_stdout) + { + GNUNET_assert (GNUNET_OK == + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (pipe_stdout, + GNUNET_DISK_PIPE_END_WRITE), + &fd_stdout_write, sizeof (int))); + GNUNET_assert (GNUNET_OK == + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (pipe_stdout, GNUNET_DISK_PIPE_END_READ), + &fd_stdout_read, sizeof (int))); + } + if (NULL != pipe_stdin) + { + GNUNET_assert (GNUNET_OK == + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (pipe_stdin, GNUNET_DISK_PIPE_END_READ), + &fd_stdin_read, sizeof (int))); + GNUNET_assert (GNUNET_OK == + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE), + &fd_stdin_write, sizeof (int))); + } lscp = NULL; ls = 0; - if (lsocks != NULL) + if (NULL != lsocks) { i = 0; while (-1 != (k = lsocks[i++])) GNUNET_array_append (lscp, ls, k); GNUNET_array_append (lscp, ls, -1); } -#if HAVE_WORKING_VFORK +#if DARWIN + /* see https://gnunet.org/vfork */ ret = vfork (); #else ret = fork (); #endif - if (ret != 0) + if (-1 == ret) + { + int eno = errno; + LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork"); + GNUNET_array_grow (lscp, ls, 0); + if (NULL != childpipe_write) + GNUNET_DISK_file_close (childpipe_write); + if (0 <= childpipe_read_fd) + close (childpipe_read_fd); + errno = eno; + return NULL; + } + if (0 != ret) { - if (ret == -1) + unsetenv (GNUNET_OS_CONTROL_PIPE); + gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process)); + gnunet_proc->pid = ret; + gnunet_proc->control_pipe = childpipe_write; + if (GNUNET_YES == pipe_control) { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork"); -#if ENABLE_WINDOWS_WORKAROUNDS - GNUNET_DISK_npipe_close (control_pipe); -#endif - } - else - { -#if HAVE_WORKING_VFORK - /* let's hope vfork actually works; for some extreme cases (including - * a testcase) we need 'execvp' to have run before we return, since - * we may send a signal to the process next and we don't want it - * to be caught by OUR signal handler (but either by the default - * handler or the actual handler as installed by the process itself). */ -#else - /* let's give the child process a chance to run execvp, 1s should - * be plenty in practice */ - sleep (1); -#endif - gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process)); - gnunet_proc->pid = ret; -#if ENABLE_WINDOWS_WORKAROUNDS - gnunet_proc->control_pipe = control_pipe; - -#endif + close (childpipe_read_fd); } GNUNET_array_grow (lscp, ls, 0); -#if ENABLE_WINDOWS_WORKAROUNDS - GNUNET_free (childpipename); -#endif return gnunet_proc; } - -#if ENABLE_WINDOWS_WORKAROUNDS - setenv (GNUNET_OS_CONTROL_PIPE, childpipename, 1); - GNUNET_free (childpipename); + if (0 <= childpipe_read_fd) + { + char fdbuf[100]; +#ifndef DARWIN + /* due to vfork, we must NOT free memory on DARWIN! */ + GNUNET_DISK_file_close (childpipe_write); #endif - - if (lscp != NULL) + snprintf (fdbuf, 100, "%x", childpipe_read_fd); + setenv (GNUNET_OS_CONTROL_PIPE, fdbuf, 1); + } + else + unsetenv (GNUNET_OS_CONTROL_PIPE); + if (NULL != pipe_stdin) + { + GNUNET_break (0 == close (fd_stdin_write)); + if (-1 == dup2 (fd_stdin_read, 0)) + LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2"); + GNUNET_break (0 == close (fd_stdin_read)); + } + else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_IN)) + { + GNUNET_break (0 == close (0)); + open_dev_null (0, O_RDONLY); + } + if (NULL != pipe_stdout) + { + GNUNET_break (0 == close (fd_stdout_read)); + if (-1 == dup2 (fd_stdout_write, 1)) + LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2"); + GNUNET_break (0 == close (fd_stdout_write)); + } + else if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_OUT)) + { + GNUNET_break (0 == close (1)); + open_dev_null (1, O_WRONLY); + } + if (0 == (std_inheritance & GNUNET_OS_INHERIT_STD_ERR)) + { + GNUNET_break (0 == close (2)); + open_dev_null (2, O_WRONLY); + } + if (NULL != lscp) { /* read systemd documentation... */ GNUNET_snprintf (lpid, sizeof (lpid), "%u", getpid ()); @@ -992,33 +708,59 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename, GNUNET_snprintf (fds, sizeof (fds), "%u", i); setenv ("LISTEN_FDS", fds, 1); } +#ifndef DARWIN + /* due to vfork, we must NOT free memory on DARWIN! */ GNUNET_array_grow (lscp, ls, 0); +#endif execvp (filename, argv); - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename); + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "execvp", filename); _exit (1); #else - char **arg, **non_const_argv; + struct GNUNET_DISK_FileHandle *childpipe_read; + struct GNUNET_DISK_FileHandle *childpipe_write; + HANDLE childpipe_read_handle; + char **arg; + char **non_const_argv; unsigned int cmdlen; - char *cmd, *idx; - STARTUPINFO start; + char *cmd; + char *idx; + STARTUPINFOW start; PROCESS_INFORMATION proc; int argcount = 0; - struct GNUNET_OS_Process *gnunet_proc = NULL; - + struct GNUNET_OS_Process *gnunet_proc; char path[MAX_PATH + 1]; - - char *our_env[3] = { NULL, NULL, NULL }; + char *our_env[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL }; char *env_block = NULL; char *pathbuf; - DWORD pathbuf_len, alloc_len; + DWORD pathbuf_len; + DWORD alloc_len; char *self_prefix; char *bindir; char *libdir; char *ptr; char *non_const_filename; - - GNUNET_assert (lsocks == NULL); - + char win_path[MAX_PATH + 1]; + struct GNUNET_DISK_PipeHandle *lsocks_pipe; + const struct GNUNET_DISK_FileHandle *lsocks_write_fd; + HANDLE lsocks_read; + HANDLE lsocks_write; + wchar_t *wpath; + wchar_t *wcmd; + size_t wpath_len; + size_t wcmd_len; + int env_off; + int fail; + long lRet; + HANDLE stdin_handle; + HANDLE stdout_handle; + HANDLE stdih, stdoh, stdeh; + DWORD stdif, stdof, stdef; + BOOL bresult; + DWORD error_code; + + if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary (filename, GNUNET_NO, NULL)) + return NULL; /* not executable */ + /* Search in prefix dir (hopefully - the directory from which * the current module was loaded), bindir and libdir, then in PATH */ @@ -1049,25 +791,47 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename, } cmdlen = strlen (filename); - if (cmdlen < 5 || strcmp (&filename[cmdlen - 4], ".exe") != 0) + if ( (cmdlen < 5) || (0 != strcmp (&filename[cmdlen - 4], ".exe")) ) GNUNET_asprintf (&non_const_filename, "%s.exe", filename); else GNUNET_asprintf (&non_const_filename, "%s", filename); - /* Check that this is the full path. If it isn't, search. */ + /* It could be in POSIX form, convert it to a DOS path early on */ + if (ERROR_SUCCESS != (lRet = plibc_conv_to_win_path (non_const_filename, win_path))) + { + SetErrnoFromWinError (lRet); + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "plibc_conv_to_win_path", + non_const_filename); + GNUNET_free (non_const_filename); + GNUNET_free (pathbuf); + return NULL; + } + GNUNET_free (non_const_filename); + non_const_filename = GNUNET_strdup (win_path); + /* Check that this is the full path. If it isn't, search. */ + /* FIXME: convert it to wchar_t and use SearchPathW? + * Remember: arguments to _start_process() are technically in UTF-8... + */ if (non_const_filename[1] == ':') + { snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Using path `%s' as-is. PATH is %s\n", path, ptr); + } else if (!SearchPathA (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char), path, NULL)) { SetErrnoFromWinError (GetLastError ()); - GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "SearchPath", - non_const_filename); + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath", + non_const_filename); GNUNET_free (non_const_filename); GNUNET_free (pathbuf); return NULL; } + else + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Found `%s' in PATH `%s'\n", path, pathbuf); GNUNET_free (pathbuf); GNUNET_free (non_const_filename); @@ -1101,7 +865,7 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename, arg = non_const_argv; while (*arg) { - cmdlen = cmdlen + strlen (*arg) + 3; + cmdlen = cmdlen + strlen (*arg) + 4; arg++; } @@ -1110,7 +874,9 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename, arg = non_const_argv; while (*arg) { - idx += sprintf (idx, "\"%s\" ", *arg); + char arg_last_char = (*arg)[strlen (*arg) - 1]; + idx += sprintf (idx, "\"%s%s\"%s", *arg, + arg_last_char == '\\' ? "\\" : "", *(arg + 1) ? " " : ""); arg++; } @@ -1120,61 +886,456 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename, memset (&start, 0, sizeof (start)); start.cb = sizeof (start); + if ((pipe_stdin != NULL) || (pipe_stdout != NULL) || (std_inheritance != 0)) + start.dwFlags |= STARTF_USESTDHANDLES; - control_pipe = - GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE, - GNUNET_DISK_PERM_USER_READ | - GNUNET_DISK_PERM_USER_WRITE); - if (control_pipe == NULL) + stdih = GetStdHandle (STD_INPUT_HANDLE); + GetHandleInformation (stdih, &stdif); + if (pipe_stdin != NULL) { - GNUNET_free (cmd); - GNUNET_free (path); - return NULL; + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (pipe_stdin, GNUNET_DISK_PIPE_END_READ), + &stdin_handle, sizeof (HANDLE)); + start.hStdInput = stdin_handle; + } + else if (stdih) + { + if (std_inheritance & GNUNET_OS_INHERIT_STD_IN) + { + SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 1); + if (pipe_stdin == NULL) + start.hStdInput = stdih; + } + else + SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, 0); } + -#if DEBUG_OS - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Opened the parent end of the pipe `%s'\n", childpipename); -#endif + stdoh = GetStdHandle (STD_OUTPUT_HANDLE); + GetHandleInformation (stdoh, &stdof); + if (NULL != pipe_stdout) + { + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (pipe_stdout, + GNUNET_DISK_PIPE_END_WRITE), + &stdout_handle, sizeof (HANDLE)); + start.hStdOutput = stdout_handle; + } + else if (stdoh) + { + if (std_inheritance & GNUNET_OS_INHERIT_STD_OUT) + { + SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 1); + if (pipe_stdout == NULL) + start.hStdOutput = stdoh; + } + else + SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, 0); + } + + stdeh = GetStdHandle (STD_ERROR_HANDLE); + GetHandleInformation (stdeh, &stdef); + if (stdeh) + { + if (std_inheritance & GNUNET_OS_INHERIT_STD_ERR) + { + SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 1); + start.hStdError = stdeh; + } + else + SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, 0); + } + + if (GNUNET_YES == pipe_control) + { + struct GNUNET_DISK_PipeHandle *childpipe; + childpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_YES, GNUNET_NO); + if (NULL == childpipe) + return NULL; + childpipe_read = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_READ); + childpipe_write = GNUNET_DISK_pipe_detach_end (childpipe, GNUNET_DISK_PIPE_END_WRITE); + GNUNET_DISK_pipe_close (childpipe); + if ((NULL == childpipe_read) || (NULL == childpipe_write) || + (GNUNET_OK != GNUNET_DISK_internal_file_handle_ (childpipe_read, + &childpipe_read_handle, sizeof (HANDLE)))) + { + if (childpipe_read) + GNUNET_DISK_file_close (childpipe_read); + if (childpipe_write) + GNUNET_DISK_file_close (childpipe_write); + GNUNET_free (cmd); + return NULL; + } + /* Unlike *nix variant, we don't dup the handle, so can't close + * filehandle right now. + */ + SetHandleInformation (childpipe_read_handle, HANDLE_FLAG_INHERIT, 1); + } + else + { + childpipe_read = NULL; + childpipe_write = NULL; + } + + if (lsocks != NULL && lsocks[0] != INVALID_SOCKET) + { + lsocks_pipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_YES, GNUNET_NO); + + if (lsocks_pipe == NULL) + { + GNUNET_free (cmd); + GNUNET_DISK_pipe_close (lsocks_pipe); + if (GNUNET_YES == pipe_control) + { + GNUNET_DISK_file_close (childpipe_write); + GNUNET_DISK_file_close (childpipe_read); + } + return NULL; + } + lsocks_write_fd = GNUNET_DISK_pipe_handle (lsocks_pipe, + GNUNET_DISK_PIPE_END_WRITE); + GNUNET_DISK_internal_file_handle_ (lsocks_write_fd, + &lsocks_write, sizeof (HANDLE)); + GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle + (lsocks_pipe, GNUNET_DISK_PIPE_END_READ), + &lsocks_read, sizeof (HANDLE)); + } + else + lsocks_pipe = NULL; - GNUNET_asprintf (&our_env[0], "%s=", GNUNET_OS_CONTROL_PIPE); - GNUNET_asprintf (&our_env[1], "%s", childpipename); - our_env[2] = NULL; + env_off = 0; + if (GNUNET_YES == pipe_control) + { + GNUNET_asprintf (&our_env[env_off++], "%s=", GNUNET_OS_CONTROL_PIPE); + GNUNET_asprintf (&our_env[env_off++], "%p", childpipe_read_handle); + } + if ( (lsocks != NULL) && (lsocks[0] != INVALID_SOCKET)) + { + /*This will tell the child that we're going to send lsocks over the pipe*/ + GNUNET_asprintf (&our_env[env_off++], "%s=", "GNUNET_OS_READ_LSOCKS"); + GNUNET_asprintf (&our_env[env_off++], "%lu", lsocks_read); + } + our_env[env_off++] = NULL; env_block = CreateCustomEnvTable (our_env); - GNUNET_free (our_env[0]); - GNUNET_free (our_env[1]); + while (0 > env_off) + GNUNET_free_non_null (our_env[--env_off]); - if (!CreateProcess - (path, cmd, NULL, NULL, FALSE, DETACHED_PROCESS | CREATE_SUSPENDED, - env_block, NULL, &start, &proc)) + wpath_len = 0; + if (NULL == (wpath = u8_to_u16 ((uint8_t *) path, 1 + strlen (path), NULL, &wpath_len))) { - SetErrnoFromWinError (GetLastError ()); - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "CreateProcess"); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Failed to convert `%s' from UTF-8 to UTF-16: %d\n", path, errno); + GNUNET_free (env_block); + GNUNET_free (cmd); + if (lsocks_pipe) + GNUNET_DISK_pipe_close (lsocks_pipe); + if (GNUNET_YES == pipe_control) + { + GNUNET_DISK_file_close (childpipe_write); + GNUNET_DISK_file_close (childpipe_read); + } + return NULL; + } + + wcmd_len = 0; + if (NULL == (wcmd = u8_to_u16 ((uint8_t *) cmd, 1 + strlen (cmd), NULL, &wcmd_len))) + { + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Failed to convert `%s' from UTF-8 to UTF-16: %d\n", cmd, errno); GNUNET_free (env_block); GNUNET_free (cmd); + free (wpath); + if (lsocks_pipe) + GNUNET_DISK_pipe_close (lsocks_pipe); + if (GNUNET_YES == pipe_control) + { + GNUNET_DISK_file_close (childpipe_write); + GNUNET_DISK_file_close (childpipe_read); + } return NULL; } + bresult = CreateProcessW (wpath, wcmd, NULL, NULL, GNUNET_YES, + DETACHED_PROCESS | CREATE_SUSPENDED, env_block, NULL, &start, &proc); + error_code = GetLastError (); + + if ((NULL == pipe_stdin) && (stdih)) + SetHandleInformation (stdih, HANDLE_FLAG_INHERIT, stdif); + + + if ((NULL == pipe_stdout) && (stdoh)) + SetHandleInformation (stdoh, HANDLE_FLAG_INHERIT, stdof); + + if (stdeh) + SetHandleInformation (stdeh, HANDLE_FLAG_INHERIT, stdef); + + if (!bresult) + LOG (GNUNET_ERROR_TYPE_ERROR, "CreateProcess(%s, %s) failed: %lu\n", path, cmd, error_code); + GNUNET_free (env_block); + GNUNET_free (cmd); + free (wpath); + free (wcmd); + if (GNUNET_YES == pipe_control) + { + GNUNET_DISK_file_close (childpipe_read); + } + + if (!bresult) + { + if (GNUNET_YES == pipe_control) + { + GNUNET_DISK_file_close (childpipe_write); + } + if (NULL != lsocks) + GNUNET_DISK_pipe_close (lsocks_pipe); + SetErrnoFromWinError (error_code); + return NULL; + } gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process)); gnunet_proc->pid = proc.dwProcessId; gnunet_proc->handle = proc.hProcess; - gnunet_proc->control_pipe = control_pipe; + gnunet_proc->control_pipe = childpipe_write; - CreateThread (NULL, 64000, ChildWaitThread, (void *) gnunet_proc, 0, NULL); + CreateThread (NULL, 64000, &child_wait_thread, (void *) gnunet_proc, 0, NULL); ResumeThread (proc.hThread); CloseHandle (proc.hThread); - GNUNET_free (cmd); + if ( (NULL == lsocks) || (INVALID_SOCKET == lsocks[0]) ) + return gnunet_proc; + + GNUNET_DISK_pipe_close_end (lsocks_pipe, GNUNET_DISK_PIPE_END_READ); + + /* This is a replacement for "goto error" that doesn't use goto */ + fail = 1; + do + { + ssize_t wrote; + uint64_t size; + uint64_t count; + unsigned int i; + + /* Tell the number of sockets */ + for (count = 0; lsocks && lsocks[count] != INVALID_SOCKET; count++); + + wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count)); + if (sizeof (count) != wrote) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to write %u count bytes to the child: %u\n", + sizeof (count), GetLastError ()); + break; + } + for (i = 0; lsocks && lsocks[i] != INVALID_SOCKET; i++) + { + WSAPROTOCOL_INFOA pi; + /* Get a socket duplication info */ + if (SOCKET_ERROR == WSADuplicateSocketA (lsocks[i], gnunet_proc->pid, &pi)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to duplicate an socket[%llu]: %u\n", i, + GetLastError ()); + break; + } + /* Synchronous I/O is not nice, but we can't schedule this: + * lsocks will be closed/freed by the caller soon, and until + * the child creates a duplicate, closing a socket here will + * close it for good. + */ + /* Send the size of the structure + * (the child might be built with different headers...) + */ + size = sizeof (pi); + wrote = GNUNET_DISK_file_write (lsocks_write_fd, &size, sizeof (size)); + if (sizeof (size) != wrote) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to write %u size[%llu] bytes to the child: %u\n", + sizeof (size), i, GetLastError ()); + break; + } + /* Finally! Send the data */ + wrote = GNUNET_DISK_file_write (lsocks_write_fd, &pi, sizeof (pi)); + if (sizeof (pi) != wrote) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Failed to write %u socket[%llu] bytes to the child: %u\n", + sizeof (pi), i, GetLastError ()); + break; + } + } + /* This will block us until the child makes a final read or closes + * the pipe (hence no 'wrote' check), since we have to wait for it + * to duplicate the last socket, before we return and start closing + * our own copies) + */ + wrote = GNUNET_DISK_file_write (lsocks_write_fd, &count, sizeof (count)); + fail = 0; + } + while (fail); + + GNUNET_DISK_file_sync (lsocks_write_fd); + GNUNET_DISK_pipe_close (lsocks_pipe); + + if (fail) + { + /* If we can't pass on the socket(s), the child will block forever, + * better put it out of its misery. + */ + SafeTerminateProcess (gnunet_proc->handle, 0, 0); + CloseHandle (gnunet_proc->handle); + if (NULL != gnunet_proc->control_pipe) + GNUNET_DISK_file_close (gnunet_proc->control_pipe); + GNUNET_free (gnunet_proc); + return NULL; + } return gnunet_proc; #endif } + + +/** + * Start a process. + * + * @param pipe_control should a pipe be used to send signals to the child? + * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags + * @param pipe_stdin pipe to use to send input to child process (or NULL) + * @param pipe_stdout pipe to use to get output from child process (or NULL) + * @param filename name of the binary + * @param argv NULL-terminated array of arguments to the process + * @return pointer to process structure of the new process, NULL on error + */ +struct GNUNET_OS_Process * +GNUNET_OS_start_process_vap (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + const char *filename, + char *const argv[]) +{ + return start_process (pipe_control, + std_inheritance, + pipe_stdin, + pipe_stdout, + NULL, + filename, + argv); +} + + +/** + * Start a process. + * + * @param pipe_control should a pipe be used to send signals to the child? + * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags + * @param pipe_stdin pipe to use to send input to child process (or NULL) + * @param pipe_stdout pipe to use to get output from child process (or NULL) + * @param filename name of the binary + * @param va NULL-terminated list of arguments to the process + * @return pointer to process structure of the new process, NULL on error + */ +struct GNUNET_OS_Process * +GNUNET_OS_start_process_va (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + const char *filename, va_list va) +{ + struct GNUNET_OS_Process *ret; + va_list ap; + char **argv; + int argc; + + argc = 0; + va_copy (ap, va); + while (NULL != va_arg (ap, char *)) + argc++; + va_end (ap); + argv = GNUNET_malloc (sizeof (char *) * (argc + 1)); + argc = 0; + va_copy (ap, va); + while (NULL != (argv[argc] = va_arg (ap, char *))) + argc++; + va_end (ap); + ret = GNUNET_OS_start_process_vap (pipe_control, + std_inheritance, + pipe_stdin, + pipe_stdout, + filename, + argv); + GNUNET_free (argv); + return ret; +} + + +/** + * Start a process. + * + * @param pipe_control should a pipe be used to send signals to the child? + * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags + * @param pipe_stdin pipe to use to send input to child process (or NULL) + * @param pipe_stdout pipe to use to get output from child process (or NULL) + * @param filename name of the binary + * @param ... NULL-terminated list of arguments to the process + * @return pointer to process structure of the new process, NULL on error + */ +struct GNUNET_OS_Process * +GNUNET_OS_start_process (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + struct GNUNET_DISK_PipeHandle *pipe_stdin, + struct GNUNET_DISK_PipeHandle *pipe_stdout, + const char *filename, ...) +{ + struct GNUNET_OS_Process *ret; + va_list ap; + + va_start (ap, filename); + ret = GNUNET_OS_start_process_va (pipe_control, std_inheritance, pipe_stdin, + pipe_stdout, filename, ap); + va_end (ap); + return ret; +} + + +/** + * Start a process. + * + * @param pipe_control should a pipe be used to send signals to the child? + * @param std_inheritance a set of GNUNET_OS_INHERIT_STD_* flags controlling which + * std handles of the parent are inherited by the child. + * pipe_stdin and pipe_stdout take priority over std_inheritance + * (when they are non-NULL). + * @param lsocks array of listen sockets to dup systemd-style (or NULL); + * must be NULL on platforms where dup is not supported + * @param filename name of the binary + * @param argv NULL-terminated list of arguments to the process + * @return process ID of the new process, -1 on error + */ +struct GNUNET_OS_Process * +GNUNET_OS_start_process_v (int pipe_control, + enum GNUNET_OS_InheritStdioFlags std_inheritance, + const SOCKTYPE *lsocks, + const char *filename, + char *const argv[]) +{ + return start_process (pipe_control, + std_inheritance, + NULL, + NULL, + lsocks, + filename, + argv); +} + + /** - * Retrieve the status of a process + * Retrieve the status of a process, waiting on him if dead. + * Nonblocking version. + * * @param proc process ID * @param type status type * @param code return code/signal number @@ -1193,7 +1354,7 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, ret = waitpid (proc->pid, &status, WNOHANG); if (ret < 0) { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid"); return GNUNET_SYSERR; } if (0 == ret) @@ -1204,7 +1365,7 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, } if (proc->pid != ret) { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid"); return GNUNET_SYSERR; } if (WIFEXITED (status)) @@ -1242,8 +1403,8 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, ret = proc->pid; if (h == NULL || ret == 0) { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Invalid process information {%d, %08X}\n", ret, h); + LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid process information {%d, %08X}\n", + ret, h); return GNUNET_SYSERR; } if (h == NULL) @@ -1255,7 +1416,7 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, if (ret == 0 || error_code != NO_ERROR) { SetErrnoFromWinError (error_code); - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess"); + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess"); return GNUNET_SYSERR; } if (STILL_ACTIVE == c) @@ -1274,42 +1435,44 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc, /** * Wait for a process + * * @param proc pointer to process structure * @return GNUNET_OK on success, GNUNET_SYSERR otherwise */ int GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc) { - #ifndef MINGW pid_t pid = proc->pid; + pid_t ret; - if (pid != waitpid (pid, NULL, 0)) + while ( (pid != (ret = waitpid (pid, NULL, 0))) && + (EINTR == errno) ) ; + if (pid != ret) + { + LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid"); return GNUNET_SYSERR; + } return GNUNET_OK; #else HANDLE h; - int ret; h = proc->handle; if (NULL == h) { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Invalid process information {%d, %08X}\n", proc->pid, h); + LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid process information {%d, %08X}\n", + proc->pid, h); return GNUNET_SYSERR; } - if (h == NULL) + if (NULL == h) h = GetCurrentProcess (); if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE)) { SetErrnoFromWinError (GetLastError ()); - ret = GNUNET_SYSERR; + return GNUNET_SYSERR; } - else - ret = GNUNET_OK; - - return ret; + return GNUNET_OK; #endif } @@ -1377,15 +1540,14 @@ struct GNUNET_OS_CommandHandle void GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd) { - - if (cmd->proc != NULL) + if (NULL != cmd->proc) { GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cmd->rtask); GNUNET_SCHEDULER_cancel (cmd->rtask); } (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL); GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (cmd->eip)); - GNUNET_OS_process_close (cmd->eip); + GNUNET_OS_process_destroy (cmd->eip); GNUNET_DISK_pipe_close (cmd->opipe); GNUNET_free (cmd); } @@ -1431,7 +1593,7 @@ cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) } end = memchr (&cmd->buf[cmd->off], '\n', ret); cmd->off += ret; - while (end != NULL) + while (NULL != end) { *end = '\0'; cmd->proc (cmd->proc_cls, cmd->buf); @@ -1466,11 +1628,12 @@ GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls, struct GNUNET_DISK_PipeHandle *opipe; va_list ap; - opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_NO, GNUNET_YES); + opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); if (NULL == opipe) return NULL; va_start (ap, binary); - eip = GNUNET_OS_start_process_va (NULL, opipe, binary, ap); + /* redirect stdout, don't inherit stderr/stdin */ + eip = GNUNET_OS_start_process_va (GNUNET_NO, 0, NULL, opipe, binary, ap); va_end (ap); if (NULL == eip) { @@ -1490,6 +1653,4 @@ GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls, } - - /* end of os_priority.c */