//===----------------------------------------------------------------------===//
#include "Win32.h"
+#include <cstdio>
#include <malloc.h>
#include <io.h>
+#include <fcntl.h>
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only Win32 specific code
if (progName.length() == 0) // no program
return Path();
Path temp;
- if (!temp.setFile(progName)) // invalid name
+ if (!temp.set(progName)) // invalid name
return Path();
- if (temp.executable()) // already executable as is
+ if (temp.canExecute()) // already executable as is
return temp;
// At this point, the file name is valid and its not executable.
}
}
-static HANDLE RedirectIO(const Path *path, int fd) {
+static HANDLE RedirectIO(const Path *path, int fd, std::string* ErrMsg) {
HANDLE h;
if (path == 0) {
DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
&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 " +
+ MakeErrMsg(ErrMsg, std::string(fname) + ": Can't open file for " +
(fd ? "input: " : "output: "));
}
+
return h;
}
+#ifdef __MINGW32__
+ // Due to unknown reason, mingw32's w32api doesn't have this declaration.
+ extern "C"
+ BOOL WINAPI SetInformationJobObject(HANDLE hJob,
+ JOBOBJECTINFOCLASS JobObjectInfoClass,
+ LPVOID lpJobObjectInfo,
+ DWORD cbJobObjectInfoLength);
+#endif
+
int
Program::ExecuteAndWait(const Path& path,
const char** args,
const char** envp,
const Path** redirects,
- unsigned secondsToWait) {
- if (!path.executable())
- throw path.toString() + " is not executable";
+ unsigned secondsToWait,
+ unsigned memoryLimit,
+ std::string* ErrMsg) {
+ if (!path.canExecute()) {
+ if (ErrMsg)
+ *ErrMsg = "program not executable";
+ return -1;
+ }
// Windows wants a command line, not an array of args, to pass to the new
// process. We have to concatenate them all, while quoting the args that
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 (...) {
+ si.hStdInput = RedirectIO(redirects[0], 0, ErrMsg);
+ if (si.hStdInput == INVALID_HANDLE_VALUE) {
+ MakeErrMsg(ErrMsg, "can't redirect stdin");
+ return -1;
+ }
+ si.hStdOutput = RedirectIO(redirects[1], 1, ErrMsg);
+ if (si.hStdOutput == INVALID_HANDLE_VALUE) {
CloseHandle(si.hStdInput);
- CloseHandle(si.hStdOutput);
- CloseHandle(si.hStdError);
- throw;
+ MakeErrMsg(ErrMsg, "can't redirect stdout");
+ return -1;
+ }
+ if (redirects[1] && redirects[2] && *(redirects[1]) != *(redirects[2])) {
+ si.hStdError = RedirectIO(redirects[2], 2, ErrMsg);
+ if (si.hStdError == INVALID_HANDLE_VALUE) {
+ CloseHandle(si.hStdInput);
+ CloseHandle(si.hStdOutput);
+ MakeErrMsg(ErrMsg, "can't redirect stderr");
+ return -1;
+ }
+ } else {
+ DuplicateHandle(GetCurrentProcess(), si.hStdOutput,
+ GetCurrentProcess(), &si.hStdError,
+ 0, TRUE, DUPLICATE_SAME_ACCESS);
}
}
-
+
PROCESS_INFORMATION pi;
memset(&pi, 0, sizeof(pi));
CloseHandle(si.hStdOutput);
CloseHandle(si.hStdError);
- // Now throw an error if the process didn't get created.
+ // Now return an error if the process didn't get created.
if (!rc)
{
SetLastError(err);
- ThrowError(std::string("Couldn't execute program '") +
+ MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
path.toString() + "'");
+ return -1;
+ }
+
+ // Make sure these get closed no matter what.
+ AutoHandle hProcess(pi.hProcess);
+ AutoHandle hThread(pi.hThread);
+
+ // Assign the process to a job if a memory limit is defined.
+ AutoHandle hJob(0);
+ if (memoryLimit != 0) {
+ hJob = CreateJobObject(0, 0);
+ bool success = false;
+ if (hJob != 0) {
+ JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli;
+ memset(&jeli, 0, sizeof(jeli));
+ jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_MEMORY;
+ jeli.ProcessMemoryLimit = uintptr_t(memoryLimit) * 1048576;
+ if (SetInformationJobObject(hJob, JobObjectExtendedLimitInformation,
+ &jeli, sizeof(jeli))) {
+ if (AssignProcessToJobObject(hJob, pi.hProcess))
+ success = true;
+ }
+ }
+ if (!success) {
+ SetLastError(GetLastError());
+ MakeErrMsg(ErrMsg, std::string("Unable to set memory limit"));
+ TerminateProcess(pi.hProcess, 1);
+ WaitForSingleObject(pi.hProcess, INFINITE);
+ return -1;
+ }
}
// Wait for it to terminate.
if (WaitForSingleObject(pi.hProcess, millisecondsToWait) == WAIT_TIMEOUT) {
if (!TerminateProcess(pi.hProcess, 1)) {
- ThrowError(std::string("Failed to terminate timed-out program '") +
- path.toString() + "'");
+ MakeErrMsg(ErrMsg, std::string("Failed to terminate timed-out program '")
+ + path.toString() + "'");
+ return -1;
}
WaitForSingleObject(pi.hProcess, INFINITE);
}
rc = GetExitCodeProcess(pi.hProcess, &status);
err = GetLastError();
- // Done with the handles; go close them.
- CloseHandle(pi.hProcess);
- CloseHandle(pi.hThread);
-
if (!rc) {
SetLastError(err);
- ThrowError(std::string("Failed getting status for program '") +
+ MakeErrMsg(ErrMsg, std::string("Failed getting status for program '") +
path.toString() + "'");
+ return -1;
}
return status;
}
+bool Program::ChangeStdinToBinary(){
+ int result = _setmode( _fileno(stdin), _O_BINARY );
+ return result == -1;
+}
+
+bool Program::ChangeStdoutToBinary(){
+ int result = _setmode( _fileno(stdout), _O_BINARY );
+ return result == -1;
+}
+
}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
projects / oota-llvm.git / blobdiff