stuff
[oweals/gnunet.git] / src / util / os_priority.c
index 38f4312511c61a6058a46b8c3667d9ba744cf0c5..77b2627035f06426cb559842445084865d2fe52b 100644 (file)
 #include "platform.h"
 #include "gnunet_common.h"
 #include "gnunet_os_lib.h"
+#include "disk.h"
+
+#if WINDOWS
+#include "gnunet_signal_lib.h"
+
+extern GNUNET_SIGNAL_Handler w32_sigchld_handler;
+
+/**
+ * @brief Waits for a process to terminate and invokes the SIGCHLD handler
+ * @param h handle to the process
+ */
+static DWORD WINAPI
+ChildWaitThread (HANDLE h)
+{
+  WaitForSingleObject (h, INFINITE);
+
+  if (w32_sigchld_handler)
+    w32_sigchld_handler ();
+
+  CloseHandle (h);
+}
+#endif
 
 /**
  * Set process priority
@@ -47,35 +69,39 @@ GNUNET_OS_set_process_priority (pid_t proc,
   /* convert to MINGW/Unix values */
   switch (prio)
     {
-    case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
+    case GNUNET_SCHEDULER_PRIORITY_UI:
+    case GNUNET_SCHEDULER_PRIORITY_URGENT:
 #ifdef MINGW
-      rprio = NORMAL_PRIORITY_CLASS;
+      rprio = HIGH_PRIORITY_CLASS;
 #else
       rprio = 0;
 #endif
       break;
+
     case GNUNET_SCHEDULER_PRIORITY_HIGH:
 #ifdef MINGW
       rprio = ABOVE_NORMAL_PRIORITY_CLASS;
 #else
-      rprio = -5;
+      rprio = 5;
 #endif
       break;
-    case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
+
+    case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
 #ifdef MINGW
-      rprio = BELOW_NORMAL_PRIORITY_CLASS;
+      rprio = NORMAL_PRIORITY_CLASS;
 #else
-      rprio = 10;
+      rprio = 7;
 #endif
       break;
-    case GNUNET_SCHEDULER_PRIORITY_UI:
-    case GNUNET_SCHEDULER_PRIORITY_URGENT:
+
+    case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
 #ifdef MINGW
-      rprio = HIGH_PRIORITY_CLASS;
+      rprio = BELOW_NORMAL_PRIORITY_CLASS;
 #else
-      rprio = -10;
+      rprio = 10;
 #endif
       break;
+
     case GNUNET_SCHEDULER_PRIORITY_IDLE:
 #ifdef MINGW
       rprio = IDLE_PRIORITY_CLASS;
@@ -90,11 +116,16 @@ GNUNET_OS_set_process_priority (pid_t proc,
   /* Set process priority */
 #ifdef MINGW
   SetPriorityClass (GetCurrentProcess (), rprio);
-#else
-  if (proc == getpid ())
+#elif LINUX 
+  if ( (0 == proc) ||
+       (proc == getpid () ) )
     {
+      int have = nice (0);
+      int delta = rprio - have;
       errno = 0;
-      if ((-1 == nice (rprio)) && (errno != 0))
+      if ( (delta != 0) &&
+          (rprio == nice (delta)) && 
+          (errno != 0) )
         {
           GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
                                GNUNET_ERROR_TYPE_BULK, "nice");
@@ -111,36 +142,39 @@ GNUNET_OS_set_process_priority (pid_t proc,
           return GNUNET_SYSERR;
         }
     }
+#else
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+             "Priority management not availabe for this platform\n");
 #endif
   return GNUNET_OK;
 }
 
-
-
 /**
  * Start a process.
  *
+ * @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 process ID of the new process, -1 on error
  */
 pid_t
-GNUNET_OS_start_process (const char *filename, ...)
+GNUNET_OS_start_process (struct GNUNET_DISK_PipeHandle *pipe_stdin, 
+                        struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                        const char *filename, ...)
 {
+  /* FIXME:  Make this work on windows!!! */
   va_list ap;
 
 #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;
 
-  ret = fork ();
-  if (ret != 0)
-    {
-      if (ret == -1)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
-      return ret;
-    }
   argc = 0;
   va_start (ap, filename);
   while (NULL != va_arg (ap, char *))
@@ -150,49 +184,144 @@ GNUNET_OS_start_process (const char *filename, ...)
   argc = 0;
   va_start (ap, filename);
   while (NULL != (argv[argc] = va_arg (ap, char *)))
-      argc++;
+    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");
+        }
+      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_free (argv);
+      return ret;
+    }
+
+  if (pipe_stdout != NULL)
+    {
+      dup2(fd_stdout_write, 1);
+      close (fd_stdout_write);
+      close (fd_stdout_read);
+    }
+
+  if (pipe_stdin != NULL)
+    {
+
+      dup2(fd_stdin_read, 0);
+      close (fd_stdin_read);
+      close (fd_stdin_write);
+    }
+
   execvp (filename, argv);
   GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
-  exit (1);
+  _exit (1);
 #else
   char *arg;
   unsigned int cmdlen;
   char *cmd, *idx;
   STARTUPINFO start;
   PROCESS_INFORMATION proc;
+#if NILS
+  HANDLE stdin_handle;
+  HANDLE stdout_handle;
+#endif
+  char *fn;
+  int len;
+  char path[MAX_PATH + 1];
 
   cmdlen = 0;
   va_start (ap, filename);
   while (NULL != (arg = va_arg (ap, char *)))
-    cmdlen = cmdlen + strlen (arg) + 3;
+      cmdlen = cmdlen + strlen (arg) + 3;
   va_end (ap);
 
-  cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
+  cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
   va_start (ap, filename);
   while (NULL != (arg = va_arg (ap, char *)))
-    idx += sprintf (idx, "\"%s\" ", arg);
+      idx += sprintf (idx, "\"%s\" ", arg);
   va_end (ap);
 
-  memset (&start, 0, sizeof(start));
-  start.cb = sizeof(start);
-
-  if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
-      NULL, &start, &proc))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
-    return -1;
-  }
-  CloseHandle (proc.hProcess);
+  memset (&start, 0, sizeof (start));
+  start.cb = sizeof (start);
+
+#if NILS
+  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;
+    }
+#endif
+  if (FindExecutable(filename, NULL, path) <= 32)
+    {
+      SetErrnoFromWinError (GetLastError ());
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "FindExecutable", fn);
+      return -1;
+    }
+
+  if (!CreateProcess
+      (path, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &start,
+       &proc))
+    {
+      SetErrnoFromWinError (GetLastError ());
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "CreateProcess", fn);
+      return -1;
+    }
+
+  CreateThread (NULL, 64000, ChildWaitThread, proc.hProcess, 0, NULL);
+
+  if (fn != filename)
+    GNUNET_free (fn);
   CloseHandle (proc.hThread);
 
-  GNUNET_free(cmd);
+  GNUNET_free (cmd);
 
   return proc.dwProcessId;
 #endif
-}
 
+}
 
 
 
@@ -209,16 +338,36 @@ GNUNET_OS_start_process_v (const char *filename, char *const argv[])
 #ifndef MINGW
   pid_t ret;
 
+#if HAVE_WORKING_VFORK
+  ret = vfork ();
+#else
   ret = fork ();
+#endif
   if (ret != 0)
     {
       if (ret == -1)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+        }
+      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
+        }
       return ret;
     }
   execvp (filename, argv);
   GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
-  exit (1);
+  _exit (1);
 #else
   char **arg;
   unsigned int cmdlen;
@@ -229,33 +378,35 @@ GNUNET_OS_start_process_v (const char *filename, char *const argv[])
   cmdlen = 0;
   arg = argv;
   while (*arg)
-  {
-    cmdlen = cmdlen + strlen (*arg) + 3;
-    arg++;
-  }
+    {
+      cmdlen = cmdlen + strlen (*arg) + 3;
+      arg++;
+    }
 
-  cmd = idx = GNUNET_malloc (sizeof(char) * cmdlen);
+  cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
   arg = argv;
   while (*arg)
-  {
-    idx += sprintf (idx, "\"%s\" ", *arg);
-    arg++;
-  }
-
-  memset (&start, 0, sizeof(start));
-  start.cb = sizeof(start);
-
-  if (!CreateProcess (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL,
-      NULL, &start, &proc))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
-    return -1;
-  }
-  CloseHandle (proc.hProcess);
-  CloseHandle (proc.hThread);
+    {
+      idx += sprintf (idx, "\"%s\" ", *arg);
+      arg++;
+    }
+
+  memset (&start, 0, sizeof (start));
+  start.cb = sizeof (start);
 
-  GNUNET_free(cmd);
+  if (!CreateProcess
+      (filename, cmd, NULL, NULL, FALSE, DETACHED_PROCESS, NULL, NULL, &start,
+       &proc))
+    {
+      SetErrnoFromWinError (GetLastError ());
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+      return -1;
+    }
+
+  CreateThread (NULL, 64000, ChildWaitThread, proc.hProcess, 0, NULL);
+
+  CloseHandle (proc.hThread);
+  GNUNET_free (cmd);
 
   return proc.dwProcessId;
 #endif
@@ -270,7 +421,7 @@ GNUNET_OS_start_process_v (const char *filename, char *const argv[])
  */
 int
 GNUNET_OS_process_status (pid_t proc, enum GNUNET_OS_ProcessStatusType *type,
-    unsigned long *code)
+                          unsigned long *code)
 {
 #ifndef MINGW
   int status;
@@ -278,7 +429,7 @@ GNUNET_OS_process_status (pid_t proc, enum GNUNET_OS_ProcessStatusType *type,
 
   GNUNET_assert (0 != proc);
   ret = waitpid (proc, &status, WNOHANG);
-  if (0 == ret) 
+  if (0 == ret)
     {
       *type = GNUNET_OS_PROCESS_RUNNING;
       *code = 0;
@@ -290,50 +441,52 @@ GNUNET_OS_process_status (pid_t proc, enum GNUNET_OS_ProcessStatusType *type,
       return GNUNET_SYSERR;
     }
   if (WIFEXITED (status))
-  {
-    *type = GNUNET_OS_PROCESS_EXITED;
-    *code = WEXITSTATUS (status);
-  }
+    {
+      *type = GNUNET_OS_PROCESS_EXITED;
+      *code = WEXITSTATUS (status);
+    }
   else if (WIFSIGNALED (status))
-  {
-    *type = GNUNET_OS_PROCESS_SIGNALED;
-    *code = WTERMSIG (status);
-  }
+    {
+      *type = GNUNET_OS_PROCESS_SIGNALED;
+      *code = WTERMSIG (status);
+    }
   else if (WIFSTOPPED (status))
-  {
-    *type = GNUNET_OS_PROCESS_SIGNALED;
-    *code = WSTOPSIG (status);
-  }
+    {
+      *type = GNUNET_OS_PROCESS_SIGNALED;
+      *code = WSTOPSIG (status);
+    }
+#ifdef WIFCONTINUED
   else if (WIFCONTINUED (status))
-  {
-    *type = GNUNET_OS_PROCESS_RUNNING;
-    *code = 0;
-  }
+    {
+      *type = GNUNET_OS_PROCESS_RUNNING;
+      *code = 0;
+    }
+#endif
   else
-  {
-    *type = GNUNET_OS_PROCESS_UNKNOWN;
-    *code = 0;
-  }
+    {
+      *type = GNUNET_OS_PROCESS_UNKNOWN;
+      *code = 0;
+    }
 #else
   HANDLE h;
   DWORD c;
 
   h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
   if (INVALID_HANDLE_VALUE == h)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "OpenProcess");
-    return GNUNET_SYSERR;
-  }
+    {
+      SetErrnoFromWinError (GetLastError ());
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "OpenProcess");
+      return GNUNET_SYSERR;
+    }
 
   c = GetExitCodeProcess (proc, &c);
   if (STILL_ACTIVE == c)
-  {
-    *type = GNUNET_OS_PROCESS_RUNNING;
-    *code = 0;
-    CloseHandle (h);
-    return GNUNET_NO;
-  }
+    {
+      *type = GNUNET_OS_PROCESS_RUNNING;
+      *code = 0;
+      CloseHandle (h);
+      return GNUNET_NO;
+    }
   *type = GNUNET_OS_PROCESS_EXITED;
   *code = c;
   CloseHandle (h);
@@ -362,16 +515,16 @@ GNUNET_OS_process_wait (pid_t proc)
 
   h = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, proc);
   if (INVALID_HANDLE_VALUE == h)
-  {
-    SetErrnoFromWinError (GetLastError ());
-    return GNUNET_SYSERR;
-  }
+    {
+      SetErrnoFromWinError (GetLastError ());
+      return GNUNET_SYSERR;
+    }
 
   if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
-  {
-    SetErrnoFromWinError (GetLastError ());
-    ret = GNUNET_SYSERR;
-  }
+    {
+      SetErrnoFromWinError (GetLastError ());
+      ret = GNUNET_SYSERR;
+    }
   else
     ret = GNUNET_OK;