#include "Win32.h"
#include <malloc.h>
+#include <io.h>
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only Win32 specific code
}
}
-//
+static HANDLE RedirectIO(const Path *path, int fd) {
+ HANDLE h;
+ if (path == 0) {
+ DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
+ GetCurrentProcess(), &h,
+ 0, TRUE, DUPLICATE_SAME_ACCESS);
+ return h;
+ }
+
+ const char *fname = path->toString().c_str();
+ if (*fname == 0)
+ fname = "NUL";
+
+ SECURITY_ATTRIBUTES sa;
+ sa.nLength = sizeof(sa);
+ sa.lpSecurityDescriptor = 0;
+ sa.bInheritHandle = TRUE;
+
+ h = CreateFile(fname, fd ? GENERIC_WRITE : GENERIC_READ, FILE_SHARE_READ,
+ &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL, NULL);
+ if (h == INVALID_HANDLE_VALUE) {
+ ThrowError(std::string(fname) + ": Can't open file for " +
+ (fd ? "input: " : "output: "));
+ }
+ return h;
+}
+
int
Program::ExecuteAndWait(const Path& path,
- const std::vector<std::string>& args,
- const char** env) {
+ const char** args,
+ const char** envp,
+ const Path** redirects,
+ unsigned secondsToWait) {
if (!path.executable())
throw path.toString() + " is not executable";
// have embedded spaces.
// First, determine the length of the command line.
- std::string progname(path.getLast());
- unsigned len = progname.length() + 1;
- if (progname.find(' ') != std::string::npos)
- len += 2;
-
- for (unsigned i = 0; i < args.size(); i++) {
- len += args[i].length() + 1;
- if (args[i].find(' ') != std::string::npos)
+ unsigned len = 0;
+ for (unsigned i = 0; args[i]; i++) {
+ len += strlen(args[i]) + 1;
+ if (strchr(args[i], ' '))
len += 2;
}
char *command = reinterpret_cast<char *>(_alloca(len));
char *p = command;
- bool needsQuoting = progname.find(' ') != std::string::npos;
- if (needsQuoting)
- *p++ = '"';
- memcpy(p, progname.c_str(), progname.length());
- p += progname.length();
- if (needsQuoting)
- *p++ = '"';
- *p++ = ' ';
-
- for (unsigned i = 0; i < args.size(); i++) {
- const std::string& arg = args[i];
- needsQuoting = arg.find(' ') != std::string::npos;
+ for (unsigned i = 0; args[i]; i++) {
+ const char *arg = args[i];
+ size_t len = strlen(arg);
+ bool needsQuoting = strchr(arg, ' ') != 0;
if (needsQuoting)
*p++ = '"';
- memcpy(p, arg.c_str(), arg.length());
- p += arg.length();
+ memcpy(p, arg, len);
+ p += len;
if (needsQuoting)
*p++ = '"';
*p++ = ' ';
STARTUPINFO si;
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
+ si.hStdInput = INVALID_HANDLE_VALUE;
+ si.hStdOutput = INVALID_HANDLE_VALUE;
+ si.hStdError = INVALID_HANDLE_VALUE;
+
+ if (redirects) {
+ si.dwFlags = STARTF_USESTDHANDLES;
+
+ try {
+ si.hStdInput = RedirectIO(redirects[0], 0);
+ si.hStdOutput = RedirectIO(redirects[1], 1);
+ if (redirects[1] && redirects[2] && *(redirects[1]) != *(redirects[2])) {
+ si.hStdError = RedirectIO(redirects[2], 2);
+ } else {
+ DuplicateHandle(GetCurrentProcess(), si.hStdOutput,
+ GetCurrentProcess(), &si.hStdError,
+ 0, TRUE, DUPLICATE_SAME_ACCESS);
+ }
+ } catch (...) {
+ CloseHandle(si.hStdInput);
+ CloseHandle(si.hStdOutput);
+ CloseHandle(si.hStdError);
+ throw;
+ }
+ }
PROCESS_INFORMATION pi;
memset(&pi, 0, sizeof(pi));
- LPVOID lpEnvironment = envp;
- if (!CreateProcess(path.c_str(), command, NULL, NULL, FALSE, 0,
- lpEnvironment, NULL, &si, &pi))
+ fflush(stdout);
+ fflush(stderr);
+ BOOL rc = CreateProcess(path.c_str(), command, NULL, NULL, FALSE, 0,
+ envp, NULL, &si, &pi);
+ DWORD err = GetLastError();
+
+ // Regardless of whether the process got created or not, we are done with
+ // the handles we created for it to inherit.
+ CloseHandle(si.hStdInput);
+ CloseHandle(si.hStdOutput);
+ CloseHandle(si.hStdError);
+
+ // Now throw an error if the process didn't get created.
+ if (!rc)
{
+ SetLastError(err);
ThrowError(std::string("Couldn't execute program '") +
path.toString() + "'");
}
// Wait for it to terminate.
- WaitForSingleObject(pi.hProcess, INFINITE);
+ DWORD millisecondsToWait = INFINITE;
+ if (secondsToWait > 0)
+ millisecondsToWait = secondsToWait * 1000;
+
+ if (WaitForSingleObject(pi.hProcess, millisecondsToWait) == WAIT_TIMEOUT) {
+ if (!TerminateProcess(pi.hProcess, 1)) {
+ ThrowError(std::string("Failed to terminate timed-out program '") +
+ path.toString() + "'");
+ }
+ WaitForSingleObject(pi.hProcess, INFINITE);
+ }
// Get its exit status.
DWORD status;
- BOOL rc = GetExitCodeProcess(pi.hProcess, &status);
+ rc = GetExitCodeProcess(pi.hProcess, &status);
+ err = GetLastError();
// Done with the handles; go close them.
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
- if (!rc)
+ if (!rc) {
+ SetLastError(err);
ThrowError(std::string("Failed getting status for program '") +
path.toString() + "'");
+ }
return status;
}