mirror of
https://github.com/AGWA/git-crypt.git
synced 2025-12-26 04:40:41 -08:00
Add Coprocess class
It provides a convenient way to spawn a process and read from/write to its stdin/stdout.
This commit is contained in:
Andrew Ayer
191
util-win32.cpp
191
util-win32.cpp
@@ -125,197 +125,6 @@ std::string our_exe_path ()
|
||||
return std::string(buffer.begin(), buffer.begin() + len);
|
||||
}
|
||||
|
||||
static void escape_cmdline_argument (std::string& cmdline, const std::string& arg)
|
||||
{
|
||||
// For an explanation of Win32's arcane argument quoting rules, see:
|
||||
// http://msdn.microsoft.com/en-us/library/17w5ykft%28v=vs.85%29.aspx
|
||||
// http://msdn.microsoft.com/en-us/library/bb776391%28v=vs.85%29.aspx
|
||||
// http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx
|
||||
// http://blogs.msdn.com/b/oldnewthing/archive/2010/09/17/10063629.aspx
|
||||
cmdline.push_back('"');
|
||||
|
||||
std::string::const_iterator p(arg.begin());
|
||||
while (p != arg.end()) {
|
||||
if (*p == '"') {
|
||||
cmdline.push_back('\\');
|
||||
cmdline.push_back('"');
|
||||
++p;
|
||||
} else if (*p == '\\') {
|
||||
unsigned int num_backslashes = 0;
|
||||
while (p != arg.end() && *p == '\\') {
|
||||
++num_backslashes;
|
||||
++p;
|
||||
}
|
||||
if (p == arg.end() || *p == '"') {
|
||||
// Backslashes need to be escaped
|
||||
num_backslashes *= 2;
|
||||
}
|
||||
while (num_backslashes--) {
|
||||
cmdline.push_back('\\');
|
||||
}
|
||||
} else {
|
||||
cmdline.push_back(*p++);
|
||||
}
|
||||
}
|
||||
|
||||
cmdline.push_back('"');
|
||||
}
|
||||
|
||||
static std::string format_cmdline (const std::vector<std::string>& command)
|
||||
{
|
||||
std::string cmdline;
|
||||
for (std::vector<std::string>::const_iterator arg(command.begin()); arg != command.end(); ++arg) {
|
||||
if (arg != command.begin()) {
|
||||
cmdline.push_back(' ');
|
||||
}
|
||||
escape_cmdline_argument(cmdline, *arg);
|
||||
}
|
||||
return cmdline;
|
||||
}
|
||||
|
||||
static int wait_for_child (HANDLE child_handle)
|
||||
{
|
||||
if (WaitForSingleObject(child_handle, INFINITE) == WAIT_FAILED) {
|
||||
throw System_error("WaitForSingleObject", "", GetLastError());
|
||||
}
|
||||
|
||||
DWORD exit_code;
|
||||
if (!GetExitCodeProcess(child_handle, &exit_code)) {
|
||||
throw System_error("GetExitCodeProcess", "", GetLastError());
|
||||
}
|
||||
|
||||
return exit_code;
|
||||
}
|
||||
|
||||
static HANDLE spawn_command (const std::vector<std::string>& command, HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle)
|
||||
{
|
||||
PROCESS_INFORMATION proc_info;
|
||||
ZeroMemory(&proc_info, sizeof(proc_info));
|
||||
|
||||
STARTUPINFO start_info;
|
||||
ZeroMemory(&start_info, sizeof(start_info));
|
||||
|
||||
start_info.cb = sizeof(STARTUPINFO);
|
||||
start_info.hStdInput = stdin_handle ? stdin_handle : GetStdHandle(STD_INPUT_HANDLE);
|
||||
start_info.hStdOutput = stdout_handle ? stdout_handle : GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
start_info.hStdError = stderr_handle ? stderr_handle : GetStdHandle(STD_ERROR_HANDLE);
|
||||
start_info.dwFlags |= STARTF_USESTDHANDLES;
|
||||
|
||||
std::string cmdline(format_cmdline(command));
|
||||
|
||||
if (!CreateProcessA(NULL, // application name (NULL to use command line)
|
||||
const_cast<char*>(cmdline.c_str()),
|
||||
NULL, // process security attributes
|
||||
NULL, // primary thread security attributes
|
||||
TRUE, // handles are inherited
|
||||
0, // creation flags
|
||||
NULL, // use parent's environment
|
||||
NULL, // use parent's current directory
|
||||
&start_info,
|
||||
&proc_info)) {
|
||||
throw System_error("CreateProcess", cmdline, GetLastError());
|
||||
}
|
||||
|
||||
CloseHandle(proc_info.hThread);
|
||||
|
||||
return proc_info.hProcess;
|
||||
}
|
||||
|
||||
int exec_command (const std::vector<std::string>& command)
|
||||
{
|
||||
HANDLE child_handle = spawn_command(command, NULL, NULL, NULL);
|
||||
int exit_code = wait_for_child(child_handle);
|
||||
CloseHandle(child_handle);
|
||||
return exit_code;
|
||||
}
|
||||
|
||||
int exec_command (const std::vector<std::string>& command, std::ostream& output)
|
||||
{
|
||||
HANDLE stdout_pipe_reader = NULL;
|
||||
HANDLE stdout_pipe_writer = NULL;
|
||||
SECURITY_ATTRIBUTES sec_attr;
|
||||
|
||||
// Set the bInheritHandle flag so pipe handles are inherited.
|
||||
sec_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
|
||||
sec_attr.bInheritHandle = TRUE;
|
||||
sec_attr.lpSecurityDescriptor = NULL;
|
||||
|
||||
// Create a pipe for the child process's STDOUT.
|
||||
if (!CreatePipe(&stdout_pipe_reader, &stdout_pipe_writer, &sec_attr, 0)) {
|
||||
throw System_error("CreatePipe", "", GetLastError());
|
||||
}
|
||||
|
||||
// Ensure the read handle to the pipe for STDOUT is not inherited.
|
||||
if (!SetHandleInformation(stdout_pipe_reader, HANDLE_FLAG_INHERIT, 0)) {
|
||||
throw System_error("SetHandleInformation", "", GetLastError());
|
||||
}
|
||||
|
||||
HANDLE child_handle = spawn_command(command, NULL, stdout_pipe_writer, NULL);
|
||||
CloseHandle(stdout_pipe_writer);
|
||||
|
||||
// Read from stdout_pipe_reader.
|
||||
// Note that ReadFile on a pipe may return with bytes_read==0 if the other
|
||||
// end of the pipe writes zero bytes, so don't break out of the read loop
|
||||
// when this happens. When the other end of the pipe closes, ReadFile
|
||||
// fails with ERROR_BROKEN_PIPE.
|
||||
char buffer[1024];
|
||||
DWORD bytes_read;
|
||||
while (ReadFile(stdout_pipe_reader, buffer, sizeof(buffer), &bytes_read, NULL)) {
|
||||
output.write(buffer, bytes_read);
|
||||
}
|
||||
const DWORD read_error = GetLastError();
|
||||
if (read_error != ERROR_BROKEN_PIPE) {
|
||||
throw System_error("ReadFile", "", read_error);
|
||||
}
|
||||
|
||||
CloseHandle(stdout_pipe_reader);
|
||||
|
||||
int exit_code = wait_for_child(child_handle);
|
||||
CloseHandle(child_handle);
|
||||
return exit_code;
|
||||
}
|
||||
|
||||
int exec_command_with_input (const std::vector<std::string>& command, const char* p, size_t len)
|
||||
{
|
||||
HANDLE stdin_pipe_reader = NULL;
|
||||
HANDLE stdin_pipe_writer = NULL;
|
||||
SECURITY_ATTRIBUTES sec_attr;
|
||||
|
||||
// Set the bInheritHandle flag so pipe handles are inherited.
|
||||
sec_attr.nLength = sizeof(SECURITY_ATTRIBUTES);
|
||||
sec_attr.bInheritHandle = TRUE;
|
||||
sec_attr.lpSecurityDescriptor = NULL;
|
||||
|
||||
// Create a pipe for the child process's STDIN.
|
||||
if (!CreatePipe(&stdin_pipe_reader, &stdin_pipe_writer, &sec_attr, 0)) {
|
||||
throw System_error("CreatePipe", "", GetLastError());
|
||||
}
|
||||
|
||||
// Ensure the write handle to the pipe for STDIN is not inherited.
|
||||
if (!SetHandleInformation(stdin_pipe_writer, HANDLE_FLAG_INHERIT, 0)) {
|
||||
throw System_error("SetHandleInformation", "", GetLastError());
|
||||
}
|
||||
|
||||
HANDLE child_handle = spawn_command(command, stdin_pipe_reader, NULL, NULL);
|
||||
CloseHandle(stdin_pipe_reader);
|
||||
|
||||
// Write to stdin_pipe_writer.
|
||||
while (len > 0) {
|
||||
DWORD bytes_written;
|
||||
if (!WriteFile(stdin_pipe_writer, p, len, &bytes_written, NULL)) {
|
||||
throw System_error("WriteFile", "", GetLastError());
|
||||
}
|
||||
p += bytes_written;
|
||||
len -= bytes_written;
|
||||
}
|
||||
|
||||
CloseHandle(stdin_pipe_writer);
|
||||
|
||||
int exit_code = wait_for_child(child_handle);
|
||||
CloseHandle(child_handle);
|
||||
return exit_code;
|
||||
}
|
||||
|
||||
int exit_status (int status)
|
||||
{
|
||||
return status;
|
||||
|
||||
Reference in New Issue
Block a user