#include "WindowsSupport.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/WindowsError.h"
#include "llvm/Support/raw_ostream.h"
#include <cstdio>
#include <fcntl.h>
#include <io.h>
#include <malloc.h>
namespace llvm {
using namespace sys;
ProcessInfo::ProcessInfo() : ProcessHandle(0), Pid(0), ReturnCode(0) {}
ErrorOr<std::string> sys::findProgramByName(StringRef Name,
ArrayRef<StringRef> Paths) {
assert(!Name.empty() && "Must have a name!");
if (Name.find_first_of("/\\") != StringRef::npos)
return std::string(Name);
const wchar_t *Path = nullptr;
std::wstring PathStorage;
if (!Paths.empty()) {
PathStorage.reserve(Paths.size() * MAX_PATH);
for (unsigned i = 0; i < Paths.size(); ++i) {
if (i)
PathStorage.push_back(L';');
StringRef P = Paths[i];
SmallVector<wchar_t, MAX_PATH> TmpPath;
if (std::error_code EC = windows::UTF8ToUTF16(P, TmpPath))
return EC;
PathStorage.append(TmpPath.begin(), TmpPath.end());
}
Path = PathStorage.c_str();
}
SmallVector<wchar_t, MAX_PATH> U16Name;
if (std::error_code EC = windows::UTF8ToUTF16(Name, U16Name))
return EC;
SmallVector<StringRef, 12> PathExts;
PathExts.push_back("");
PathExts.push_back(".exe"); if (const char *PathExtEnv = std::getenv("PATHEXT"))
SplitString(PathExtEnv, PathExts, ";");
SmallVector<wchar_t, MAX_PATH> U16Result;
DWORD Len = MAX_PATH;
for (StringRef Ext : PathExts) {
SmallVector<wchar_t, MAX_PATH> U16Ext;
if (std::error_code EC = windows::UTF8ToUTF16(Ext, U16Ext))
return EC;
do {
U16Result.reserve(Len);
Len = ::SearchPathW(Path, c_str(U16Name),
U16Ext.empty() ? nullptr : c_str(U16Ext),
U16Result.capacity(), U16Result.data(), nullptr);
} while (Len > U16Result.capacity());
if (Len != 0)
break; }
if (Len == 0)
return mapWindowsError(::GetLastError());
U16Result.set_size(Len);
SmallVector<char, MAX_PATH> U8Result;
if (std::error_code EC =
windows::UTF16ToUTF8(U16Result.data(), U16Result.size(), U8Result))
return EC;
return std::string(U8Result.begin(), U8Result.end());
}
static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) {
HANDLE h;
if (path == 0) {
if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
GetCurrentProcess(), &h,
0, TRUE, DUPLICATE_SAME_ACCESS))
return INVALID_HANDLE_VALUE;
return h;
}
std::string fname;
if (path->empty())
fname = "NUL";
else
fname = *path;
SECURITY_ATTRIBUTES sa;
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = 0;
sa.bInheritHandle = TRUE;
SmallVector<wchar_t, 128> fnameUnicode;
if (path->empty()) {
if (windows::UTF8ToUTF16(fname, fnameUnicode))
return INVALID_HANDLE_VALUE;
} else {
if (path::widenPath(fname, fnameUnicode))
return INVALID_HANDLE_VALUE;
}
h = CreateFileW(fnameUnicode.data(), fd ? GENERIC_WRITE : GENERIC_READ,
FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE) {
MakeErrMsg(ErrMsg, fname + ": Can't open file for " +
(fd ? "input: " : "output: "));
}
return h;
}
static bool ArgNeedsQuotes(const char *Str) {
return Str[0] == '\0' || strpbrk(Str, "\t \"&\'()*<>\\`^|") != 0;
}
static unsigned int CountPrecedingBackslashes(const char *Start,
const char *Cur) {
unsigned int Count = 0;
--Cur;
while (Cur >= Start && *Cur == '\\') {
++Count;
--Cur;
}
return Count;
}
static char *EscapePrecedingEscapes(char *Dst, const char *Start,
const char *Cur) {
unsigned PrecedingEscapes = CountPrecedingBackslashes(Start, Cur);
while (PrecedingEscapes > 0) {
*Dst++ = '\\';
--PrecedingEscapes;
}
return Dst;
}
static unsigned int ArgLenWithQuotes(const char *Str) {
const char *Start = Str;
bool Quoted = ArgNeedsQuotes(Str);
unsigned int len = Quoted ? 2 : 0;
while (*Str != '\0') {
if (*Str == '\"') {
unsigned PrecedingEscapes = CountPrecedingBackslashes(Start, Str);
len += PrecedingEscapes + 1;
}
++len;
++Str;
}
if (Quoted) {
unsigned PrecedingEscapes = CountPrecedingBackslashes(Start, Str);
len += PrecedingEscapes + 1;
}
return len;
}
}
static std::unique_ptr<char[]> flattenArgs(const char **args) {
unsigned len = 0;
for (unsigned i = 0; args[i]; i++) {
len += ArgLenWithQuotes(args[i]) + 1;
}
std::unique_ptr<char[]> command(new char[len+1]);
char *p = command.get();
for (unsigned i = 0; args[i]; i++) {
const char *arg = args[i];
const char *start = arg;
bool needsQuoting = ArgNeedsQuotes(arg);
if (needsQuoting)
*p++ = '"';
while (*arg != '\0') {
if (*arg == '\"') {
p = EscapePrecedingEscapes(p, start, arg);
*p++ = '\\';
}
*p++ = *arg++;
}
if (needsQuoting) {
p = EscapePrecedingEscapes(p, start, arg);
*p++ = '"';
}
*p++ = ' ';
}
*p = 0;
return command;
}
static bool Execute(ProcessInfo &PI, StringRef Program, const char **args,
const char **envp, const StringRef **redirects,
unsigned memoryLimit, std::string *ErrMsg) {
if (!sys::fs::can_execute(Program)) {
if (ErrMsg)
*ErrMsg = "program not executable";
return false;
}
std::unique_ptr<char[]> command = flattenArgs(args);
std::vector<wchar_t> EnvBlock;
if (envp) {
for (unsigned i = 0; envp[i]; ++i) {
SmallVector<wchar_t, MAX_PATH> EnvString;
if (std::error_code ec = windows::UTF8ToUTF16(envp[i], EnvString)) {
SetLastError(ec.value());
MakeErrMsg(ErrMsg, "Unable to convert environment variable to UTF-16");
return false;
}
EnvBlock.insert(EnvBlock.end(), EnvString.begin(), EnvString.end());
EnvBlock.push_back(0);
}
EnvBlock.push_back(0);
}
STARTUPINFOW 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;
si.hStdInput = RedirectIO(redirects[0], 0, ErrMsg);
if (si.hStdInput == INVALID_HANDLE_VALUE) {
MakeErrMsg(ErrMsg, "can't redirect stdin");
return false;
}
si.hStdOutput = RedirectIO(redirects[1], 1, ErrMsg);
if (si.hStdOutput == INVALID_HANDLE_VALUE) {
CloseHandle(si.hStdInput);
MakeErrMsg(ErrMsg, "can't redirect stdout");
return false;
}
if (redirects[1] && redirects[2] && *(redirects[1]) == *(redirects[2])) {
if (!DuplicateHandle(GetCurrentProcess(), si.hStdOutput,
GetCurrentProcess(), &si.hStdError,
0, TRUE, DUPLICATE_SAME_ACCESS)) {
CloseHandle(si.hStdInput);
CloseHandle(si.hStdOutput);
MakeErrMsg(ErrMsg, "can't dup stderr to stdout");
return false;
}
} else {
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 false;
}
}
}
PROCESS_INFORMATION pi;
memset(&pi, 0, sizeof(pi));
fflush(stdout);
fflush(stderr);
SmallVector<wchar_t, MAX_PATH> ProgramUtf16;
if (std::error_code ec = path::widenPath(Program, ProgramUtf16)) {
SetLastError(ec.value());
MakeErrMsg(ErrMsg,
std::string("Unable to convert application name to UTF-16"));
return false;
}
SmallVector<wchar_t, MAX_PATH> CommandUtf16;
if (std::error_code ec = windows::UTF8ToUTF16(command.get(), CommandUtf16)) {
SetLastError(ec.value());
MakeErrMsg(ErrMsg,
std::string("Unable to convert command-line to UTF-16"));
return false;
}
BOOL rc = CreateProcessW(ProgramUtf16.data(), CommandUtf16.data(), 0, 0,
TRUE, CREATE_UNICODE_ENVIRONMENT,
EnvBlock.empty() ? 0 : EnvBlock.data(), 0, &si,
&pi);
DWORD err = GetLastError();
CloseHandle(si.hStdInput);
CloseHandle(si.hStdOutput);
CloseHandle(si.hStdError);
if (!rc) {
SetLastError(err);
MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
Program.str() + "'");
return false;
}
PI.Pid = pi.dwProcessId;
PI.ProcessHandle = pi.hProcess;
ScopedCommonHandle hThread(pi.hThread);
ScopedJobHandle hJob;
if (memoryLimit != 0) {
hJob = CreateJobObjectW(0, 0);
bool success = false;
if (hJob) {
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 false;
}
}
return true;
}
namespace llvm {
ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
bool WaitUntilChildTerminates, std::string *ErrMsg) {
assert(PI.Pid && "invalid pid to wait on, process not started?");
assert(PI.ProcessHandle &&
"invalid process handle to wait on, process not started?");
DWORD milliSecondsToWait = 0;
if (WaitUntilChildTerminates)
milliSecondsToWait = INFINITE;
else if (SecondsToWait > 0)
milliSecondsToWait = SecondsToWait * 1000;
ProcessInfo WaitResult = PI;
DWORD WaitStatus = WaitForSingleObject(PI.ProcessHandle, milliSecondsToWait);
if (WaitStatus == WAIT_TIMEOUT) {
if (SecondsToWait) {
if (!TerminateProcess(PI.ProcessHandle, 1)) {
if (ErrMsg)
MakeErrMsg(ErrMsg, "Failed to terminate timed-out program.");
WaitResult.ReturnCode = -2;
CloseHandle(PI.ProcessHandle);
return WaitResult;
}
WaitForSingleObject(PI.ProcessHandle, INFINITE);
CloseHandle(PI.ProcessHandle);
} else {
return ProcessInfo();
}
}
DWORD status;
BOOL rc = GetExitCodeProcess(PI.ProcessHandle, &status);
DWORD err = GetLastError();
CloseHandle(PI.ProcessHandle);
if (!rc) {
SetLastError(err);
if (ErrMsg)
MakeErrMsg(ErrMsg, "Failed getting status for program.");
WaitResult.ReturnCode = -2;
return WaitResult;
}
if (!status)
return WaitResult;
if ((status & 0xBFFF0000U) == 0x80000000U)
WaitResult.ReturnCode = static_cast<int>(status);
else if (status & 0xFF)
WaitResult.ReturnCode = status & 0x7FFFFFFF;
else
WaitResult.ReturnCode = 1;
return WaitResult;
}
std::error_code sys::ChangeStdinToBinary() {
int result = _setmode(_fileno(stdin), _O_BINARY);
if (result == -1)
return std::error_code(errno, std::generic_category());
return std::error_code();
}
std::error_code sys::ChangeStdoutToBinary() {
int result = _setmode(_fileno(stdout), _O_BINARY);
if (result == -1)
return std::error_code(errno, std::generic_category());
return std::error_code();
}
std::error_code
llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
WindowsEncodingMethod Encoding) {
std::error_code EC;
llvm::raw_fd_ostream OS(FileName, EC, llvm::sys::fs::OpenFlags::F_Text);
if (EC)
return EC;
if (Encoding == WEM_UTF8) {
OS << Contents;
} else if (Encoding == WEM_CurrentCodePage) {
SmallVector<wchar_t, 1> ArgsUTF16;
SmallVector<char, 1> ArgsCurCP;
if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
return EC;
if ((EC = windows::UTF16ToCurCP(
ArgsUTF16.data(), ArgsUTF16.size(), ArgsCurCP)))
return EC;
OS.write(ArgsCurCP.data(), ArgsCurCP.size());
} else if (Encoding == WEM_UTF16) {
SmallVector<wchar_t, 1> ArgsUTF16;
if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
return EC;
char BOM[2];
uint16_t src = UNI_UTF16_BYTE_ORDER_MARK_NATIVE;
memcpy(BOM, &src, 2);
OS.write(BOM, 2);
OS.write((char *)ArgsUTF16.data(), ArgsUTF16.size() << 1);
} else {
llvm_unreachable("Unknown encoding");
}
if (OS.has_error())
return std::make_error_code(std::errc::io_error);
return EC;
}
bool llvm::sys::argumentsFitWithinSystemLimits(ArrayRef<const char*> Args) {
static const size_t MaxCommandStringLength = 32768;
size_t ArgLength = 0;
for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
I != E; ++I) {
ArgLength += ArgLenWithQuotes(*I) + 1;
if (ArgLength > MaxCommandStringLength) {
return false;
}
}
return true;
}
}