external/bsd/atf/dist/atf-c++/detail/process.cpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2008 The NetBSD Foundation, Inc.
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 // 1. Redistributions of source code must retain the above copyright
  11 //    notice, this list of conditions and the following disclaimer.
  12 // 2. Redistributions in binary form must reproduce the above copyright
  13 //    notice, this list of conditions and the following disclaimer in the
  14 //    documentation and/or other materials provided with the distribution.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 //
  29
  30 extern "C" {
  31 #include <signal.h>
  32
  33 #include "../../atf-c/error.h"
  34
  35 #include "../../atf-c/detail/process.h"
  36 }
  37
  38 #include <iostream>
  39
  40 #include "exceptions.hpp"
  41 #include "process.hpp"
  42 #include "sanity.hpp"
  43
  44 namespace detail = atf::process::detail;
  45 namespace impl = atf::process;
  46 #define IMPL_NAME "atf::process"
  47
  48 // ------------------------------------------------------------------------
  49 // Auxiliary functions.
  50 // ------------------------------------------------------------------------
  51
  52 template< class C >
  53 atf::auto_array< const char* >
  54 collection_to_argv(const C& c)
  55 {
  56     atf::auto_array< const char* > argv(new const char*[c.size() + 1]);
  57
  58     std::size_t pos = 0;
  59     for (typename C::const_iterator iter = c.begin(); iter != c.end();
  60          iter++) {
  61         argv[pos] = (*iter).c_str();
  62         pos++;
  63     }
  64     INV(pos == c.size());
  65     argv[pos] = NULL;
  66
  67     return argv;
  68 }
  69
  70 template< class C >
  71 C
  72 argv_to_collection(const char* const* argv)
  73 {
  74     C c;
  75
  76     for (const char* const* iter = argv; *iter != NULL; iter++)
  77         c.push_back(std::string(*iter));
  78
  79     return c;
  80 }
  81
  82 // ------------------------------------------------------------------------
  83 // The "argv_array" type.
  84 // ------------------------------------------------------------------------
  85
  86 impl::argv_array::argv_array(void) :
  87     m_exec_argv(collection_to_argv(m_args))
  88 {
  89 }
  90
  91 impl::argv_array::argv_array(const char* arg1, ...)
  92 {
  93     m_args.push_back(arg1);
  94
  95     {
  96         va_list ap;
  97         const char* nextarg;
  98
  99         va_start(ap, arg1);
 100         while ((nextarg = va_arg(ap, const char*)) != NULL)
 101             m_args.push_back(nextarg);
 102         va_end(ap);
 103     }
 104
 105     ctor_init_exec_argv();
 106 }
 107
 108 impl::argv_array::argv_array(const char* const* ca) :
 109     m_args(argv_to_collection< args_vector >(ca)),
 110     m_exec_argv(collection_to_argv(m_args))
 111 {
 112 }
 113
 114 impl::argv_array::argv_array(const argv_array& a) :
 115     m_args(a.m_args),
 116     m_exec_argv(collection_to_argv(m_args))
 117 {
 118 }
 119
 120 void
 121 impl::argv_array::ctor_init_exec_argv(void)
 122 {
 123     m_exec_argv = collection_to_argv(m_args);
 124 }
 125
 126 const char* const*
 127 impl::argv_array::exec_argv(void)
 128     const
 129 {
 130     return m_exec_argv.get();
 131 }
 132
 133 impl::argv_array::size_type
 134 impl::argv_array::size(void)
 135     const
 136 {
 137     return m_args.size();
 138 }
 139
 140 const char*
 141 impl::argv_array::operator[](int idx)
 142     const
 143 {
 144     return m_args[idx].c_str();
 145 }
 146
 147 impl::argv_array::const_iterator
 148 impl::argv_array::begin(void)
 149     const
 150 {
 151     return m_args.begin();
 152 }
 153
 154 impl::argv_array::const_iterator
 155 impl::argv_array::end(void)
 156     const
 157 {
 158     return m_args.end();
 159 }
 160
 161 impl::argv_array&
 162 impl::argv_array::operator=(const argv_array& a)
 163 {
 164     if (this != &a) {
 165         m_args = a.m_args;
 166         m_exec_argv = collection_to_argv(m_args);
 167     }
 168     return *this;
 169 }
 170
 171 // ------------------------------------------------------------------------
 172 // The "stream" types.
 173 // ------------------------------------------------------------------------
 174
 175 impl::basic_stream::basic_stream(void) :
 176     m_inited(false)
 177 {
 178 }
 179
 180 impl::basic_stream::~basic_stream(void)
 181 {
 182     if (m_inited)
 183         atf_process_stream_fini(&m_sb);
 184 }
 185
 186 const atf_process_stream_t*
 187 impl::basic_stream::get_sb(void)
 188     const
 189 {
 190     INV(m_inited);
 191     return &m_sb;
 192 }
 193
 194 impl::stream_capture::stream_capture(void)
 195 {
 196     atf_error_t err = atf_process_stream_init_capture(&m_sb);
 197     if (atf_is_error(err))
 198         throw_atf_error(err);
 199     m_inited = true;
 200 }
 201
 202 impl::stream_connect::stream_connect(const int src_fd, const int tgt_fd)
 203 {
 204     atf_error_t err = atf_process_stream_init_connect(&m_sb, src_fd, tgt_fd);
 205     if (atf_is_error(err))
 206         throw_atf_error(err);
 207     m_inited = true;
 208 }
 209
 210 impl::stream_inherit::stream_inherit(void)
 211 {
 212     atf_error_t err = atf_process_stream_init_inherit(&m_sb);
 213     if (atf_is_error(err))
 214         throw_atf_error(err);
 215     m_inited = true;
 216 }
 217
 218 impl::stream_redirect_fd::stream_redirect_fd(const int fd)
 219 {
 220     atf_error_t err = atf_process_stream_init_redirect_fd(&m_sb, fd);
 221     if (atf_is_error(err))
 222         throw_atf_error(err);
 223     m_inited = true;
 224 }
 225
 226 impl::stream_redirect_path::stream_redirect_path(const fs::path& p)
 227 {
 228     atf_error_t err = atf_process_stream_init_redirect_path(&m_sb, p.c_path());
 229     if (atf_is_error(err))
 230         throw_atf_error(err);
 231     m_inited = true;
 232 }
 233
 234 // ------------------------------------------------------------------------
 235 // The "status" type.
 236 // ------------------------------------------------------------------------
 237
 238 impl::status::status(atf_process_status_t& s) :
 239     m_status(s)
 240 {
 241 }
 242
 243 impl::status::~status(void)
 244 {
 245     atf_process_status_fini(&m_status);
 246 }
 247
 248 bool
 249 impl::status::exited(void)
 250     const
 251 {
 252     return atf_process_status_exited(&m_status);
 253 }
 254
 255 int
 256 impl::status::exitstatus(void)
 257     const
 258 {
 259     return atf_process_status_exitstatus(&m_status);
 260 }
 261
 262 bool
 263 impl::status::signaled(void)
 264     const
 265 {
 266     return atf_process_status_signaled(&m_status);
 267 }
 268
 269 int
 270 impl::status::termsig(void)
 271     const
 272 {
 273     return atf_process_status_termsig(&m_status);
 274 }
 275
 276 bool
 277 impl::status::coredump(void)
 278     const
 279 {
 280     return atf_process_status_coredump(&m_status);
 281 }
 282
 283 // ------------------------------------------------------------------------
 284 // The "child" type.
 285 // ------------------------------------------------------------------------
 286
 287 impl::child::child(atf_process_child_t& c) :
 288     m_child(c),
 289     m_waited(false)
 290 {
 291 }
 292
 293 impl::child::~child(void)
 294 {
 295     if (!m_waited) {
 296         ::kill(atf_process_child_pid(&m_child), SIGTERM);
 297
 298         atf_process_status_t s;
 299 #if defined(__minix) && !defined(NDEBUG)
 300         atf_error_t err =
 301 #endif /* defined(__minix) && !defined(NDEBUG) */
 302         atf_process_child_wait(&m_child, &s);
 303         INV(!atf_is_error(err));
 304         atf_process_status_fini(&s);
 305     }
 306 }
 307
 308 impl::status
 309 impl::child::wait(void)
 310 {
 311     atf_process_status_t s;
 312
 313     atf_error_t err = atf_process_child_wait(&m_child, &s);
 314     if (atf_is_error(err))
 315         throw_atf_error(err);
 316
 317     m_waited = true;
 318     return status(s);
 319 }
 320
 321 pid_t
 322 impl::child::pid(void)
 323     const
 324 {
 325     return atf_process_child_pid(&m_child);
 326 }
 327
 328 int
 329 impl::child::stdout_fd(void)
 330 {
 331     return atf_process_child_stdout(&m_child);
 332 }
 333
 334 int
 335 impl::child::stderr_fd(void)
 336 {
 337     return atf_process_child_stderr(&m_child);
 338 }
 339
 340 // ------------------------------------------------------------------------
 341 // Free functions.
 342 // ------------------------------------------------------------------------
 343
 344 void
 345 detail::flush_streams(void)
 346 {
 347     // This is a weird hack to ensure that the output of the parent process
 348     // is flushed before executing a child which prevents, for example, the
 349     // output of the atf-run hooks to appear before the output of atf-run
 350     // itself.
 351     //
 352     // TODO: This should only be executed when inheriting the stdout or
 353     // stderr file descriptors.  However, the flushing is specific to the
 354     // iostreams, so we cannot do it from the C library where all the process
 355     // logic is performed.  Come up with a better design.
 356     std::cout.flush();
 357     std::cerr.flush();
 358 }