d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
fe138cc2af
freebsd-skq/contrib/atf/atf-run/io.cpp
Marcel Moolenaar c243e4902b Merge ATF 0.16 from vendor/atf/dist. 
Provenance: http://code.google.com/p/kyua
Discussed with: gibbs, gnn, keramida, mdf, mlaier,
Discussed with: Garrett Cooper
2012-09-04 23:16:58 +00:00

362 lines
8.7 KiB
C++
Raw Blame History

//
// Automated Testing Framework (atf)
//
// Copyright (c) 2007 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 <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <unistd.h>
}
#include <cerrno>
#include <cstring>
extern "C" {
#include "../atf-c/error.h"
}
#include "../atf-c++/detail/exceptions.hpp"
#include "../atf-c++/detail/sanity.hpp"
#include "../atf-c++/utils.hpp"
#include "io.hpp"
namespace impl = atf::atf_run;
#define IMPL_NAME "atf::atf_run"
// ------------------------------------------------------------------------
// The "file_handle" class.
// ------------------------------------------------------------------------
impl::file_handle::file_handle(void) :
m_handle(invalid_value())
{
}
impl::file_handle::file_handle(handle_type h) :
m_handle(h)
{
PRE(m_handle != invalid_value());
}
impl::file_handle::file_handle(const file_handle& fh) :
m_handle(fh.m_handle)
{
fh.m_handle = invalid_value();
}
impl::file_handle::~file_handle(void)
{
if (is_valid())
close();
}
impl::file_handle&
impl::file_handle::operator=(const file_handle& fh)
{
m_handle = fh.m_handle;
fh.m_handle = invalid_value();
return *this;
}
bool
impl::file_handle::is_valid(void)
const
{
return m_handle != invalid_value();
}
void
impl::file_handle::close(void)
{
PRE(is_valid());
::close(m_handle);
m_handle = invalid_value();
}
impl::file_handle::handle_type
impl::file_handle::disown(void)
{
PRE(is_valid());
handle_type h = m_handle;
m_handle = invalid_value();
return h;
}
impl::file_handle::handle_type
impl::file_handle::get(void)
const
{
PRE(is_valid());
return m_handle;
}
void
impl::file_handle::posix_remap(handle_type h)
{
PRE(is_valid());
if (m_handle == h)
return;
if (::dup2(m_handle, h) == -1)
throw system_error(IMPL_NAME "::file_handle::posix_remap",
"dup2(2) failed", errno);
if (::close(m_handle) == -1) {
::close(h);
throw system_error(IMPL_NAME "::file_handle::posix_remap",
"close(2) failed", errno);
}
m_handle = h;
}
impl::file_handle::handle_type
impl::file_handle::invalid_value(void)
{
return -1;
}
// ------------------------------------------------------------------------
// The "systembuf" class.
// ------------------------------------------------------------------------
impl::systembuf::systembuf(handle_type h, std::size_t bufsize) :
m_handle(h),
m_bufsize(bufsize),
m_read_buf(NULL),
m_write_buf(NULL)
{
PRE(m_handle >= 0);
PRE(m_bufsize > 0);
try {
m_read_buf = new char[bufsize];
m_write_buf = new char[bufsize];
} catch (...) {
if (m_read_buf != NULL)
delete [] m_read_buf;
if (m_write_buf != NULL)
delete [] m_write_buf;
throw;
}
setp(m_write_buf, m_write_buf + m_bufsize);
}
impl::systembuf::~systembuf(void)
{
delete [] m_read_buf;
delete [] m_write_buf;
}
impl::systembuf::int_type
impl::systembuf::underflow(void)
{
PRE(gptr() >= egptr());
bool ok;
ssize_t cnt = ::read(m_handle, m_read_buf, m_bufsize);
ok = (cnt != -1 && cnt != 0);
if (!ok)
return traits_type::eof();
else {
setg(m_read_buf, m_read_buf, m_read_buf + cnt);
return traits_type::to_int_type(*gptr());
}
}
impl::systembuf::int_type
impl::systembuf::overflow(int c)
{
PRE(pptr() >= epptr());
if (sync() == -1)
return traits_type::eof();
if (!traits_type::eq_int_type(c, traits_type::eof())) {
traits_type::assign(*pptr(), c);
pbump(1);
}
return traits_type::not_eof(c);
}
int
impl::systembuf::sync(void)
{
ssize_t cnt = pptr() - pbase();
bool ok;
ok = ::write(m_handle, pbase(), cnt) == cnt;
if (ok)
pbump(-cnt);
return ok ? 0 : -1;
}
// ------------------------------------------------------------------------
// The "pistream" class.
// ------------------------------------------------------------------------
impl::pistream::pistream(const int fd) :
std::istream(NULL),
m_systembuf(fd)
{
rdbuf(&m_systembuf);
}
// ------------------------------------------------------------------------
// The "muxer" class.
// ------------------------------------------------------------------------
static int
safe_poll(struct pollfd fds[], nfds_t nfds, int timeout)
{
int ret = ::poll(fds, nfds, timeout);
if (ret == -1) {
if (errno == EINTR)
ret = 0;
else
throw atf::system_error(IMPL_NAME "::safe_poll", "poll(2) failed",
errno);
}
INV(ret >= 0);
return ret;
}
static size_t
safe_read(const int fd, void* buffer, const size_t nbytes,
const bool report_errors)
{
int ret;
while ((ret = ::read(fd, buffer, nbytes)) == -1 && errno == EINTR) {}
if (ret == -1) {
INV(errno != EINTR);
if (report_errors)
throw atf::system_error(IMPL_NAME "::safe_read", "read(2) failed",
errno);
else
ret = 0;
}
INV(ret >= 0);
return static_cast< size_t >(ret);
}
impl::muxer::muxer(const int* fds, const size_t nfds, const size_t bufsize) :
m_fds(fds),
m_nfds(nfds),
m_bufsize(bufsize),
m_buffers(new std::string[nfds])
{
}
impl::muxer::~muxer(void)
{
}
size_t
impl::muxer::read_one(const size_t index, const int fd, std::string& accum,
const bool report_errors)
{
atf::utils::auto_array< char > buffer(new char[m_bufsize]);
const size_t nbytes = safe_read(fd, buffer.get(), m_bufsize - 1,
report_errors);
INV(nbytes < m_bufsize);
buffer[nbytes] = '\0';
std::string line(accum);
size_t line_start = 0;
for (size_t i = 0; i < nbytes; i++) {
if (buffer[i] == '\n') {
line_callback(index, line);
line.clear();
accum.clear();
line_start = i + 1;
} else if (buffer[i] == '\r') {
// Do nothing.
} else {
line.append(1, buffer[i]);
}
}
accum.append(&buffer[line_start]);
return nbytes;
}
void
impl::muxer::mux(volatile const bool& terminate)
{
atf::utils::auto_array< struct pollfd > poll_fds(new struct pollfd[m_nfds]);
for (size_t i = 0; i < m_nfds; i++) {
poll_fds[i].fd = m_fds[i];
poll_fds[i].events = POLLIN;
}
size_t nactive = m_nfds;
while (nactive > 0 && !terminate) {
int ret;
while (!terminate && (ret = safe_poll(poll_fds.get(), 2, 250)) == 0) {}
for (size_t i = 0; !terminate && i < m_nfds; i++) {
if (poll_fds[i].events == 0)
continue;
if (poll_fds[i].revents & POLLHUP) {
// Any data still available at this point will be processed by
// a call to the flush method.
poll_fds[i].events = 0;
INV(nactive >= 1);
nactive--;
} else if (poll_fds[i].revents & (POLLIN | POLLRDNORM | POLLRDBAND |
POLLPRI)) {
(void)read_one(i, poll_fds[i].fd, m_buffers[i], true);
}
}
}
}
void
impl::muxer::flush(void)
{
for (size_t i = 0; i < m_nfds; i++) {
while (read_one(i, m_fds[i], m_buffers[i], false) > 0) {}
if (!m_buffers[i].empty())
line_callback(i, m_buffers[i]);
}
}
Reference in New Issue View Git Blame Copy Permalink