std::pair< int, int > impl::get_required_user(const atf::tests::vars_map& metadata, const atf::tests::vars_map& config) { const atf::tests::vars_map::const_iterator user = metadata.find( "require.user"); if (user == metadata.end()) return std::make_pair(-1, -1); if ((*user).second == "unprivileged") { if (impl::is_root()) { const atf::tests::vars_map::const_iterator iter = config.find( "unprivileged-user"); try { return impl::get_user_ids((*iter).second); } catch (const std::exception& e) { UNREACHABLE; // This has been validated by check_user. throw e; } } else { return std::make_pair(-1, -1); } } else return std::make_pair(-1, -1); }
std::pair< std::string, atf::process::status > impl::run_test_case(const atf::fs::path& executable, const std::string& test_case_name, const std::string& test_case_part, const atf::tests::vars_map& metadata, const atf::tests::vars_map& config, const atf::fs::path& resfile, const atf::fs::path& workdir, atf_tps_writer& writer) { // TODO: Capture termination signals and deliver them to the subprocess // instead. Or maybe do something else; think about it. test_case_params params(executable, test_case_name, test_case_part, metadata, config, resfile, workdir); atf::process::child child = atf::process::fork(run_test_case_child, atf::process::stream_capture(), atf::process::stream_capture(), static_cast< void * >(¶ms)); terminate_poll = false; const atf::tests::vars_map::const_iterator iter = metadata.find("timeout"); INV(iter != metadata.end()); const unsigned int timeout = atf::text::to_type< unsigned int >((*iter).second); const pid_t child_pid = child.pid(); // Get the input stream of stdout and stderr. impl::file_handle outfh = child.stdout_fd(); impl::file_handle errfh = child.stderr_fd(); bool timed_out = false; // Process the test case's output and multiplex it into our output // stream as we read it. int fds[2] = {outfh.get(), errfh.get()}; child_muxer mux(fds, 2, writer); try { child_timer timeout_timer(timeout, child_pid, terminate_poll); signal_programmer sigchld(SIGCHLD, sigchld_handler); mux.mux(terminate_poll); timed_out = timeout_timer.fired(); } catch (...) { UNREACHABLE; } ::killpg(child_pid, SIGKILL); mux.flush(); atf::process::status status = child.wait(); std::string reason; if (timed_out) { // Don't assume the child process has been signaled due to the timeout // expiration as older versions did. The child process may have exited // but we may have timed out due to a subchild process getting stuck. reason = "Test case timed out after " + atf::text::to_string(timeout) + " " + (timeout == 1 ? "second" : "seconds"); } return std::make_pair(reason, status); }