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