Finish implementing Windows utility functions

This completes Windows support, except for the build system and
documentation.

util-win32.cpp

@@ -32,6 +32,7 @@
 #include <stdio.h>
 #include <fcntl.h>
 #include <windows.h>
+#include <vector>
 
 std::string System_error::message () const
 {
@@ -41,7 +42,17 @@ std::string System_error::message () const
 		mesg += target;
 	}
 	if (error) {
-		// TODO: use FormatMessage()
+		LPTSTR	error_message;
+		FormatMessageA(
+			FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+			NULL,
+			error,
+			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+			reinterpret_cast<LPTSTR>(&error_message),
+			0,
+			NULL);
+		mesg += error_message;
+		LocalFree(error_message);
 	}
 	return mesg;
 }
@@ -97,27 +108,214 @@ void	mkdir_parent (const std::string& path)
 	}
 }
 
-std::string our_exe_path () // TODO
+std::string our_exe_path ()
 {
-	return argv0;
+	std::vector<char>	buffer(128);
+	size_t			len;
+
+	while ((len = GetModuleFileNameA(NULL, &buffer[0], buffer.size())) == buffer.size()) {
+		// buffer may have been truncated - grow and try again
+		buffer.resize(buffer.size() * 2);
+	}
+	if (len == 0) {
+		throw System_error("GetModuleFileNameA", "", GetLastError());
+	}
+
+	return std::string(buffer.begin(), buffer.begin() + len);
 }
 
-int exec_command (const std::vector<std::string>& command) // TODO
+static void escape_cmdline_argument (std::string& cmdline, const std::string& arg)
 {
-	return -1;
+	// 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('"');
 }
 
-int exec_command (const std::vector<std::string>& command, std::ostream& output) // TODO
+static std::string format_cmdline (const std::vector<std::string>& command)
 {
-	return -1;
+	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;
 }
 
-int exec_command_with_input (const std::vector<std::string>& command, const char* p, size_t len) // TODO
+static int wait_for_child (HANDLE child_handle)
 {
-	return -1;
+	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;
 }
 
-bool successful_exit (int status) // TODO
+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;
+}
+
+bool successful_exit (int status)
 {
 	return status == 0;
 }