 @@ -1,847 +1,847 @@
 //
 // Automated Testing Framework (atf)
 //
 // Copyright (c) 2008 The NetBSD Foundation, Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 // 1. Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
 // 2. 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.
 //
 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 //
 extern "C" {
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <limits.h>
 #include <signal.h>
 #include <unistd.h>
+}
 #include <cerrno>
 #include <cstdlib>
 #include <cstring>
 #include <fstream>
 #include <ios>
 #include <iostream>
 #include <iterator>
 #include <list>
 #include <memory>
 #include <utility>
 #include "atf-c++/check.hpp"
 #include "atf-c++/config.hpp"
 #include "atf-c++/detail/application.hpp"
 #include "atf-c++/detail/auto_array.hpp"
 #include "atf-c++/detail/exceptions.hpp"
 #include "atf-c++/detail/fs.hpp"
 #include "atf-c++/detail/process.hpp"
 #include "atf-c++/detail/sanity.hpp"
 #include "atf-c++/detail/text.hpp"
 // ------------------------------------------------------------------------
 // Auxiliary functions.
 // ------------------------------------------------------------------------
 namespace {
 enum status_check_t {
     sc_exit,
     sc_ignore,
     sc_signal,
 };
 struct status_check {
     status_check_t type;
     bool negated;
     int value;
     status_check(const status_check_t& p_type, const bool p_negated,
                  const int p_value) :
         type(p_type),
         negated(p_negated),
         value(p_value)
+    {
+    }
 };
 enum output_check_t {
     oc_ignore,
     oc_inline,
     oc_file,
     oc_empty,
     oc_match,
     oc_save
 };
 struct output_check {
     output_check_t type;
     bool negated;
     std::string value;
     output_check(const output_check_t& p_type, const bool p_negated,
                  const std::string& p_value) :
         type(p_type),
         negated(p_negated),
         value(p_value)
+    {
+    }
 };
 class temp_file : public std::ostream {
     std::auto_ptr< atf::fs::path > m_path;
     int m_fd;
 public:
     temp_file(const atf::fs::path& p) :
         std::ostream(NULL),
         m_fd(-1)
+    {
         atf::auto_array< char > buf(new char[p.str().length() + 1]);
         std::strcpy(buf.get(), p.c_str());
         m_fd = ::mkstemp(buf.get());
         if (m_fd == -1)
             throw atf::system_error("atf_check::temp_file::temp_file(" +
                                     p.str() + ")", "mkstemp(3) failed",
                                     errno);
         m_path.reset(new atf::fs::path(buf.get()));
+    }
     ~temp_file(void)
+    {
         close();
         try {
             remove(*m_path);
         } catch (const atf::system_error&) {
             // Ignore deletion errors.
+        }
+    }
     const atf::fs::path&
     get_path(void) const
+    {
         return *m_path;
+    }
     void
     write(const std::string& text)
+    {
         if (::write(m_fd, text.c_str(), text.size()) == -1)
             throw atf::system_error("atf_check", "write(2) failed", errno);
+    }
     void
     close(void)
+    {
         if (m_fd != -1) {
             flush();
             ::close(m_fd);
             m_fd = -1;
+        }
+    }
 };
 } // anonymous namespace
 static int
 parse_exit_code(const std::string& str)
+{
     try {
         const int value = atf::text::to_type< int >(str);
         if (value < 0 || value > 255)
             throw std::runtime_error("Unused reason");
         return value;
     } catch (const std::runtime_error&) {
         throw atf::application::usage_error("Invalid exit code for -s option; "
             "must be an integer in range 0-255");
+    }
+}
 static struct name_number {
     const char *name;
     int signo;
 } signal_names_to_numbers[] = {
     { "hup", SIGHUP },
     { "int", SIGINT },
     { "quit", SIGQUIT },
     { "trap", SIGTRAP },
     { "abrt", SIGABRT },
     { "kill", SIGKILL },
     { "segv", SIGSEGV },
     { "pipe", SIGPIPE },
     { "alrm", SIGALRM },
     { "term", SIGTERM },
     { "usr1", SIGUSR1 },
     { "usr2", SIGUSR2 },
     { NULL, INT_MIN },
 };
 static int
 signal_name_to_number(const std::string& str)
+{
     struct name_number* iter = signal_names_to_numbers;
     int signo = INT_MIN;
     while (signo == INT_MIN && iter->name != NULL) {
         if (str == iter->name || str == std::string("sig") + iter->name)
             signo = iter->signo;
         else
             iter++;
+    }
     return signo;
+}
 static int
 parse_signal(const std::string& str)
+{
     const int signo = signal_name_to_number(str);
     if (signo == INT_MIN) {
         try {
             return atf::text::to_type< int >(str);
         } catch (std::runtime_error &e) {
             throw atf::application::usage_error("Invalid signal name or number "
                 "in -s option");
+        }
+    }
     INV(signo != INT_MIN);
     return signo;
+}
 static status_check
 parse_status_check_arg(const std::string& arg)
+{
     const std::string::size_type delimiter = arg.find(':');
     bool negated = (arg.compare(0, 4, "not-") == 0);
     const std::string action_str = arg.substr(0, delimiter);
     const std::string action = negated ? action_str.substr(4) : action_str;
     const std::string value_str = (
         delimiter == std::string::npos ? "" : arg.substr(delimiter + 1));
     int value;
     status_check_t type;
     if (action == "eq") {
         // Deprecated; use exit instead.  TODO: Remove after 0.10.
         type = sc_exit;
         if (negated)
             throw atf::application::usage_error("Cannot negate eq checker");
         negated = false;
         value = parse_exit_code(value_str);
     } else if (action == "exit") {
         type = sc_exit;
         if (value_str.empty())
             value = INT_MIN;
         else
             value = parse_exit_code(value_str);
     } else if (action == "ignore") {
         if (negated)
             throw atf::application::usage_error("Cannot negate ignore checker");
         type = sc_ignore;
         value = INT_MIN;
     } else if (action == "ne") {
         // Deprecated; use not-exit instead.  TODO: Remove after 0.10.
         type = sc_exit;
         if (negated)
             throw atf::application::usage_error("Cannot negate ne checker");
         negated = true;
         value = parse_exit_code(value_str);
     } else if (action == "signal") {
         type = sc_signal;
         if (value_str.empty())
             value = INT_MIN;
         else
             value = parse_signal(value_str);
     } else
         throw atf::application::usage_error("Invalid status checker");
     return status_check(type, negated, value);
+}
 static
 output_check
 parse_output_check_arg(const std::string& arg)
+{
     const std::string::size_type delimiter = arg.find(':');
     const bool negated = (arg.compare(0, 4, "not-") == 0);
     const std::string action_str = arg.substr(0, delimiter);
     const std::string action = negated ? action_str.substr(4) : action_str;
     output_check_t type;
     if (action == "empty")
         type = oc_empty;
     else if (action == "file")
         type = oc_file;
     else if (action == "ignore") {
         if (negated)
             throw atf::application::usage_error("Cannot negate ignore checker");
         type = oc_ignore;
     } else if (action == "inline")
         type = oc_inline;
     else if (action == "match")
         type = oc_match;
     else if (action == "save") {
         if (negated)
             throw atf::application::usage_error("Cannot negate save checker");
         type = oc_save;
     } else
         throw atf::application::usage_error("Invalid output checker");
     return output_check(type, negated, arg.substr(delimiter + 1));
+}
 static
 std::string
 flatten_argv(char* const* argv)
+{
     std::string cmdline;
     char* const* arg = &argv[0];
     while (*arg != NULL) {
         if (arg != &argv[0])
             cmdline += ' ';
         cmdline += *arg;
         arg++;
+    }
     return cmdline;
+}
 static
 std::auto_ptr< atf::check::check_result >
 execute(const char* const* argv)
+{
     // TODO: This should go to stderr... but fixing it now may be hard as test
     // cases out there might be relying on stderr being silent.
     std::cout << "Executing command [ ";
     for (int i = 0; argv[i] != NULL; ++i)
         std::cout << argv[i] << " ";
     std::cout << "]\n";
     std::cout.flush();
     atf::process::argv_array argva(argv);
     return atf::check::exec(argva);
+}
 static
 std::auto_ptr< atf::check::check_result >
 execute_with_shell(char* const* argv)
+{
     const std::string cmd = flatten_argv(argv);
     const char* sh_argv[4];
     sh_argv[0] = atf::config::get("atf_shell").c_str();
     sh_argv[1] = "-c";
     sh_argv[2] = cmd.c_str();
     sh_argv[3] = NULL;
     return execute(sh_argv);
+}
 static
 void
 open_error(const atf::fs::path& path)
+{
     throw std::runtime_error("Failed to open " + path.str() + " "
 	+ ::strerror(errno));
+}
 static
 void
 cat_file(const atf::fs::path& path)
+{
     std::ifstream stream(path.c_str());
     if (!stream)
 	open_error(path);
     stream >> std::noskipws;
     std::istream_iterator< char > begin(stream), end;
     std::ostream_iterator< char > out(std::cerr);
     std::copy(begin, end, out);
     stream.close();
+}
 static
 bool
 grep_file(const atf::fs::path& path, const std::string& regexp)
+{
     std::ifstream stream(path.c_str());
     if (!stream)
 	open_error(path);
     bool found = false;
     std::string line;
     while (!found && !std::getline(stream, line).fail()) {
         if (atf::text::match(line, regexp))
             found = true;
+    }
     stream.close();
     return found;
+}
 static
 bool
 file_empty(const atf::fs::path& p)
+{
     atf::fs::file_info f(p);
     return (f.get_size() == 0);
+}
 static bool
 compare_files(const atf::fs::path& p1, const atf::fs::path& p2)
+{
     bool equal = false;
     std::ifstream f1(p1.c_str());
     if (!f1)
 	open_error(p1);
     std::ifstream f2(p2.c_str());
     if (!f2)
 	open_error(p2);
     for (;;) {
         char buf1[512], buf2[512];
         f1.read(buf1, sizeof(buf1));
         if (f1.bad())
             throw std::runtime_error("Failed to read from " + p1.str());
         f2.read(buf2, sizeof(buf2));
         if (f2.bad())
             throw std::runtime_error("Failed to read from " + p1.str());
         if ((f1.gcount() == 0) && (f2.gcount() == 0)) {
             equal = true;
             break;
+        }
         if ((f1.gcount() != f2.gcount()) ||
             (std::memcmp(buf1, buf2, f1.gcount()) != 0)) {
             break;
+        }
+    }
     return equal;
+}
 static
 void
 print_diff(const atf::fs::path& p1, const atf::fs::path& p2)
+{
     const atf::process::status s =
         atf::process::exec(atf::fs::path("diff"),
                            atf::process::argv_array("diff", "-u", p1.c_str(),
                                                     p2.c_str(), NULL),
                            atf::process::stream_connect(STDOUT_FILENO,
                                                         STDERR_FILENO),
                            atf::process::stream_inherit());
     if (!s.exited())
         std::cerr << "Failed to run diff(3)\n";
     if (s.exitstatus() != 1)
         std::cerr << "Error while running diff(3)\n";
+}
 static
 std::string
 decode(const std::string& s)
+{
     size_t i;
     std::string res;
     res.reserve(s.length());
     i = 0;
     while (i < s.length()) {
         char c = s[i++];
         if (c == '\\') {
             switch (s[i++]) {
             case 'a': c = '\a'; break;
             case 'b': c = '\b'; break;
             case 'c': break;
             case 'e': c = 033; break;
             case 'f': c = '\f'; break;
             case 'n': c = '\n'; break;
             case 'r': c = '\r'; break;
             case 't': c = '\t'; break;
             case 'v': c = '\v'; break;
             case '\\': break;
             case '0':
+                {
                     int count = 3;
                     c = 0;
-                    while (--count >= 0 && (unsigned)(s[i] - '0') < 8)
+                    while (--count >= 0 && static_cast<unsigned>(s[i] - '0') < 8)
                         c = (c << 3) + (s[i++] - '0');
                     break;
+                }
             default:
                 --i;
                 break;
+            }
+        }
         res.push_back(c);
+    }
     return res;
+}
 static
 bool
 run_status_check(const status_check& sc, const atf::check::check_result& cr)
+{
     bool result;
     if (sc.type == sc_exit) {
         if (cr.exited() && sc.value != INT_MIN) {
             const int status = cr.exitcode();
             if (!sc.negated && sc.value != status) {
                 std::cerr << "Fail: incorrect exit status: "
                           << status << ", expected: "
                           << sc.value << "\n";
                 result = false;
             } else if (sc.negated && sc.value == status) {
                 std::cerr << "Fail: incorrect exit status: "
                           << status << ", expected: "
                           << "anything else\n";
                 result = false;
             } else
                 result = true;
         } else if (cr.exited() && sc.value == INT_MIN) {
             result = true;
         } else {
             std::cerr << "Fail: program did not exit cleanly\n";
             result = false;
+        }
     } else if (sc.type == sc_ignore) {
         result = true;
     } else if (sc.type == sc_signal) {
         if (cr.signaled() && sc.value != INT_MIN) {
             const int status = cr.termsig();
             if (!sc.negated && sc.value != status) {
                 std::cerr << "Fail: incorrect signal received: "
                           << status << ", expected: " << sc.value << "\n";
                 result = false;
             } else if (sc.negated && sc.value == status) {
                 std::cerr << "Fail: incorrect signal received: "
                           << status << ", expected: "
                           << "anything else\n";
                 result = false;
             } else
                 result = true;
         } else if (cr.signaled() && sc.value == INT_MIN) {
             result = true;
         } else {
             std::cerr << "Fail: program did not receive a signal\n";
             result = false;
+        }
     } else {
         UNREACHABLE;
         result = false;
+    }
     if (result == false) {
         std::cerr << "stdout:\n";
         cat_file(atf::fs::path(cr.stdout_path()));
         std::cerr << "\n";
         std::cerr << "stderr:\n";
         cat_file(atf::fs::path(cr.stderr_path()));
         std::cerr << "\n";
+    }
     return result;
+}
 static
 bool
 run_status_checks(const std::vector< status_check >& checks,
                   const atf::check::check_result& result)
+{
     bool ok = false;
     for (std::vector< status_check >::const_iterator iter = checks.begin();
          !ok && iter != checks.end(); iter++) {
          ok |= run_status_check(*iter, result);
+    }
     return ok;
+}
 static
 bool
 run_output_check(const output_check oc, const atf::fs::path& path,
                  const std::string& stdxxx)
+{
     bool result;
     if (oc.type == oc_empty) {
         const bool is_empty = file_empty(path);
         if (!oc.negated && !is_empty) {
             std::cerr << "Fail: " << stdxxx << " not empty\n";
             print_diff(atf::fs::path("/dev/null"), path);
             result = false;
         } else if (oc.negated && is_empty) {
             std::cerr << "Fail: " << stdxxx << " is empty\n";
             result = false;
         } else
             result = true;
     } else if (oc.type == oc_file) {
         const bool equals = compare_files(path, atf::fs::path(oc.value));
         if (!oc.negated && !equals) {
             std::cerr << "Fail: " << stdxxx << " does not match golden "
                 "output\n";
             print_diff(atf::fs::path(oc.value), path);
             result = false;
         } else if (oc.negated && equals) {
             std::cerr << "Fail: " << stdxxx << " matches golden output\n";
             cat_file(atf::fs::path(oc.value));
             result = false;
         } else
             result = true;
     } else if (oc.type == oc_ignore) {
         result = true;
     } else if (oc.type == oc_inline) {
         atf::fs::path path2 = atf::fs::path(atf::config::get("atf_workdir"))
                               / "inline.XXXXXX";
         temp_file temp(path2);
         temp.write(decode(oc.value));
         temp.close();
         const bool equals = compare_files(path, temp.get_path());
         if (!oc.negated && !equals) {
             std::cerr << "Fail: " << stdxxx << " does not match expected "
                 "value\n";
             print_diff(temp.get_path(), path);
             result = false;
         } else if (oc.negated && equals) {
             std::cerr << "Fail: " << stdxxx << " matches expected value\n";
             cat_file(temp.get_path());
             result = false;
         } else
             result = true;
     } else if (oc.type == oc_match) {
         const bool matches = grep_file(path, oc.value);
         if (!oc.negated && !matches) {
             std::cerr << "Fail: regexp " + oc.value + " not in " << stdxxx
                       << "\n";
             cat_file(path);
             result = false;
         } else if (oc.negated && matches) {
             std::cerr << "Fail: regexp " + oc.value + " is in " << stdxxx
                       << "\n";
             cat_file(path);
             result = false;
         } else
             result = true;
     } else if (oc.type == oc_save) {
         INV(!oc.negated);
         std::ifstream ifs(path.c_str(), std::fstream::binary);
         ifs >> std::noskipws;
         std::istream_iterator< char > begin(ifs), end;
         std::ofstream ofs(oc.value.c_str(), std::fstream::binary
                                      | std::fstream::trunc);
         std::ostream_iterator <char> obegin(ofs);
         std::copy(begin, end, obegin);
         result = true;
     } else {
         UNREACHABLE;
         result = false;
+    }
     return result;
+}
 static
 bool
 run_output_checks(const std::vector< output_check >& checks,
                   const atf::fs::path& path, const std::string& stdxxx)
+{
     bool ok = true;
     for (std::vector< output_check >::const_iterator iter = checks.begin();
          iter != checks.end(); iter++) {
          ok &= run_output_check(*iter, path, stdxxx);
+    }
     return ok;
+}
 // ------------------------------------------------------------------------
 // The "atf_check" application.
 // ------------------------------------------------------------------------
 namespace {
 class atf_check : public atf::application::app {
     bool m_xflag;
     std::vector< status_check > m_status_checks;
     std::vector< output_check > m_stdout_checks;
     std::vector< output_check > m_stderr_checks;
     static const char* m_description;
     bool run_output_checks(const atf::check::check_result&,
                            const std::string&) const;
     std::string specific_args(void) const;
     options_set specific_options(void) const;
     void process_option(int, const char*);
     void process_option_s(const std::string&);
 public:
     atf_check(void);
     int main(void);
 };
 } // anonymous namespace
 const char* atf_check::m_description =
     "atf-check executes given command and analyzes its results.";
 atf_check::atf_check(void) :
     app(m_description, "atf-check(1)"),
     m_xflag(false)
+{
+}
 bool
 atf_check::run_output_checks(const atf::check::check_result& r,
                              const std::string& stdxxx)
     const
+{
     if (stdxxx == "stdout") {
         return ::run_output_checks(m_stdout_checks,
             atf::fs::path(r.stdout_path()), "stdout");
     } else if (stdxxx == "stderr") {
         return ::run_output_checks(m_stderr_checks,
             atf::fs::path(r.stderr_path()), "stderr");
     } else {
         UNREACHABLE;
         return false;
+    }
+}
 std::string
 atf_check::specific_args(void)
     const
+{
     return "<command>";
+}
 atf_check::options_set
 atf_check::specific_options(void)
     const
+{
     using atf::application::option;
     options_set opts;
     opts.insert(option('s', "qual:value", "Handle status. Qualifier "
                 "must be one of: ignore exit:<num> signal:<name|num>"));
     opts.insert(option('o', "action:arg", "Handle stdout. Action must be "
                 "one of: empty ignore file:<path> inline:<val> match:regexp "
                 "save:<path>"));
     opts.insert(option('e', "action:arg", "Handle stderr. Action must be "
                 "one of: empty ignore file:<path> inline:<val> match:regexp "
                 "save:<path>"));
     opts.insert(option('x', "", "Execute command as a shell command"));
     return opts;
+}
 void
 atf_check::process_option(int ch, const char* arg)
+{
     switch (ch) {
     case 's':
         m_status_checks.push_back(parse_status_check_arg(arg));
         break;
     case 'o':
         m_stdout_checks.push_back(parse_output_check_arg(arg));
         break;
     case 'e':
         m_stderr_checks.push_back(parse_output_check_arg(arg));
         break;
     case 'x':
         m_xflag = true;
         break;
     default:
         UNREACHABLE;
+    }
+}
 int
 atf_check::main(void)
+{
     if (m_argc < 1)
         throw atf::application::usage_error("No command specified");
     int status = EXIT_FAILURE;
     std::auto_ptr< atf::check::check_result > r =
         m_xflag ? execute_with_shell(m_argv) : execute(m_argv);
     if (m_status_checks.empty())
         m_status_checks.push_back(status_check(sc_exit, false, EXIT_SUCCESS));
     else if (m_status_checks.size() > 1) {
         // TODO: Remove this restriction.
         throw atf::application::usage_error("Cannot specify -s more than once");
+    }
     if (m_stdout_checks.empty())
         m_stdout_checks.push_back(output_check(oc_empty, false, ""));
     if (m_stderr_checks.empty())
         m_stderr_checks.push_back(output_check(oc_empty, false, ""));
     if ((run_status_checks(m_status_checks, *r) == false) ||
         (run_output_checks(*r, "stderr") == false) ||
         (run_output_checks(*r, "stdout") == false))
         status = EXIT_FAILURE;
     else
         status = EXIT_SUCCESS;
     return status;
+}
 int
 main(int argc, char* const* argv)
+{
     return atf_check().run(argc, argv);
+}

	@@ -1,510 +1,509 @@		@@ -1,510 +1,509 @@
1	//	1	//
2	// Automated Testing Framework (atf)	2	// Automated Testing Framework (atf)
3	//	3	//
4	// Copyright (c) 2008 The NetBSD Foundation, Inc.	4	// Copyright (c) 2008 The NetBSD Foundation, Inc.
5	// All rights reserved.	5	// All rights reserved.
6	//	6	//
7	// Redistribution and use in source and binary forms, with or without	7	// Redistribution and use in source and binary forms, with or without
8	// modification, are permitted provided that the following conditions	8	// modification, are permitted provided that the following conditions
9	// are met:	9	// are met:
10	// 1. Redistributions of source code must retain the above copyright	10	// 1. Redistributions of source code must retain the above copyright
11	// notice, this list of conditions and the following disclaimer.	11	// notice, this list of conditions and the following disclaimer.
12	// 2. Redistributions in binary form must reproduce the above copyright	12	// 2. Redistributions in binary form must reproduce the above copyright
13	// notice, this list of conditions and the following disclaimer in the	13	// notice, this list of conditions and the following disclaimer in the
14	// documentation and/or other materials provided with the distribution.	14	// documentation and/or other materials provided with the distribution.
15	//	15	//
16	// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND	16	// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17	// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,	17	// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF	18	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19	// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY	20	// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21	// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL	21	// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE	22	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23	// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	23	// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER	24	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25	// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR	25	// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26	// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN	26	// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27	// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	//	28	//
29		29
30	extern "C" {	30	extern "C" {
31	#include <sys/types.h>	31	#include <sys/types.h>
32	#include <sys/wait.h>	32	#include <sys/wait.h>
33		33
34	#include <fcntl.h>	34	#include <fcntl.h>
35	#include <signal.h>	35	#include <signal.h>
36	}	36	}
37		37
38	#include <cassert>	38	#include <cassert>
39	#include <cstdarg>	39	#include <cstdarg>
40	#include <cerrno>	40	#include <cerrno>
41	#include <cstring>	41	#include <cstring>
42	#include <iostream>	42	#include <iostream>
43		43
44	#include "exceptions.hpp"	44	#include "exceptions.hpp"
45	#include "text.hpp"	45	#include "text.hpp"
46	#include "process.hpp"	46	#include "process.hpp"
47		47
48	namespace detail = tools::process::detail;	48	namespace detail = tools::process::detail;
49	namespace impl = tools::process;	49	namespace impl = tools::process;
50	#define IMPL_NAME "tools::process"	50	#define IMPL_NAME "tools::process"
51		51
52	// ------------------------------------------------------------------------	52	// ------------------------------------------------------------------------
53	// Auxiliary functions.	53	// Auxiliary functions.
54	// ------------------------------------------------------------------------	54	// ------------------------------------------------------------------------
55		55
56	template< class C >	56	template< class C >
57	tools::auto_array< const char* >	57	tools::auto_array< const char* >
58	collection_to_argv(const C& c)	58	collection_to_argv(const C& c)
59	{	59	{
60	tools::auto_array< const char* > argv(new const char*[c.size() + 1]);	60	tools::auto_array< const char* > argv(new const char*[c.size() + 1]);
61		61
62	std::size_t pos = 0;	62	std::size_t pos = 0;
63	for (typename C::const_iterator iter = c.begin(); iter != c.end();	63	for (typename C::const_iterator iter = c.begin(); iter != c.end();
64	iter++) {	64	iter++) {
65	argv[pos] = (*iter).c_str();	65	argv[pos] = (*iter).c_str();
66	pos++;	66	pos++;
67	}	67	}
68	assert(pos == c.size());	68	assert(pos == c.size());
69	argv[pos] = NULL;	69	argv[pos] = NULL;
70		70
71	return argv;	71	return argv;
72	}	72	}
73		73
74	template< class C >	74	template< class C >
75	C	75	C
76	argv_to_collection(const char* const* argv)	76	argv_to_collection(const char* const* argv)
77	{	77	{
78	C c;	78	C c;
79		79
80	for (const char* const* iter = argv; *iter != NULL; iter++)	80	for (const char* const* iter = argv; *iter != NULL; iter++)
81	c.push_back(std::string(*iter));	81	c.push_back(std::string(*iter));
82		82
83	return c;	83	return c;
84	}	84	}
85		85
86	static	86	static
87	void	87	void
88	safe_dup(const int oldfd, const int newfd)	88	safe_dup(const int oldfd, const int newfd)
89	{	89	{
90	if (oldfd != newfd) {	90	if (oldfd != newfd) {
91	if (dup2(oldfd, newfd) == -1) {	91	if (dup2(oldfd, newfd) == -1) {
92	throw tools::system_error(IMPL_NAME "::safe_dup",	92	throw tools::system_error(IMPL_NAME "::safe_dup",
93	"Could not allocate file descriptor",	93	"Could not allocate file descriptor",
94	errno);	94	errno);
95	} else {	95	} else {
96	::close(oldfd);	96	::close(oldfd);
97	}	97	}
98	}	98	}
99	}	99	}
100		100
101	static	101	static
102	int	102	int
103	const_execvp(const char file, const char const *argv)	103	const_execvp(const char file, const char const *argv)
104	{	104	{
105	#define UNCONST(a) ((void )(unsigned long)(const void )(a))	105	return ::execvp(file, const_cast<char* const*>(argv));
106	return ::execvp(file, (char* const*)(UNCONST(argv)));
107	#undef UNCONST	106	#undef UNCONST
108	}	107	}
109		108
110	void	109	void
111	detail::do_exec(void *v)	110	detail::do_exec(void *v)
112	{	111	{
113	struct exec_args ea = reinterpret_cast<struct exec_args >(v);	112	struct exec_args ea = reinterpret_cast<struct exec_args >(v);
114		113
115	if (ea->m_prehook != NULL)	114	if (ea->m_prehook != NULL)
116	ea->m_prehook();	115	ea->m_prehook();
117		116
118	const int ret = const_execvp(ea->m_prog.c_str(), ea->m_argv.exec_argv());	117	const int ret = const_execvp(ea->m_prog.c_str(), ea->m_argv.exec_argv());
119	const int errnocopy = errno;	118	const int errnocopy = errno;
120	assert(ret == -1);	119	assert(ret == -1);
121	std::cerr << "exec(" << ea->m_prog.str() << ") failed: "	120	std::cerr << "exec(" << ea->m_prog.str() << ") failed: "
122	<< std::strerror(errnocopy) << "\n";	121	<< std::strerror(errnocopy) << "\n";
123	std::exit(EXIT_FAILURE);	122	std::exit(EXIT_FAILURE);
124	}	123	}
125		124
126	// ------------------------------------------------------------------------	125	// ------------------------------------------------------------------------
127	// The "argv_array" type.	126	// The "argv_array" type.
128	// ------------------------------------------------------------------------	127	// ------------------------------------------------------------------------
129		128
130	impl::argv_array::argv_array(void) :	129	impl::argv_array::argv_array(void) :
131	m_exec_argv(collection_to_argv(m_args))	130	m_exec_argv(collection_to_argv(m_args))
132	{	131	{
133	}	132	}
134		133
135	impl::argv_array::argv_array(const char* arg1, ...)	134	impl::argv_array::argv_array(const char* arg1, ...)
136	{	135	{
137	m_args.push_back(arg1);	136	m_args.push_back(arg1);
138		137
139	{	138	{
140	va_list ap;	139	va_list ap;
141	const char* nextarg;	140	const char* nextarg;
142		141
143	va_start(ap, arg1);	142	va_start(ap, arg1);
144	while ((nextarg = va_arg(ap, const char*)) != NULL)	143	while ((nextarg = va_arg(ap, const char*)) != NULL)
145	m_args.push_back(nextarg);	144	m_args.push_back(nextarg);
146	va_end(ap);	145	va_end(ap);
147	}	146	}
148		147
149	ctor_init_exec_argv();	148	ctor_init_exec_argv();
150	}	149	}
151		150
152	impl::argv_array::argv_array(const char* const* ca) :	151	impl::argv_array::argv_array(const char* const* ca) :
153	m_args(argv_to_collection< args_vector >(ca)),	152	m_args(argv_to_collection< args_vector >(ca)),
154	m_exec_argv(collection_to_argv(m_args))	153	m_exec_argv(collection_to_argv(m_args))
155	{	154	{
156	}	155	}
157		156
158	impl::argv_array::argv_array(const argv_array& a) :	157	impl::argv_array::argv_array(const argv_array& a) :
159	m_args(a.m_args),	158	m_args(a.m_args),
160	m_exec_argv(collection_to_argv(m_args))	159	m_exec_argv(collection_to_argv(m_args))
161	{	160	{
162	}	161	}
163		162
164	void	163	void
165	impl::argv_array::ctor_init_exec_argv(void)	164	impl::argv_array::ctor_init_exec_argv(void)
166	{	165	{
167	m_exec_argv = collection_to_argv(m_args);	166	m_exec_argv = collection_to_argv(m_args);
168	}	167	}
169		168
170	const char* const*	169	const char* const*
171	impl::argv_array::exec_argv(void)	170	impl::argv_array::exec_argv(void)
172	const	171	const
173	{	172	{
174	return m_exec_argv.get();	173	return m_exec_argv.get();
175	}	174	}
176		175
177	impl::argv_array::size_type	176	impl::argv_array::size_type
178	impl::argv_array::size(void)	177	impl::argv_array::size(void)
179	const	178	const
180	{	179	{
181	return m_args.size();	180	return m_args.size();
182	}	181	}
183		182
184	const char*	183	const char*
185	impl::argv_array::operator[](int idx)	184	impl::argv_array::operator[](int idx)
186	const	185	const
187	{	186	{
188	return m_args[idx].c_str();	187	return m_args[idx].c_str();
189	}	188	}
190		189
191	impl::argv_array::const_iterator	190	impl::argv_array::const_iterator
192	impl::argv_array::begin(void)	191	impl::argv_array::begin(void)
193	const	192	const
194	{	193	{
195	return m_args.begin();	194	return m_args.begin();
196	}	195	}
197		196
198	impl::argv_array::const_iterator	197	impl::argv_array::const_iterator
199	impl::argv_array::end(void)	198	impl::argv_array::end(void)
200	const	199	const
201	{	200	{
202	return m_args.end();	201	return m_args.end();
203	}	202	}
204		203
205	impl::argv_array&	204	impl::argv_array&
206	impl::argv_array::operator=(const argv_array& a)	205	impl::argv_array::operator=(const argv_array& a)
207	{	206	{
208	if (this != &a) {	207	if (this != &a) {
209	m_args = a.m_args;	208	m_args = a.m_args;
210	m_exec_argv = collection_to_argv(m_args);	209	m_exec_argv = collection_to_argv(m_args);
211	}	210	}
212	return *this;	211	return *this;
213	}	212	}
214		213
215	// ------------------------------------------------------------------------	214	// ------------------------------------------------------------------------
216	// The "stream" types.	215	// The "stream" types.
217	// ------------------------------------------------------------------------	216	// ------------------------------------------------------------------------
218		217
219	impl::stream_capture::stream_capture(void)	218	impl::stream_capture::stream_capture(void)
220	{	219	{
221	for (int i = 0; i < 2; i++)	220	for (int i = 0; i < 2; i++)
222	m_pipefds[i] = -1;	221	m_pipefds[i] = -1;
223	}	222	}
224		223
225	impl::stream_capture::~stream_capture(void)	224	impl::stream_capture::~stream_capture(void)
226	{	225	{
227	for (int i = 0; i < 2; i++)	226	for (int i = 0; i < 2; i++)
228	if (m_pipefds[i] != -1)	227	if (m_pipefds[i] != -1)
229	::close(m_pipefds[i]);	228	::close(m_pipefds[i]);
230	}	229	}
231		230
232	void	231	void
233	impl::stream_capture::prepare(void)	232	impl::stream_capture::prepare(void)
234	{	233	{
235	if (pipe(m_pipefds) == -1)	234	if (pipe(m_pipefds) == -1)
236	throw system_error(IMPL_NAME "::stream_capture::prepare",	235	throw system_error(IMPL_NAME "::stream_capture::prepare",
237	"Failed to create pipe", errno);	236	"Failed to create pipe", errno);
238	}	237	}
239		238
240	int	239	int
241	impl::stream_capture::connect_parent(void)	240	impl::stream_capture::connect_parent(void)
242	{	241	{
243	::close(m_pipefds[1]); m_pipefds[1] = -1;	242	::close(m_pipefds[1]); m_pipefds[1] = -1;
244	const int fd = m_pipefds[0];	243	const int fd = m_pipefds[0];
245	m_pipefds[0] = -1;	244	m_pipefds[0] = -1;
246	return fd;	245	return fd;
247	}	246	}
248		247
249	void	248	void
250	impl::stream_capture::connect_child(const int fd)	249	impl::stream_capture::connect_child(const int fd)
251	{	250	{
252	::close(m_pipefds[0]); m_pipefds[0] = -1;	251	::close(m_pipefds[0]); m_pipefds[0] = -1;
253	if (m_pipefds[1] != fd) {	252	if (m_pipefds[1] != fd) {
254	safe_dup(m_pipefds[1], fd);	253	safe_dup(m_pipefds[1], fd);
255	}	254	}
256	m_pipefds[1] = -1;	255	m_pipefds[1] = -1;
257	}	256	}
258		257
259	impl::stream_connect::stream_connect(const int src_fd, const int tgt_fd) :	258	impl::stream_connect::stream_connect(const int src_fd, const int tgt_fd) :
260	m_src_fd(src_fd), m_tgt_fd(tgt_fd)	259	m_src_fd(src_fd), m_tgt_fd(tgt_fd)
261	{	260	{
262	}	261	}
263		262
264	void	263	void
265	impl::stream_connect::prepare(void)	264	impl::stream_connect::prepare(void)
266	{	265	{
267	}	266	}
268		267
269	int	268	int
270	impl::stream_connect::connect_parent(void)	269	impl::stream_connect::connect_parent(void)
271	{	270	{
272	return -1;	271	return -1;
273	}	272	}
274		273
275	void	274	void
276	impl::stream_connect::connect_child(const int fd __attribute__((__unused__)))	275	impl::stream_connect::connect_child(const int fd __attribute__((__unused__)))
277	{	276	{
278	safe_dup(m_tgt_fd, m_src_fd);	277	safe_dup(m_tgt_fd, m_src_fd);
279	}	278	}
280		279
281	impl::stream_inherit::stream_inherit(void)	280	impl::stream_inherit::stream_inherit(void)
282	{	281	{
283	}	282	}
284		283
285	void	284	void
286	impl::stream_inherit::prepare(void)	285	impl::stream_inherit::prepare(void)
287	{	286	{
288	}	287	}
289		288
290	int	289	int
291	impl::stream_inherit::connect_parent(void)	290	impl::stream_inherit::connect_parent(void)
292	{	291	{
293	return -1;	292	return -1;
294	}	293	}
295		294
296	void	295	void
297	impl::stream_inherit::connect_child(const int fd __attribute__((__unused__)))	296	impl::stream_inherit::connect_child(const int fd __attribute__((__unused__)))
298	{	297	{
299	}	298	}
300		299
301	impl::stream_redirect_fd::stream_redirect_fd(const int fd) :	300	impl::stream_redirect_fd::stream_redirect_fd(const int fd) :
302	m_fd(fd)	301	m_fd(fd)
303	{	302	{
304	}	303	}
305		304
306	void	305	void
307	impl::stream_redirect_fd::prepare(void)	306	impl::stream_redirect_fd::prepare(void)
308	{	307	{
309	}	308	}
310		309
311	int	310	int
312	impl::stream_redirect_fd::connect_parent(void)	311	impl::stream_redirect_fd::connect_parent(void)
313	{	312	{
314	return -1;	313	return -1;
315	}	314	}
316		315
317	void	316	void
318	impl::stream_redirect_fd::connect_child(const int fd)	317	impl::stream_redirect_fd::connect_child(const int fd)
319	{	318	{
320	safe_dup(m_fd, fd);	319	safe_dup(m_fd, fd);
321	}	320	}
322		321
323	impl::stream_redirect_path::stream_redirect_path(const tools::fs::path& p) :	322	impl::stream_redirect_path::stream_redirect_path(const tools::fs::path& p) :
324	m_path(p)	323	m_path(p)
325	{	324	{
326	}	325	}
327		326
328	void	327	void
329	impl::stream_redirect_path::prepare(void)	328	impl::stream_redirect_path::prepare(void)
330	{	329	{
331	}	330	}
332		331
333	int	332	int
334	impl::stream_redirect_path::connect_parent(void)	333	impl::stream_redirect_path::connect_parent(void)
335	{	334	{
336	return -1;	335	return -1;
337	}	336	}
338		337
339	void	338	void
340	impl::stream_redirect_path::connect_child(const int fd)	339	impl::stream_redirect_path::connect_child(const int fd)
341	{	340	{
342	const int aux = ::open(m_path.c_str(), O_WRONLY \| O_CREAT \| O_TRUNC, 0644);	341	const int aux = ::open(m_path.c_str(), O_WRONLY \| O_CREAT \| O_TRUNC, 0644);
343	if (aux == -1)	342	if (aux == -1)
344	throw system_error(IMPL_NAME "::stream_redirect_path::connect_child",	343	throw system_error(IMPL_NAME "::stream_redirect_path::connect_child",
345	"Could not create " + m_path.str(), errno);	344	"Could not create " + m_path.str(), errno);
346	else	345	else
347	safe_dup(aux, fd);	346	safe_dup(aux, fd);
348	}	347	}
349		348
350	// ------------------------------------------------------------------------	349	// ------------------------------------------------------------------------
351	// The "status" type.	350	// The "status" type.
352	// ------------------------------------------------------------------------	351	// ------------------------------------------------------------------------
353		352
354	impl::status::status(int s) :	353	impl::status::status(int s) :
355	m_status(s)	354	m_status(s)
356	{	355	{
357	}	356	}
358		357
359	impl::status::~status(void)	358	impl::status::~status(void)
360	{	359	{
361	}	360	}
362		361
363	std::string	362	std::string
364	impl::status::str(void)	363	impl::status::str(void)
365	const	364	const
366	{	365	{
367	int mutable_status = m_status;	366	int mutable_status = m_status;
368	std::stringstream rv;	367	std::stringstream rv;
369	if (WIFEXITED(mutable_status))	368	if (WIFEXITED(mutable_status))
370	rv << "exit(" << WEXITSTATUS(mutable_status);	369	rv << "exit(" << WEXITSTATUS(mutable_status);
371	else if (WIFSTOPPED(mutable_status))	370	else if (WIFSTOPPED(mutable_status))
372	rv << "stopped(" << WSTOPSIG(mutable_status);	371	rv << "stopped(" << WSTOPSIG(mutable_status);
373	else if (WIFSIGNALED(mutable_status))	372	else if (WIFSIGNALED(mutable_status))
374	rv << "terminated(" << WTERMSIG(mutable_status);	373	rv << "terminated(" << WTERMSIG(mutable_status);
375	if (WCOREDUMP(mutable_status))	374	if (WCOREDUMP(mutable_status))
376	rv << "/core)";	375	rv << "/core)";
377	else	376	else
378	rv << ")";	377	rv << ")";
379	return rv.str();	378	return rv.str();
380	}	379	}
381		380
382	bool	381	bool
383	impl::status::exited(void)	382	impl::status::exited(void)
384	const	383	const
385	{	384	{
386	int mutable_status = m_status;	385	int mutable_status = m_status;
387	return WIFEXITED(mutable_status);	386	return WIFEXITED(mutable_status);
388	}	387	}
389		388
390	int	389	int
391	impl::status::exitstatus(void)	390	impl::status::exitstatus(void)
392	const	391	const
393	{	392	{
394	assert(exited());	393	assert(exited());
395	int mutable_status = m_status;	394	int mutable_status = m_status;
396	return WEXITSTATUS(mutable_status);	395	return WEXITSTATUS(mutable_status);
397	}	396	}
398		397
399	bool	398	bool
400	impl::status::signaled(void)	399	impl::status::signaled(void)
401	const	400	const
402	{	401	{
403	int mutable_status = m_status;	402	int mutable_status = m_status;
404	return WIFSIGNALED(mutable_status);	403	return WIFSIGNALED(mutable_status);
405	}	404	}
406		405
407	int	406	int
408	impl::status::termsig(void)	407	impl::status::termsig(void)
409	const	408	const
410	{	409	{
411	assert(signaled());	410	assert(signaled());
412	int mutable_status = m_status;	411	int mutable_status = m_status;
413	return WTERMSIG(mutable_status);	412	return WTERMSIG(mutable_status);
414	}	413	}
415		414
416	bool	415	bool
417	impl::status::coredump(void)	416	impl::status::coredump(void)
418	const	417	const
419	{	418	{
420	assert(signaled());	419	assert(signaled());
421	int mutable_status = m_status;	420	int mutable_status = m_status;
422	return WCOREDUMP(mutable_status);	421	return WCOREDUMP(mutable_status);
423	}	422	}
424		423
425	// ------------------------------------------------------------------------	424	// ------------------------------------------------------------------------
426	// The "child" type.	425	// The "child" type.
427	// ------------------------------------------------------------------------	426	// ------------------------------------------------------------------------
428		427
429	impl::child::child(const pid_t pid_arg, const int stdout_fd_arg,	428	impl::child::child(const pid_t pid_arg, const int stdout_fd_arg,
430	const int stderr_fd_arg) :	429	const int stderr_fd_arg) :
431	m_pid(pid_arg),	430	m_pid(pid_arg),
432	m_stdout(stdout_fd_arg),	431	m_stdout(stdout_fd_arg),
433	m_stderr(stderr_fd_arg),	432	m_stderr(stderr_fd_arg),
434	m_waited(false)	433	m_waited(false)
435	{	434	{
436	}	435	}
437		436
438	impl::child::~child(void)	437	impl::child::~child(void)
439	{	438	{
440	if (!m_waited) {	439	if (!m_waited) {
441	::kill(m_pid, SIGTERM);	440	::kill(m_pid, SIGTERM);
442	(void)wait();	441	(void)wait();
443		442
444	if (m_stdout != -1) {	443	if (m_stdout != -1) {
445	::close(m_stdout); m_stdout = -1;	444	::close(m_stdout); m_stdout = -1;
446	}	445	}
447	if (m_stderr != -1) {	446	if (m_stderr != -1) {
448	::close(m_stderr); m_stderr = -1;	447	::close(m_stderr); m_stderr = -1;
449	}	448	}
450	}	449	}
451	}	450	}
452		451
453	impl::status	452	impl::status
454	impl::child::wait(void)	453	impl::child::wait(void)
455	{	454	{
456	int s;	455	int s;
457		456
458	if (::waitpid(m_pid, &s, 0) == -1)	457	if (::waitpid(m_pid, &s, 0) == -1)
459	throw system_error(IMPL_NAME "::child::wait", "Failed waiting for "	458	throw system_error(IMPL_NAME "::child::wait", "Failed waiting for "
460	"process " + text::to_string(m_pid), errno);	459	"process " + text::to_string(m_pid), errno);
461		460
462	if (m_stdout != -1) {	461	if (m_stdout != -1) {
463	::close(m_stdout); m_stdout = -1;	462	::close(m_stdout); m_stdout = -1;
464	}	463	}
465	if (m_stderr != -1) {	464	if (m_stderr != -1) {
466	::close(m_stderr); m_stderr = -1;	465	::close(m_stderr); m_stderr = -1;
467	}	466	}
468		467
469	m_waited = true;	468	m_waited = true;
470	return status(s);	469	return status(s);
471	}	470	}
472		471
473	pid_t	472	pid_t
474	impl::child::pid(void)	473	impl::child::pid(void)
475	const	474	const
476	{	475	{
477	return m_pid;	476	return m_pid;
478	}	477	}
479		478
480	int	479	int
481	impl::child::stdout_fd(void)	480	impl::child::stdout_fd(void)
482	{	481	{
483	return m_stdout;	482	return m_stdout;
484	}	483	}
485		484
486	int	485	int
487	impl::child::stderr_fd(void)	486	impl::child::stderr_fd(void)
488	{	487	{
489	return m_stderr;	488	return m_stderr;
490	}	489	}
491		490
492	// ------------------------------------------------------------------------	491	// ------------------------------------------------------------------------
493	// Free functions.	492	// Free functions.
494	// ------------------------------------------------------------------------	493	// ------------------------------------------------------------------------
495		494
496	void	495	void
497	detail::flush_streams(void)	496	detail::flush_streams(void)
498	{	497	{
499	// This is a weird hack to ensure that the output of the parent process	498	// This is a weird hack to ensure that the output of the parent process
500	// is flushed before executing a child which prevents, for example, the	499	// is flushed before executing a child which prevents, for example, the
501	// output of the atf-run hooks to appear before the output of atf-run	500	// output of the atf-run hooks to appear before the output of atf-run
502	// itself.	501	// itself.
503	//	502	//
504	// TODO: This should only be executed when inheriting the stdout or	503	// TODO: This should only be executed when inheriting the stdout or
505	// stderr file descriptors. However, the flushing is specific to the	504	// stderr file descriptors. However, the flushing is specific to the
506	// iostreams, so we cannot do it from the C library where all the process	505	// iostreams, so we cannot do it from the C library where all the process
507	// logic is performed. Come up with a better design.	506	// logic is performed. Come up with a better design.
508	std::cout.flush();	507	std::cout.flush();
509	std::cerr.flush();	508	std::cerr.flush();
510	}	509	}