lib/Support/Windows/Program.inc

   1 //===- Win32/Program.cpp - Win32 Program Implementation ------- -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file provides the Win32 specific implementation of the Program class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Windows.h"
  15 #include "llvm/Support/FileSystem.h"
  16 #include <cstdio>
  17 #include <fcntl.h>
  18 #include <io.h>
  19 #include <malloc.h>
  20
  21 //===----------------------------------------------------------------------===//
  22 //=== WARNING: Implementation here must contain only Win32 specific code
  23 //===          and must not be UNIX code
  24 //===----------------------------------------------------------------------===//
  25
  26 namespace {
  27   struct Win32ProcessInfo {
  28     HANDLE hProcess;
  29     DWORD  dwProcessId;
  30   };
  31 }
  32
  33 namespace llvm {
  34 using namespace sys;
  35
  36 // This function just uses the PATH environment variable to find the program.
  37 std::string sys::FindProgramByName(const std::string &progName) {
  38   // Check some degenerate cases
  39   if (progName.length() == 0) // no program
  40     return "";
  41   std::string temp = progName;
  42   // Return paths with slashes verbatim.
  43   if (progName.find('\\') != std::string::npos ||
  44       progName.find('/') != std::string::npos)
  45     return temp;
  46
  47   // At this point, the file name is valid and does not contain slashes.
  48   // Let Windows search for it.
  49   char buffer[MAX_PATH];
  50   char *dummy = NULL;
  51   DWORD len = SearchPath(NULL, progName.c_str(), ".exe", MAX_PATH,
  52                          buffer, &dummy);
  53
  54   // See if it wasn't found.
  55   if (len == 0)
  56     return "";
  57
  58   // See if we got the entire path.
  59   if (len < MAX_PATH)
  60     return std::string(buffer);
  61
  62   // Buffer was too small; grow and retry.
  63   while (true) {
  64     char *b = reinterpret_cast<char *>(_alloca(len+1));
  65     DWORD len2 = SearchPath(NULL, progName.c_str(), ".exe", len+1, b, &dummy);
  66
  67     // It is unlikely the search failed, but it's always possible some file
  68     // was added or removed since the last search, so be paranoid...
  69     if (len2 == 0)
  70       return "";
  71     else if (len2 <= len)
  72       return std::string(b);
  73
  74     len = len2;
  75   }
  76 }
  77
  78 static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) {
  79   HANDLE h;
  80   if (path == 0) {
  81     DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
  82                     GetCurrentProcess(), &h,
  83                     0, TRUE, DUPLICATE_SAME_ACCESS);
  84     return h;
  85   }
  86
  87   std::string fname;
  88   if (path->empty())
  89     fname = "NUL";
  90   else
  91     fname = *path;
  92
  93   SECURITY_ATTRIBUTES sa;
  94   sa.nLength = sizeof(sa);
  95   sa.lpSecurityDescriptor = 0;
  96   sa.bInheritHandle = TRUE;
  97
  98   h = CreateFile(fname.c_str(), fd ? GENERIC_WRITE : GENERIC_READ,
  99                  FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
 100                  FILE_ATTRIBUTE_NORMAL, NULL);
 101   if (h == INVALID_HANDLE_VALUE) {
 102     MakeErrMsg(ErrMsg, std::string(fname) + ": Can't open file for " +
 103         (fd ? "input: " : "output: "));
 104   }
 105
 106   return h;
 107 }
 108
 109 /// ArgNeedsQuotes - Check whether argument needs to be quoted when calling
 110 /// CreateProcess.
 111 static bool ArgNeedsQuotes(const char *Str) {
 112   return Str[0] == '\0' || strpbrk(Str, "\t \"&\'()*<>\\`^|") != 0;
 113 }
 114
 115 /// CountPrecedingBackslashes - Returns the number of backslashes preceding Cur
 116 /// in the C string Start.
 117 static unsigned int CountPrecedingBackslashes(const char *Start,
 118                                               const char *Cur) {
 119   unsigned int Count = 0;
 120   --Cur;
 121   while (Cur >= Start && *Cur == '\\') {
 122     ++Count;
 123     --Cur;
 124   }
 125   return Count;
 126 }
 127
 128 /// EscapePrecedingEscapes - Append a backslash to Dst for every backslash
 129 /// preceding Cur in the Start string.  Assumes Dst has enough space.
 130 static char *EscapePrecedingEscapes(char *Dst, const char *Start,
 131                                     const char *Cur) {
 132   unsigned PrecedingEscapes = CountPrecedingBackslashes(Start, Cur);
 133   while (PrecedingEscapes > 0) {
 134     *Dst++ = '\\';
 135     --PrecedingEscapes;
 136   }
 137   return Dst;
 138 }
 139
 140 /// ArgLenWithQuotes - Check whether argument needs to be quoted when calling
 141 /// CreateProcess and returns length of quoted arg with escaped quotes
 142 static unsigned int ArgLenWithQuotes(const char *Str) {
 143   const char *Start = Str;
 144   bool Quoted = ArgNeedsQuotes(Str);
 145   unsigned int len = Quoted ? 2 : 0;
 146
 147   while (*Str != '\0') {
 148     if (*Str == '\"') {
 149       // We need to add a backslash, but ensure that it isn't escaped.
 150       unsigned PrecedingEscapes = CountPrecedingBackslashes(Start, Str);
 151       len += PrecedingEscapes + 1;
 152     }
 153     // Note that we *don't* need to escape runs of backslashes that don't
 154     // precede a double quote!  See MSDN:
 155     // http://msdn.microsoft.com/en-us/library/17w5ykft%28v=vs.85%29.aspx
 156
 157     ++len;
 158     ++Str;
 159   }
 160
 161   if (Quoted) {
 162     // Make sure the closing quote doesn't get escaped by a trailing backslash.
 163     unsigned PrecedingEscapes = CountPrecedingBackslashes(Start, Str);
 164     len += PrecedingEscapes + 1;
 165   }
 166
 167   return len;
 168 }
 169
 170 }
 171
 172 static bool Execute(void **Data,
 173                     StringRef Program,
 174                     const char** args,
 175                     const char** envp,
 176                     const StringRef** redirects,
 177                     unsigned memoryLimit,
 178                     std::string* ErrMsg) {
 179   if (!sys::fs::can_execute(Program)) {
 180     if (ErrMsg)
 181       *ErrMsg = "program not executable";
 182     return false;
 183   }
 184
 185   // Windows wants a command line, not an array of args, to pass to the new
 186   // process.  We have to concatenate them all, while quoting the args that
 187   // have embedded spaces (or are empty).
 188
 189   // First, determine the length of the command line.
 190   unsigned len = 0;
 191   for (unsigned i = 0; args[i]; i++) {
 192     len += ArgLenWithQuotes(args[i]) + 1;
 193   }
 194
 195   // Now build the command line.
 196   char *command = reinterpret_cast<char *>(_alloca(len+1));
 197   char *p = command;
 198
 199   for (unsigned i = 0; args[i]; i++) {
 200     const char *arg = args[i];
 201     const char *start = arg;
 202
 203     bool needsQuoting = ArgNeedsQuotes(arg);
 204     if (needsQuoting)
 205       *p++ = '"';
 206
 207     while (*arg != '\0') {
 208       if (*arg == '\"') {
 209         // Escape all preceding escapes (if any), and then escape the quote.
 210         p = EscapePrecedingEscapes(p, start, arg);
 211         *p++ = '\\';
 212       }
 213
 214       *p++ = *arg++;
 215     }
 216
 217     if (needsQuoting) {
 218       // Make sure our quote doesn't get escaped by a trailing backslash.
 219       p = EscapePrecedingEscapes(p, start, arg);
 220       *p++ = '"';
 221     }
 222     *p++ = ' ';
 223   }
 224
 225   *p = 0;
 226
 227   // The pointer to the environment block for the new process.
 228   char *envblock = 0;
 229
 230   if (envp) {
 231     // An environment block consists of a null-terminated block of
 232     // null-terminated strings. Convert the array of environment variables to
 233     // an environment block by concatenating them.
 234
 235     // First, determine the length of the environment block.
 236     len = 0;
 237     for (unsigned i = 0; envp[i]; i++)
 238       len += strlen(envp[i]) + 1;
 239
 240     // Now build the environment block.
 241     envblock = reinterpret_cast<char *>(_alloca(len+1));
 242     p = envblock;
 243
 244     for (unsigned i = 0; envp[i]; i++) {
 245       const char *ev = envp[i];
 246       size_t len = strlen(ev) + 1;
 247       memcpy(p, ev, len);
 248       p += len;
 249     }
 250
 251     *p = 0;
 252   }
 253
 254   // Create a child process.
 255   STARTUPINFO si;
 256   memset(&si, 0, sizeof(si));
 257   si.cb = sizeof(si);
 258   si.hStdInput = INVALID_HANDLE_VALUE;
 259   si.hStdOutput = INVALID_HANDLE_VALUE;
 260   si.hStdError = INVALID_HANDLE_VALUE;
 261
 262   if (redirects) {
 263     si.dwFlags = STARTF_USESTDHANDLES;
 264
 265     si.hStdInput = RedirectIO(redirects[0], 0, ErrMsg);
 266     if (si.hStdInput == INVALID_HANDLE_VALUE) {
 267       MakeErrMsg(ErrMsg, "can't redirect stdin");
 268       return false;
 269     }
 270     si.hStdOutput = RedirectIO(redirects[1], 1, ErrMsg);
 271     if (si.hStdOutput == INVALID_HANDLE_VALUE) {
 272       CloseHandle(si.hStdInput);
 273       MakeErrMsg(ErrMsg, "can't redirect stdout");
 274       return false;
 275     }
 276     if (redirects[1] && redirects[2] && *(redirects[1]) == *(redirects[2])) {
 277       // If stdout and stderr should go to the same place, redirect stderr
 278       // to the handle already open for stdout.
 279       DuplicateHandle(GetCurrentProcess(), si.hStdOutput,
 280                       GetCurrentProcess(), &si.hStdError,
 281                       0, TRUE, DUPLICATE_SAME_ACCESS);
 282     } else {
 283       // Just redirect stderr
 284       si.hStdError = RedirectIO(redirects[2], 2, ErrMsg);
 285       if (si.hStdError == INVALID_HANDLE_VALUE) {
 286         CloseHandle(si.hStdInput);
 287         CloseHandle(si.hStdOutput);
 288         MakeErrMsg(ErrMsg, "can't redirect stderr");
 289         return false;
 290       }
 291     }
 292   }
 293
 294   PROCESS_INFORMATION pi;
 295   memset(&pi, 0, sizeof(pi));
 296
 297   fflush(stdout);
 298   fflush(stderr);
 299   std::string ProgramStr = Program;
 300   BOOL rc = CreateProcess(ProgramStr.c_str(), command, NULL, NULL, TRUE, 0,
 301                           envblock, NULL, &si, &pi);
 302   DWORD err = GetLastError();
 303
 304   // Regardless of whether the process got created or not, we are done with
 305   // the handles we created for it to inherit.
 306   CloseHandle(si.hStdInput);
 307   CloseHandle(si.hStdOutput);
 308   CloseHandle(si.hStdError);
 309
 310   // Now return an error if the process didn't get created.
 311   if (!rc) {
 312     SetLastError(err);
 313     MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
 314                ProgramStr + "'");
 315     return false;
 316   }
 317   if (Data) {
 318     Win32ProcessInfo* wpi = new Win32ProcessInfo;
 319     wpi->hProcess = pi.hProcess;
 320     wpi->dwProcessId = pi.dwProcessId;
 321     *Data = wpi;
 322   }
 323
 324   // Make sure these get closed no matter what.
 325   ScopedCommonHandle hThread(pi.hThread);
 326
 327   // Assign the process to a job if a memory limit is defined.
 328   ScopedJobHandle hJob;
 329   if (memoryLimit != 0) {
 330     hJob = CreateJobObject(0, 0);
 331     bool success = false;
 332     if (hJob) {
 333       JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli;
 334       memset(&jeli, 0, sizeof(jeli));
 335       jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_MEMORY;
 336       jeli.ProcessMemoryLimit = uintptr_t(memoryLimit) * 1048576;
 337       if (SetInformationJobObject(hJob, JobObjectExtendedLimitInformation,
 338                                   &jeli, sizeof(jeli))) {
 339         if (AssignProcessToJobObject(hJob, pi.hProcess))
 340           success = true;
 341       }
 342     }
 343     if (!success) {
 344       SetLastError(GetLastError());
 345       MakeErrMsg(ErrMsg, std::string("Unable to set memory limit"));
 346       TerminateProcess(pi.hProcess, 1);
 347       WaitForSingleObject(pi.hProcess, INFINITE);
 348       return false;
 349     }
 350   }
 351
 352   // Don't leak the handle if the caller doesn't want it.
 353   if (!Data)
 354     CloseHandle(pi.hProcess);
 355
 356   return true;
 357 }
 358
 359 static int WaitAux(Win32ProcessInfo *wpi, unsigned secondsToWait,
 360                    std::string *ErrMsg) {
 361   // Wait for the process to terminate.
 362   HANDLE hProcess = wpi->hProcess;
 363   DWORD millisecondsToWait = INFINITE;
 364   if (secondsToWait > 0)
 365     millisecondsToWait = secondsToWait * 1000;
 366
 367   if (WaitForSingleObject(hProcess, millisecondsToWait) == WAIT_TIMEOUT) {
 368     if (!TerminateProcess(hProcess, 1)) {
 369       MakeErrMsg(ErrMsg, "Failed to terminate timed-out program.");
 370       // -2 indicates a crash or timeout as opposed to failure to execute.
 371       return -2;
 372     }
 373     WaitForSingleObject(hProcess, INFINITE);
 374   }
 375
 376   // Get its exit status.
 377   DWORD status;
 378   BOOL rc = GetExitCodeProcess(hProcess, &status);
 379   DWORD err = GetLastError();
 380
 381   if (!rc) {
 382     SetLastError(err);
 383     MakeErrMsg(ErrMsg, "Failed getting status for program.");
 384     // -2 indicates a crash or timeout as opposed to failure to execute.
 385     return -2;
 386   }
 387
 388   if (!status)
 389     return 0;
 390
 391   // Pass 10(Warning) and 11(Error) to the callee as negative value.
 392   if ((status & 0xBFFF0000U) == 0x80000000U)
 393     return (int)status;
 394
 395   if (status & 0xFF)
 396     return status & 0x7FFFFFFF;
 397
 398   return 1;
 399 }
 400
 401 static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
 402                 std::string *ErrMsg) {
 403   Win32ProcessInfo *wpi = reinterpret_cast<Win32ProcessInfo *>(Data);
 404   int Ret = WaitAux(wpi, secondsToWait, ErrMsg);
 405
 406   CloseHandle(wpi->hProcess);
 407   delete wpi;
 408   Data = 0;
 409
 410   return Ret;
 411 }
 412
 413 namespace llvm {
 414 error_code sys::ChangeStdinToBinary(){
 415   int result = _setmode( _fileno(stdin), _O_BINARY );
 416   if (result == -1)
 417     return error_code(errno, generic_category());
 418   return make_error_code(errc::success);
 419 }
 420
 421 error_code sys::ChangeStdoutToBinary(){
 422   int result = _setmode( _fileno(stdout), _O_BINARY );
 423   if (result == -1)
 424     return error_code(errno, generic_category());
 425   return make_error_code(errc::success);
 426 }
 427
 428 error_code sys::ChangeStderrToBinary(){
 429   int result = _setmode( _fileno(stderr), _O_BINARY );
 430   if (result == -1)
 431     return error_code(errno, generic_category());
 432   return make_error_code(errc::success);
 433 }
 434
 435 bool llvm::sys::argumentsFitWithinSystemLimits(ArrayRef<const char*> Args) {
 436   // The documented max length of the command line passed to CreateProcess.
 437   static const size_t MaxCommandStringLength = 32768;
 438   size_t ArgLength = 0;
 439   for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
 440        I != E; ++I) {
 441     // Account for the trailing space for every arg but the last one and the
 442     // trailing NULL of the last argument.
 443     ArgLength += ArgLenWithQuotes(*I) + 1;
 444     if (ArgLength > MaxCommandStringLength) {
 445       return false;
 446     }
 447   }
 448   return true;
 449 }
 450
 451 }