src/google/protobuf/compiler/subprocess.cc - platform/external/protobuf-javalite - Gitiles

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 // Author: kenton@google.com (Kenton Varda)

 #include <google/protobuf/compiler/subprocess.h>

 #include <algorithm>
 #include <iostream>

 #ifndef _WIN32
 #include <errno.h>
 #include <sys/select.h>
 #include <sys/wait.h>
 #include <signal.h>
 #endif

 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/message.h>
 #include <google/protobuf/stubs/substitute.h>


 namespace google {
 namespace protobuf {
 namespace compiler {

 #ifdef _WIN32

 static void CloseHandleOrDie(HANDLE handle) {
   if (!CloseHandle(handle)) {
     GOOGLE_LOG(FATAL) << "CloseHandle: "
                       << Subprocess::Win32ErrorMessage(GetLastError());
   }
 }

 Subprocess::Subprocess()
     : process_start_error_(ERROR_SUCCESS),
       child_handle_(NULL), child_stdin_(NULL), child_stdout_(NULL) {}

 Subprocess::~Subprocess() {
   if (child_stdin_ != NULL) {
     CloseHandleOrDie(child_stdin_);
   }
   if (child_stdout_ != NULL) {
     CloseHandleOrDie(child_stdout_);
   }
 }

 void Subprocess::Start(const string& program, SearchMode search_mode) {
   // Create the pipes.
   HANDLE stdin_pipe_read;
   HANDLE stdin_pipe_write;
   HANDLE stdout_pipe_read;
   HANDLE stdout_pipe_write;

   if (!CreatePipe(&stdin_pipe_read, &stdin_pipe_write, NULL, 0)) {
     GOOGLE_LOG(FATAL) << "CreatePipe: " << Win32ErrorMessage(GetLastError());
   }
   if (!CreatePipe(&stdout_pipe_read, &stdout_pipe_write, NULL, 0)) {
     GOOGLE_LOG(FATAL) << "CreatePipe: " << Win32ErrorMessage(GetLastError());
   }

   // Make child side of the pipes inheritable.
   if (!SetHandleInformation(stdin_pipe_read,
                             HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
     GOOGLE_LOG(FATAL) << "SetHandleInformation: "
                       << Win32ErrorMessage(GetLastError());
   }
   if (!SetHandleInformation(stdout_pipe_write,
                             HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
     GOOGLE_LOG(FATAL) << "SetHandleInformation: "
                       << Win32ErrorMessage(GetLastError());
   }

   // Setup STARTUPINFO to redirect handles.
   STARTUPINFOA startup_info;
   ZeroMemory(&startup_info, sizeof(startup_info));
   startup_info.cb = sizeof(startup_info);
   startup_info.dwFlags = STARTF_USESTDHANDLES;
   startup_info.hStdInput = stdin_pipe_read;
   startup_info.hStdOutput = stdout_pipe_write;
   startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);

   if (startup_info.hStdError == INVALID_HANDLE_VALUE) {
     GOOGLE_LOG(FATAL) << "GetStdHandle: "
                       << Win32ErrorMessage(GetLastError());
   }

   // CreateProcess() mutates its second parameter.  WTF?
   char* name_copy = strdup(program.c_str());

   // Create the process.
   PROCESS_INFORMATION process_info;

   if (CreateProcessA((search_mode == SEARCH_PATH) ? NULL : program.c_str(),
                      (search_mode == SEARCH_PATH) ? name_copy : NULL,
                      NULL,  // process security attributes
                      NULL,  // thread security attributes
                      TRUE,  // inherit handles?
                      0,     // obscure creation flags
                      NULL,  // environment (inherit from parent)
                      NULL,  // current directory (inherit from parent)
                      &startup_info,
                      &process_info)) {
     child_handle_ = process_info.hProcess;
     CloseHandleOrDie(process_info.hThread);
     child_stdin_ = stdin_pipe_write;
     child_stdout_ = stdout_pipe_read;
   } else {
     process_start_error_ = GetLastError();
     CloseHandleOrDie(stdin_pipe_write);
     CloseHandleOrDie(stdout_pipe_read);
   }

   CloseHandleOrDie(stdin_pipe_read);
   CloseHandleOrDie(stdout_pipe_write);
   free(name_copy);
 }

 bool Subprocess::Communicate(const Message& input, Message* output,
                              string* error) {
   if (process_start_error_ != ERROR_SUCCESS) {
     *error = Win32ErrorMessage(process_start_error_);
     return false;
   }

   GOOGLE_CHECK(child_handle_ != NULL) << "Must call Start() first.";

   string input_data = input.SerializeAsString();
   string output_data;

   int input_pos = 0;

   while (child_stdout_ != NULL) {
     HANDLE handles[2];
     int handle_count = 0;

     if (child_stdin_ != NULL) {
       handles[handle_count++] = child_stdin_;
     }
     if (child_stdout_ != NULL) {
       handles[handle_count++] = child_stdout_;
     }

     DWORD wait_result =
         WaitForMultipleObjects(handle_count, handles, FALSE, INFINITE);

     HANDLE signaled_handle = NULL;
     if (wait_result >= WAIT_OBJECT_0 &&
         wait_result < WAIT_OBJECT_0 + handle_count) {
       signaled_handle = handles[wait_result - WAIT_OBJECT_0];
     } else if (wait_result == WAIT_FAILED) {
       GOOGLE_LOG(FATAL) << "WaitForMultipleObjects: "
                         << Win32ErrorMessage(GetLastError());
     } else {
       GOOGLE_LOG(FATAL) << "WaitForMultipleObjects: Unexpected return code: "
                         << wait_result;
     }

     if (signaled_handle == child_stdin_) {
       DWORD n;
       if (!WriteFile(child_stdin_,
                      input_data.data() + input_pos,
                      input_data.size() - input_pos,
                      &n, NULL)) {
         // Child closed pipe.  Presumably it will report an error later.
         // Pretend we're done for now.
         input_pos = input_data.size();
       } else {
         input_pos += n;
       }

       if (input_pos == input_data.size()) {
         // We're done writing.  Close.
         CloseHandleOrDie(child_stdin_);
         child_stdin_ = NULL;
       }
     } else if (signaled_handle == child_stdout_) {
       char buffer[4096];
       DWORD n;

       if (!ReadFile(child_stdout_, buffer, sizeof(buffer), &n, NULL)) {
         // We're done reading.  Close.
         CloseHandleOrDie(child_stdout_);
         child_stdout_ = NULL;
       } else {
         output_data.append(buffer, n);
       }
     }
   }

   if (child_stdin_ != NULL) {
     // Child did not finish reading input before it closed the output.
     // Presumably it exited with an error.
     CloseHandleOrDie(child_stdin_);
     child_stdin_ = NULL;
   }

   DWORD wait_result = WaitForSingleObject(child_handle_, INFINITE);

   if (wait_result == WAIT_FAILED) {
     GOOGLE_LOG(FATAL) << "WaitForSingleObject: "
                       << Win32ErrorMessage(GetLastError());
   } else if (wait_result != WAIT_OBJECT_0) {
     GOOGLE_LOG(FATAL) << "WaitForSingleObject: Unexpected return code: "
                       << wait_result;
   }

   DWORD exit_code;
   if (!GetExitCodeProcess(child_handle_, &exit_code)) {
     GOOGLE_LOG(FATAL) << "GetExitCodeProcess: "
                       << Win32ErrorMessage(GetLastError());
   }

   CloseHandleOrDie(child_handle_);
   child_handle_ = NULL;

   if (exit_code != 0) {
     *error = strings::Substitute(
         "Plugin failed with status code $0.", exit_code);
     return false;
   }

   if (!output->ParseFromString(output_data)) {
     *error = "Plugin output is unparseable: " + CEscape(output_data);
     return false;
   }

   return true;
 }

 string Subprocess::Win32ErrorMessage(DWORD error_code) {
   char* message;

   // WTF?
   FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                 FORMAT_MESSAGE_FROM_SYSTEM |
                 FORMAT_MESSAGE_IGNORE_INSERTS,
                 NULL, error_code, 0,
                 (LPTSTR)&message,  // NOT A BUG!
                 0, NULL);

   string result = message;
   LocalFree(message);
   return result;
 }

 // ===================================================================

 #else  // _WIN32

 Subprocess::Subprocess()
     : child_pid_(-1), child_stdin_(-1), child_stdout_(-1) {}

 Subprocess::~Subprocess() {
   if (child_stdin_ != -1) {
     close(child_stdin_);
   }
   if (child_stdout_ != -1) {
     close(child_stdout_);
   }
 }

 void Subprocess::Start(const string& program, SearchMode search_mode) {
   // Note that we assume that there are no other threads, thus we don't have to
   // do crazy stuff like using socket pairs or avoiding libc locks.

   // [0] is read end, [1] is write end.
   int stdin_pipe[2];
   int stdout_pipe[2];

   GOOGLE_CHECK(pipe(stdin_pipe) != -1);
   GOOGLE_CHECK(pipe(stdout_pipe) != -1);

   char* argv[2] = { strdup(program.c_str()), NULL };

   child_pid_ = fork();
   if (child_pid_ == -1) {
     GOOGLE_LOG(FATAL) << "fork: " << strerror(errno);
   } else if (child_pid_ == 0) {
     // We are the child.
     dup2(stdin_pipe[0], STDIN_FILENO);
     dup2(stdout_pipe[1], STDOUT_FILENO);

     close(stdin_pipe[0]);
     close(stdin_pipe[1]);
     close(stdout_pipe[0]);
     close(stdout_pipe[1]);

     switch (search_mode) {
       case SEARCH_PATH:
         execvp(argv[0], argv);
         break;
       case EXACT_NAME:
         execv(argv[0], argv);
         break;
     }

     // Write directly to STDERR_FILENO to avoid stdio code paths that may do
     // stuff that is unsafe here.
     int ignored;
     ignored = write(STDERR_FILENO, argv[0], strlen(argv[0]));
     const char* message = ": program not found or is not executable\n";
     ignored = write(STDERR_FILENO, message, strlen(message));
     (void) ignored;

     // Must use _exit() rather than exit() to avoid flushing output buffers
     // that will also be flushed by the parent.
     _exit(1);
   } else {
     free(argv[0]);

     close(stdin_pipe[0]);
     close(stdout_pipe[1]);

     child_stdin_ = stdin_pipe[1];
     child_stdout_ = stdout_pipe[0];
   }
 }

 bool Subprocess::Communicate(const Message& input, Message* output,
                              string* error) {

   GOOGLE_CHECK_NE(child_stdin_, -1) << "Must call Start() first.";

   // The "sighandler_t" typedef is GNU-specific, so define our own.
   typedef void SignalHandler(int);

   // Make sure SIGPIPE is disabled so that if the child dies it doesn't kill us.
   SignalHandler* old_pipe_handler = signal(SIGPIPE, SIG_IGN);

   string input_data = input.SerializeAsString();
   string output_data;

   int input_pos = 0;
   int max_fd = max(child_stdin_, child_stdout_);

   while (child_stdout_ != -1) {
     fd_set read_fds;
     fd_set write_fds;
     FD_ZERO(&read_fds);
     FD_ZERO(&write_fds);
     if (child_stdout_ != -1) {
       FD_SET(child_stdout_, &read_fds);
     }
     if (child_stdin_ != -1) {
       FD_SET(child_stdin_, &write_fds);
     }

     if (select(max_fd + 1, &read_fds, &write_fds, NULL, NULL) < 0) {
       if (errno == EINTR) {
         // Interrupted by signal.  Try again.
         continue;
       } else {
         GOOGLE_LOG(FATAL) << "select: " << strerror(errno);
       }
     }

     if (child_stdin_ != -1 && FD_ISSET(child_stdin_, &write_fds)) {
       int n = write(child_stdin_, input_data.data() + input_pos,
                                   input_data.size() - input_pos);
       if (n < 0) {
         // Child closed pipe.  Presumably it will report an error later.
         // Pretend we're done for now.
         input_pos = input_data.size();
       } else {
         input_pos += n;
       }

       if (input_pos == input_data.size()) {
         // We're done writing.  Close.
         close(child_stdin_);
         child_stdin_ = -1;
       }
     }

     if (child_stdout_ != -1 && FD_ISSET(child_stdout_, &read_fds)) {
       char buffer[4096];
       int n = read(child_stdout_, buffer, sizeof(buffer));

       if (n > 0) {
         output_data.append(buffer, n);
       } else {
         // We're done reading.  Close.
         close(child_stdout_);
         child_stdout_ = -1;
       }
     }
   }

   if (child_stdin_ != -1) {
     // Child did not finish reading input before it closed the output.
     // Presumably it exited with an error.
     close(child_stdin_);
     child_stdin_ = -1;
   }

   int status;
   while (waitpid(child_pid_, &status, 0) == -1) {
     if (errno != EINTR) {
       GOOGLE_LOG(FATAL) << "waitpid: " << strerror(errno);
     }
   }

   // Restore SIGPIPE handling.
   signal(SIGPIPE, old_pipe_handler);

   if (WIFEXITED(status)) {
     if (WEXITSTATUS(status) != 0) {
       int error_code = WEXITSTATUS(status);
       *error = strings::Substitute(
           "Plugin failed with status code $0.", error_code);
       return false;
     }
   } else if (WIFSIGNALED(status)) {
     int signal = WTERMSIG(status);
     *error = strings::Substitute(
         "Plugin killed by signal $0.", signal);
     return false;
   } else {
     *error = "Neither WEXITSTATUS nor WTERMSIG is true?";
     return false;
   }

   if (!output->ParseFromString(output_data)) {
     *error = "Plugin output is unparseable: " + CEscape(output_data);
     return false;
   }

   return true;
 }

 #endif  // !_WIN32

 }  // namespace compiler
 }  // namespace protobuf
 }  // namespace google
	// Protocol Buffers - Google's data interchange format
	// Copyright 2008 Google Inc. All rights reserved.
	// https://developers.google.com/protocol-buffers/
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	// Author: kenton@google.com (Kenton Varda)

	#include <google/protobuf/compiler/subprocess.h>

	#include <algorithm>
	#include <iostream>

	#ifndef _WIN32
	#include <errno.h>
	#include <sys/select.h>
	#include <sys/wait.h>
	#include <signal.h>
	#endif

	#include <google/protobuf/stubs/logging.h>
	#include <google/protobuf/stubs/common.h>
	#include <google/protobuf/message.h>
	#include <google/protobuf/stubs/substitute.h>


	namespace google {
	namespace protobuf {
	namespace compiler {

	#ifdef _WIN32

	static void CloseHandleOrDie(HANDLE handle) {
	if (!CloseHandle(handle)) {
	GOOGLE_LOG(FATAL) << "CloseHandle: "
	<< Subprocess::Win32ErrorMessage(GetLastError());
	}
	}

	Subprocess::Subprocess()
	: process_start_error_(ERROR_SUCCESS),
	child_handle_(NULL), child_stdin_(NULL), child_stdout_(NULL) {}

	Subprocess::~Subprocess() {
	if (child_stdin_ != NULL) {
	CloseHandleOrDie(child_stdin_);
	}
	if (child_stdout_ != NULL) {
	CloseHandleOrDie(child_stdout_);
	}
	}

	void Subprocess::Start(const string& program, SearchMode search_mode) {
	// Create the pipes.
	HANDLE stdin_pipe_read;
	HANDLE stdin_pipe_write;
	HANDLE stdout_pipe_read;
	HANDLE stdout_pipe_write;

	if (!CreatePipe(&stdin_pipe_read, &stdin_pipe_write, NULL, 0)) {
	GOOGLE_LOG(FATAL) << "CreatePipe: " << Win32ErrorMessage(GetLastError());
	}
	if (!CreatePipe(&stdout_pipe_read, &stdout_pipe_write, NULL, 0)) {
	GOOGLE_LOG(FATAL) << "CreatePipe: " << Win32ErrorMessage(GetLastError());
	}

	// Make child side of the pipes inheritable.
	if (!SetHandleInformation(stdin_pipe_read,
	HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
	GOOGLE_LOG(FATAL) << "SetHandleInformation: "
	<< Win32ErrorMessage(GetLastError());
	}
	if (!SetHandleInformation(stdout_pipe_write,
	HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
	GOOGLE_LOG(FATAL) << "SetHandleInformation: "
	<< Win32ErrorMessage(GetLastError());
	}

	// Setup STARTUPINFO to redirect handles.
	STARTUPINFOA startup_info;
	ZeroMemory(&startup_info, sizeof(startup_info));
	startup_info.cb = sizeof(startup_info);
	startup_info.dwFlags = STARTF_USESTDHANDLES;
	startup_info.hStdInput = stdin_pipe_read;
	startup_info.hStdOutput = stdout_pipe_write;
	startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);

	if (startup_info.hStdError == INVALID_HANDLE_VALUE) {
	GOOGLE_LOG(FATAL) << "GetStdHandle: "
	<< Win32ErrorMessage(GetLastError());
	}

	// CreateProcess() mutates its second parameter. WTF?
	char* name_copy = strdup(program.c_str());

	// Create the process.
	PROCESS_INFORMATION process_info;

	if (CreateProcessA((search_mode == SEARCH_PATH) ? NULL : program.c_str(),
	(search_mode == SEARCH_PATH) ? name_copy : NULL,
	NULL, // process security attributes
	NULL, // thread security attributes
	TRUE, // inherit handles?
	0, // obscure creation flags
	NULL, // environment (inherit from parent)
	NULL, // current directory (inherit from parent)
	&startup_info,
	&process_info)) {
	child_handle_ = process_info.hProcess;
	CloseHandleOrDie(process_info.hThread);
	child_stdin_ = stdin_pipe_write;
	child_stdout_ = stdout_pipe_read;
	} else {
	process_start_error_ = GetLastError();
	CloseHandleOrDie(stdin_pipe_write);
	CloseHandleOrDie(stdout_pipe_read);
	}

	CloseHandleOrDie(stdin_pipe_read);
	CloseHandleOrDie(stdout_pipe_write);
	free(name_copy);
	}

	bool Subprocess::Communicate(const Message& input, Message* output,
	string* error) {
	if (process_start_error_ != ERROR_SUCCESS) {
	*error = Win32ErrorMessage(process_start_error_);
	return false;
	}

	GOOGLE_CHECK(child_handle_ != NULL) << "Must call Start() first.";

	string input_data = input.SerializeAsString();
	string output_data;

	int input_pos = 0;

	while (child_stdout_ != NULL) {
	HANDLE handles[2];
	int handle_count = 0;

	if (child_stdin_ != NULL) {
	handles[handle_count++] = child_stdin_;
	}
	if (child_stdout_ != NULL) {
	handles[handle_count++] = child_stdout_;
	}

	DWORD wait_result =
	WaitForMultipleObjects(handle_count, handles, FALSE, INFINITE);

	HANDLE signaled_handle = NULL;
	if (wait_result >= WAIT_OBJECT_0 &&
	wait_result < WAIT_OBJECT_0 + handle_count) {
	signaled_handle = handles[wait_result - WAIT_OBJECT_0];
	} else if (wait_result == WAIT_FAILED) {
	GOOGLE_LOG(FATAL) << "WaitForMultipleObjects: "
	<< Win32ErrorMessage(GetLastError());
	} else {
	GOOGLE_LOG(FATAL) << "WaitForMultipleObjects: Unexpected return code: "
	<< wait_result;
	}

	if (signaled_handle == child_stdin_) {
	DWORD n;
	if (!WriteFile(child_stdin_,
	input_data.data() + input_pos,
	input_data.size() - input_pos,
	&n, NULL)) {
	// Child closed pipe. Presumably it will report an error later.
	// Pretend we're done for now.
	input_pos = input_data.size();
	} else {
	input_pos += n;
	}

	if (input_pos == input_data.size()) {
	// We're done writing. Close.
	CloseHandleOrDie(child_stdin_);
	child_stdin_ = NULL;
	}
	} else if (signaled_handle == child_stdout_) {
	char buffer[4096];
	DWORD n;

	if (!ReadFile(child_stdout_, buffer, sizeof(buffer), &n, NULL)) {
	// We're done reading. Close.
	CloseHandleOrDie(child_stdout_);
	child_stdout_ = NULL;
	} else {
	output_data.append(buffer, n);
	}
	}
	}

	if (child_stdin_ != NULL) {
	// Child did not finish reading input before it closed the output.
	// Presumably it exited with an error.
	CloseHandleOrDie(child_stdin_);
	child_stdin_ = NULL;
	}

	DWORD wait_result = WaitForSingleObject(child_handle_, INFINITE);

	if (wait_result == WAIT_FAILED) {
	GOOGLE_LOG(FATAL) << "WaitForSingleObject: "
	<< Win32ErrorMessage(GetLastError());
	} else if (wait_result != WAIT_OBJECT_0) {
	GOOGLE_LOG(FATAL) << "WaitForSingleObject: Unexpected return code: "
	<< wait_result;
	}

	DWORD exit_code;
	if (!GetExitCodeProcess(child_handle_, &exit_code)) {
	GOOGLE_LOG(FATAL) << "GetExitCodeProcess: "
	<< Win32ErrorMessage(GetLastError());
	}

	CloseHandleOrDie(child_handle_);
	child_handle_ = NULL;

	if (exit_code != 0) {
	*error = strings::Substitute(
	"Plugin failed with status code $0.", exit_code);
	return false;
	}

	if (!output->ParseFromString(output_data)) {
	*error = "Plugin output is unparseable: " + CEscape(output_data);
	return false;
	}

	return true;
	}

	string Subprocess::Win32ErrorMessage(DWORD error_code) {
	char* message;

	// WTF?
	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER \|
	FORMAT_MESSAGE_FROM_SYSTEM \|
	FORMAT_MESSAGE_IGNORE_INSERTS,
	NULL, error_code, 0,
	(LPTSTR)&message, // NOT A BUG!
	0, NULL);

	string result = message;
	LocalFree(message);
	return result;
	}

	// ===================================================================

	#else // _WIN32

	Subprocess::Subprocess()
	: child_pid_(-1), child_stdin_(-1), child_stdout_(-1) {}

	Subprocess::~Subprocess() {
	if (child_stdin_ != -1) {
	close(child_stdin_);
	}
	if (child_stdout_ != -1) {
	close(child_stdout_);
	}
	}

	void Subprocess::Start(const string& program, SearchMode search_mode) {
	// Note that we assume that there are no other threads, thus we don't have to
	// do crazy stuff like using socket pairs or avoiding libc locks.

	// [0] is read end, [1] is write end.
	int stdin_pipe[2];
	int stdout_pipe[2];

	GOOGLE_CHECK(pipe(stdin_pipe) != -1);
	GOOGLE_CHECK(pipe(stdout_pipe) != -1);

	char* argv[2] = { strdup(program.c_str()), NULL };

	child_pid_ = fork();
	if (child_pid_ == -1) {
	GOOGLE_LOG(FATAL) << "fork: " << strerror(errno);
	} else if (child_pid_ == 0) {
	// We are the child.
	dup2(stdin_pipe[0], STDIN_FILENO);
	dup2(stdout_pipe[1], STDOUT_FILENO);

	close(stdin_pipe[0]);
	close(stdin_pipe[1]);
	close(stdout_pipe[0]);
	close(stdout_pipe[1]);

	switch (search_mode) {
	case SEARCH_PATH:
	execvp(argv[0], argv);
	break;
	case EXACT_NAME:
	execv(argv[0], argv);
	break;
	}

	// Write directly to STDERR_FILENO to avoid stdio code paths that may do
	// stuff that is unsafe here.
	int ignored;
	ignored = write(STDERR_FILENO, argv[0], strlen(argv[0]));
	const char* message = ": program not found or is not executable\n";
	ignored = write(STDERR_FILENO, message, strlen(message));
	(void) ignored;

	// Must use _exit() rather than exit() to avoid flushing output buffers
	// that will also be flushed by the parent.
	_exit(1);
	} else {
	free(argv[0]);

	close(stdin_pipe[0]);
	close(stdout_pipe[1]);

	child_stdin_ = stdin_pipe[1];
	child_stdout_ = stdout_pipe[0];
	}
	}

	bool Subprocess::Communicate(const Message& input, Message* output,
	string* error) {

	GOOGLE_CHECK_NE(child_stdin_, -1) << "Must call Start() first.";

	// The "sighandler_t" typedef is GNU-specific, so define our own.
	typedef void SignalHandler(int);

	// Make sure SIGPIPE is disabled so that if the child dies it doesn't kill us.
	SignalHandler* old_pipe_handler = signal(SIGPIPE, SIG_IGN);

	string input_data = input.SerializeAsString();
	string output_data;

	int input_pos = 0;
	int max_fd = max(child_stdin_, child_stdout_);

	while (child_stdout_ != -1) {
	fd_set read_fds;
	fd_set write_fds;
	FD_ZERO(&read_fds);
	FD_ZERO(&write_fds);
	if (child_stdout_ != -1) {
	FD_SET(child_stdout_, &read_fds);
	}
	if (child_stdin_ != -1) {
	FD_SET(child_stdin_, &write_fds);
	}

	if (select(max_fd + 1, &read_fds, &write_fds, NULL, NULL) < 0) {
	if (errno == EINTR) {
	// Interrupted by signal. Try again.
	continue;
	} else {
	GOOGLE_LOG(FATAL) << "select: " << strerror(errno);
	}
	}

	if (child_stdin_ != -1 && FD_ISSET(child_stdin_, &write_fds)) {
	int n = write(child_stdin_, input_data.data() + input_pos,
	input_data.size() - input_pos);
	if (n < 0) {
	// Child closed pipe. Presumably it will report an error later.
	// Pretend we're done for now.
	input_pos = input_data.size();
	} else {
	input_pos += n;
	}

	if (input_pos == input_data.size()) {
	// We're done writing. Close.
	close(child_stdin_);
	child_stdin_ = -1;
	}
	}

	if (child_stdout_ != -1 && FD_ISSET(child_stdout_, &read_fds)) {
	char buffer[4096];
	int n = read(child_stdout_, buffer, sizeof(buffer));

	if (n > 0) {
	output_data.append(buffer, n);
	} else {
	// We're done reading. Close.
	close(child_stdout_);
	child_stdout_ = -1;
	}
	}
	}

	if (child_stdin_ != -1) {
	// Child did not finish reading input before it closed the output.
	// Presumably it exited with an error.
	close(child_stdin_);
	child_stdin_ = -1;
	}

	int status;
	while (waitpid(child_pid_, &status, 0) == -1) {
	if (errno != EINTR) {
	GOOGLE_LOG(FATAL) << "waitpid: " << strerror(errno);
	}
	}

	// Restore SIGPIPE handling.
	signal(SIGPIPE, old_pipe_handler);

	if (WIFEXITED(status)) {
	if (WEXITSTATUS(status) != 0) {
	int error_code = WEXITSTATUS(status);
	*error = strings::Substitute(
	"Plugin failed with status code $0.", error_code);
	return false;
	}
	} else if (WIFSIGNALED(status)) {
	int signal = WTERMSIG(status);
	*error = strings::Substitute(
	"Plugin killed by signal $0.", signal);
	return false;
	} else {
	*error = "Neither WEXITSTATUS nor WTERMSIG is true?";
	return false;
	}

	if (!output->ParseFromString(output_data)) {
	*error = "Plugin output is unparseable: " + CEscape(output_data);
	return false;
	}

	return true;
	}

	#endif // !_WIN32

	} // namespace compiler
	} // namespace protobuf
	} // namespace google