1 files changed, 1 insertions, 614 deletions

diff --git a/src/util/os_priority.c b/src/util/os_priority.c
index ebe469b3b..e25623af5 100644
--- a/src/util/os_priority.c
+++ b/src/util/os_priority.c
@@ -350,7 +350,6 @@ start_process(int pipe_control,
               const char *filename,
               char *const argv[])
 {
-#ifndef MINGW
   pid_t ret;
   char fds[16];
   struct GNUNET_OS_Process *gnunet_proc;
@@ -464,7 +463,7 @@ start_process(int pipe_control,
       GNUNET_array_append(lscp, ls, -1);
     }
 #if DARWIN
-  /* see https://gnunet.org/vfork */
+  /* see https://web.archive.org/web/20150924082249/gnunet.org/vfork */
   ret = vfork();
 #else
   ret = fork();
@@ -589,547 +588,6 @@ start_process(int pipe_control,
   execvp(filename, argv);
   LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
   _exit(1);
-#else
-  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;
-  char *idx;
-  STARTUPINFOW start;
-  PROCESS_INFORMATION proc;
-  int argcount = 0;
-  struct GNUNET_OS_Process *gnunet_proc;
-  char path[MAX_PATH + 1];
-  char *our_env[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
-  char *env_block = NULL;
-  char *pathbuf;
-  DWORD pathbuf_len;
-  DWORD alloc_len;
-  char *self_prefix;
-  char *bindir;
-  char *libdir;
-  char *ptr;
-  char *non_const_filename;
-  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;
-  DWORD create_no_window;
-
-  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
-   */
-  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);
-  if (alloc_len != pathbuf_len - 1)
-    {
-      GNUNET_free(pathbuf);
-      errno = ENOSYS; /* PATH changed on the fly. What kind of error is that? */
-      return NULL;
-    }
-
-  cmdlen = strlen(filename);
-  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);
-
-  /* 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());
-      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);
-
-  /* Count the number of arguments */
-  arg = (char **)argv;
-  while (*arg)
-    {
-      arg++;
-      argcount++;
-    }
-
-  /* Allocate a copy argv */
-  non_const_argv = GNUNET_malloc(sizeof(char *) * (argcount + 1));
-
-  /* Copy all argv strings */
-  argcount = 0;
-  arg = (char **)argv;
-  while (*arg)
-    {
-      if (arg == argv)
-        non_const_argv[argcount] = GNUNET_strdup(path);
-      else
-        non_const_argv[argcount] = GNUNET_strdup(*arg);
-      arg++;
-      argcount++;
-    }
-  non_const_argv[argcount] = NULL;
-
-  /* Count cmd len */
-  cmdlen = 1;
-  arg = non_const_argv;
-  while (*arg)
-    {
-      cmdlen = cmdlen + strlen(*arg) + 4;
-      arg++;
-    }
-
-  /* Allocate and create cmd */
-  cmd = idx = GNUNET_malloc(sizeof(char) * cmdlen);
-  arg = non_const_argv;
-  while (*arg)
-    {
-      char arg_last_char = (*arg)[strlen(*arg) - 1];
-      idx += sprintf(idx,
-                     "\"%s%s\"%s",
-                     *arg,
-                     arg_last_char == '\\' ? "\\" : "",
-                     *(arg + 1) ? " " : "");
-      arg++;
-    }
-
-  while (argcount > 0)
-    GNUNET_free(non_const_argv[--argcount]);
-  GNUNET_free(non_const_argv);
-
-  memset(&start, 0, sizeof(start));
-  start.cb = sizeof(start);
-  if ((pipe_stdin != NULL) || (pipe_stdout != NULL) || (std_inheritance != 0))
-    start.dwFlags |= STARTF_USESTDHANDLES;
-
-  stdih = GetStdHandle(STD_INPUT_HANDLE);
-  GetHandleInformation(stdih, &stdif);
-  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;
-    }
-  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);
-    }
-
-
-  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;
-      lsocks_write_fd = 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);
-  while (0 > env_off)
-    GNUNET_free_non_null(our_env[--env_off]);
-
-  wpath_len = 0;
-  if (NULL ==
-      (wpath =
-         u8_to_u16((uint8_t *)path, 1 + strlen(path), NULL, &wpath_len)))
-    {
-      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;
-    }
-
-  create_no_window = 0;
-  {
-    HANDLE console_input = CreateFile("CONIN$",
-                                      GENERIC_READ,
-                                      FILE_SHARE_READ | FILE_SHARE_WRITE,
-                                      NULL,
-                                      OPEN_EXISTING,
-                                      0,
-                                      NULL);
-    if (INVALID_HANDLE_VALUE == console_input)
-      create_no_window = CREATE_NO_WINDOW;
-    else
-      CloseHandle(console_input);
-  }
-
-  bresult = CreateProcessW(wpath,
-                           wcmd,
-                           NULL,
-                           NULL,
-                           GNUNET_YES,
-                           create_no_window | 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_new(struct GNUNET_OS_Process);
-  gnunet_proc->pid = proc.dwProcessId;
-  gnunet_proc->handle = proc.hProcess;
-  gnunet_proc->control_pipe = childpipe_write;
-
-  CreateThread(NULL, 64000, &child_wait_thread, (void *)gnunet_proc, 0, NULL);
-
-  ResumeThread(proc.hThread);
-  CloseHandle(proc.hThread);
-
-  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: %lu\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[%u]: %lu\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[%u] bytes to the child: %lu\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[%u] bytes to the child: %lu\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
 }
 
 
@@ -1439,7 +897,6 @@ process_status(struct GNUNET_OS_Process *proc,
                unsigned long *code,
                int options)
 {
-#ifndef MINGW
   int status;
   int ret;
 
@@ -1488,53 +945,6 @@ process_status(struct GNUNET_OS_Process *proc,
       *type = GNUNET_OS_PROCESS_UNKNOWN;
       *code = 0;
     }
-#else
-#ifndef WNOHANG
-#define WNOHANG 42 /* just a flag for W32, purely internal at this point */
-#endif
-
-  HANDLE h;
-  DWORD c, error_code, ret;
-
-  h = proc->handle;
-  ret = proc->pid;
-  if (h == NULL || ret == 0)
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "Invalid process information {%d, %08X}\n",
-          ret,
-          h);
-      return GNUNET_SYSERR;
-    }
-  if (h == NULL)
-    h = GetCurrentProcess();
-
-  if (WNOHANG != options)
-    {
-      if (WAIT_OBJECT_0 != WaitForSingleObject(h, INFINITE))
-        {
-          SetErrnoFromWinError(GetLastError());
-          return GNUNET_SYSERR;
-        }
-    }
-  SetLastError(0);
-  ret = GetExitCodeProcess(h, &c);
-  error_code = GetLastError();
-  if (ret == 0 || error_code != NO_ERROR)
-    {
-      SetErrnoFromWinError(error_code);
-      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
-      return GNUNET_SYSERR;
-    }
-  if (STILL_ACTIVE == c)
-    {
-      *type = GNUNET_OS_PROCESS_RUNNING;
-      *code = 0;
-      return GNUNET_NO;
-    }
-  *type = GNUNET_OS_PROCESS_EXITED;
-  *code = c;
-#endif
 
   return GNUNET_OK;
 }
@@ -1589,7 +999,6 @@ GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc,
 int
 GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
 {
-#ifndef MINGW
   pid_t pid = proc->pid;
   pid_t ret;
 
@@ -1601,28 +1010,6 @@ GNUNET_OS_process_wait(struct GNUNET_OS_Process *proc)
       return GNUNET_SYSERR;
     }
   return GNUNET_OK;
-#else
-  HANDLE h;
-
-  h = proc->handle;
-  if (NULL == h)
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          "Invalid process information {%d, %08X}\n",
-          proc->pid,
-          h);
-      return GNUNET_SYSERR;
-    }
-  if (NULL == h)
-    h = GetCurrentProcess();
-
-  if (WAIT_OBJECT_0 != WaitForSingleObject(h, INFINITE))
-    {
-      SetErrnoFromWinError(GetLastError());
-      return GNUNET_SYSERR;
-    }
-  return GNUNET_OK;
-#endif
 }