replace _wspawnvp() by CreateProcessW()

Author: Daniel Kroening

src/util/run.cpp

@@ -12,6 +12,7 @@ Date: August 2012
 
 #ifdef _WIN32
 #include <process.h>
+#include <windows.h>
 #else
 
 #include <cstring>
@@ -37,14 +38,85 @@ int run(const std::string &what, const std::vector<std::string> &argv)
   return run(what, argv, "", "", "");
 }
 
-#ifndef _WIN32
+#ifdef _WIN32
+#define STDIN_FILENO 0
+#define STDOUT_FILENO 1
+#define STDERR_FILENO 2
+using fdt = HANDLE;
+#else
+using fdt = int;
+#endif
+
 /// open given file to replace either stdin, stderr, stdout
-static int stdio_redirection(int fd, const std::string &file)
+static fdt stdio_redirection(int fd, const std::string &file)
 {
-  int result_fd = fd;
+  fdt result_fd;
+
+#ifdef _WIN32
+  std::string name;
+
+  SECURITY_ATTRIBUTES SecurityAttributes;
+  ZeroMemory(&SecurityAttributes, sizeof SecurityAttributes);
+  SecurityAttributes.bInheritHandle = true;
+
+  switch(fd)
+  {
+  case STDIN_FILENO:
+    name = "stdin";
+    if(file.empty())
+      result_fd = GetStdHandle(STD_INPUT_HANDLE);
+    else
+      result_fd = CreateFileW(
+        widen(file).c_str(),
+        GENERIC_READ,
+        0,
+        &SecurityAttributes,
+        OPEN_EXISTING,
+        FILE_ATTRIBUTE_READONLY,
+        NULL);
+    break;
+
+  case STDOUT_FILENO:
+    name = "stdout";
+    if(file.empty())
+      result_fd = GetStdHandle(STD_OUTPUT_HANDLE);
+    else
+      result_fd = CreateFileW(
+        widen(file).c_str(),
+        GENERIC_WRITE,
+        0,
+        &SecurityAttributes,
+        CREATE_ALWAYS,
+        FILE_ATTRIBUTE_NORMAL,
+        NULL);
+    break;
+
+  case STDERR_FILENO:
+    name = "stderr";
+    if(file.empty())
+      result_fd = GetStdHandle(STD_ERROR_HANDLE);
+    else
+      result_fd = CreateFileW(
+        widen(file).c_str(),
+        GENERIC_WRITE,
+        0,
+        &SecurityAttributes,
+        CREATE_ALWAYS,
+        FILE_ATTRIBUTE_NORMAL,
+        NULL);
+    break;
+
+  default:
+    UNREACHABLE;
+  }
+
+  if(result_fd == INVALID_HANDLE_VALUE)
+    perror(("Failed to open " + name + " file " + file).c_str());
+
+#else
 
   if(file.empty())
-    return result_fd;
+    return fd;
 
   int flags = 0, mode = 0;
   std::string name;
@@ -68,12 +140,13 @@ static int stdio_redirection(int fd, const std::string &file)
   }
 
   result_fd = open(file.c_str(), flags, mode);
+
   if(result_fd == -1)
     perror(("Failed to open " + name + " file " + file).c_str());
+#endif
 
   return result_fd;
 }
-#endif
 
 #ifdef _WIN32
 // Read
@@ -140,56 +213,87 @@ int run(
   const std::string &std_output,
   const std::string &std_error)
 {
-  #ifdef _WIN32
-  // we use the cmd.exe shell to do stdin/stdout/stderr redirection on Windows
-  if(!std_input.empty() || !std_output.empty() || !std_error.empty())
+#ifdef _WIN32
+  // unicode commandline, quoted
+  std::wstring cmdline;
+
+  // we replace argv[0] by what
+  cmdline = quote_windows_arg(widen(what));
+
+  for(std::size_t i = 1; i < argv.size(); i++)
   {
-    std::vector<std::string> new_argv = argv;
-    new_argv.insert(new_argv.begin(), "cmd.exe");
-    new_argv.insert(new_argv.begin() + 1, "/c");
+    cmdline += L" ";
+    cmdline += quote_windows_arg(widen(argv[i]));
+  }
 
-    if(!std_input.empty())
-    {
-      new_argv.push_back("<");
-      new_argv.push_back(std_input);
-    }
+  PROCESS_INFORMATION piProcInfo;
+  STARTUPINFOW siStartInfo;
 
-    if(!std_output.empty())
-    {
-      new_argv.push_back(">");
-      new_argv.push_back(std_output);
-    }
+  ZeroMemory(&piProcInfo, sizeof piProcInfo);
+  ZeroMemory(&siStartInfo, sizeof siStartInfo);
 
-    if(!std_error.empty())
-    {
-      new_argv.push_back("2>");
-      new_argv.push_back(std_error);
-    }
+  siStartInfo.cb = sizeof siStartInfo;
 
-    // this is recursive
-    return run(new_argv[0], new_argv, "", "", "");
-  }
+  siStartInfo.hStdInput = stdio_redirection(STDIN_FILENO, std_input);
+  siStartInfo.hStdOutput = stdio_redirection(STDOUT_FILENO, std_output);
+  siStartInfo.hStdError = stdio_redirection(STDERR_FILENO, std_error);
 
-  // unicode and whitespace-quoted version of the arguments
-  std::vector<std::wstring> wargv;
+  siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
 
-  wargv.resize(argv.size());
+  // CreateProcessW wants to modify the command line
+  std::vector<wchar_t> mutable_cmdline(cmdline.begin(), cmdline.end());
+  mutable_cmdline.push_back(0); // zero termination
+  wchar_t *cmdline_ptr = mutable_cmdline.data();
 
-  for(std::size_t i=0; i<argv.size(); i++)
-    wargv[i]=quote_windows_arg(widen(argv[i]));
+  BOOL bSuccess = CreateProcessW(
+    NULL,         // application name
+    cmdline_ptr,  // command line
+    NULL,         // process security attributes
+    NULL,         // primary thread security attributes
+    true,         // handles are inherited
+    0,            // creation flags
+    NULL,         // use parent's environment
+    NULL,         // use parent's current directory
+    &siStartInfo, // STARTUPINFO
+    &piProcInfo); // PROCESS_INFORMATION
 
-  std::vector<const wchar_t *> _argv(argv.size()+1);
+  if(!bSuccess)
+  {
+    if(!std_input.empty())
+      CloseHandle(siStartInfo.hStdInput);
+    if(!std_output.empty())
+      CloseHandle(siStartInfo.hStdOutput);
+    if(!std_error.empty())
+      CloseHandle(siStartInfo.hStdError);
+    return -1;
+  }
 
-  for(std::size_t i=0; i<wargv.size(); i++)
-    _argv[i]=wargv[i].c_str();
+  // wait for child to finish
+  WaitForSingleObject(piProcInfo.hProcess, INFINITE);
 
-  _argv[argv.size()]=NULL;
+  if(!std_input.empty())
+    CloseHandle(siStartInfo.hStdInput);
+  if(!std_output.empty())
+    CloseHandle(siStartInfo.hStdOutput);
+  if(!std_error.empty())
+    CloseHandle(siStartInfo.hStdError);
 
-  std::wstring wide_what=widen(what);
-  int status=_wspawnvp(_P_WAIT, wide_what.c_str(), _argv.data());
-  return status;
+  DWORD exit_code;
 
-  #else
+  // get exit code
+  if(!GetExitCodeProcess(piProcInfo.hProcess, &exit_code))
+  {
+    CloseHandle(piProcInfo.hProcess);
+    CloseHandle(piProcInfo.hThread);
+    return -1;
+  }
+
+  CloseHandle(piProcInfo.hProcess);
+  CloseHandle(piProcInfo.hThread);
+
+  return exit_code;
+
+#else
   int stdin_fd = stdio_redirection(STDIN_FILENO, std_input);
   int stdout_fd = stdio_redirection(STDOUT_FILENO, std_output);
   int stderr_fd = stdio_redirection(STDERR_FILENO, std_error);
@@ -280,5 +384,5 @@ int run(
 
     return 1;
   }
-  #endif
+#endif
 }