ceph/src/boost/boost/process/detail/posix/basic_pipe.hpp

   1 // Copyright (c) 2006, 2007 Julio M. Merino Vidal
   2 // Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
   3 // Copyright (c) 2009 Boris Schaeling
   4 // Copyright (c) 2010 Felipe Tanus, Boris Schaeling
   5 // Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #ifndef BOOST_PROCESS_POSIX_PIPE_HPP
  11 #define BOOST_PROCESS_POSIX_PIPE_HPP
  12
  13
  14 #include <boost/filesystem.hpp>
  15 #include <boost/process/detail/posix/compare_handles.hpp>
  16 #include <system_error>
  17 #include <array>
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <memory>
  21
  22 namespace boost { namespace process { namespace detail { namespace posix {
  23
  24
  25 template<class CharT, class Traits = std::char_traits<CharT>>
  26 class basic_pipe
  27 {
  28     int _source = -1;
  29     int _sink   = -1;
  30 public:
  31     explicit basic_pipe(int source, int sink) : _source(source), _sink(sink) {}
  32     explicit basic_pipe(int source, int sink, const std::string&) : _source(source), _sink(sink) {}
  33     typedef CharT                      char_type  ;
  34     typedef          Traits            traits_type;
  35     typedef typename Traits::int_type  int_type   ;
  36     typedef typename Traits::pos_type  pos_type   ;
  37     typedef typename Traits::off_type  off_type   ;
  38     typedef          int               native_handle_type;
  39
  40     basic_pipe()
  41     {
  42         int fds[2];
  43         if (::pipe(fds) == -1)
  44             boost::process::detail::throw_last_error("pipe(2) failed");
  45
  46         _source = fds[0];
  47         _sink   = fds[1];
  48     }
  49     inline basic_pipe(const basic_pipe& rhs);
  50     explicit inline basic_pipe(const std::string& name);
  51     basic_pipe(basic_pipe&& lhs)  : _source(lhs._source), _sink(lhs._sink)
  52     {
  53         lhs._source = -1;
  54         lhs._sink   = -1;
  55     }
  56     inline basic_pipe& operator=(const basic_pipe& );
  57     basic_pipe& operator=(basic_pipe&& lhs)
  58     {
  59         _source = lhs._source;
  60         _sink   = lhs._sink ;
  61
  62         lhs._source = -1;
  63         lhs._sink   = -1;
  64
  65         return *this;
  66     }
  67     ~basic_pipe()
  68     {
  69         if (_sink   != -1)
  70             ::close(_sink);
  71         if (_source != -1)
  72             ::close(_source);
  73     }
  74     native_handle_type native_source() const {return _source;}
  75     native_handle_type native_sink  () const {return _sink;}
  76
  77     void assign_source(native_handle_type h) { _source = h;}
  78     void assign_sink  (native_handle_type h) { _sink = h;}
  79
  80
  81
  82
  83     int_type write(const char_type * data, int_type count)
  84     {
  85         auto write_len = ::write(_sink, data, count * sizeof(char_type));
  86         if (write_len == -1)
  87             ::boost::process::detail::throw_last_error();
  88
  89         return write_len;
  90     }
  91     int_type read(char_type * data, int_type count)
  92     {
  93         auto read_len = ::read(_source, data, count * sizeof(char_type));
  94         if (read_len == -1)
  95             ::boost::process::detail::throw_last_error();
  96
  97         return read_len;
  98     }
  99
 100     bool is_open()
 101     {
 102         return (_source != -1) ||
 103                (_sink   != -1);
 104     }
 105
 106     void close()
 107     {
 108         if (_source != -1)
 109             ::close(_source);
 110         if (_sink != -1)
 111             ::close(_sink);
 112         _source = -1;
 113         _sink   = -1;
 114     }
 115 };
 116
 117 template<class CharT, class Traits>
 118 basic_pipe<CharT, Traits>::basic_pipe(const basic_pipe & rhs)
 119 {
 120        if (rhs._source != -1)
 121        {
 122            _source = ::dup(rhs._source);
 123            if (_source == -1)
 124                ::boost::process::detail::throw_last_error("dup() failed");
 125        }
 126     if (rhs._sink != -1)
 127     {
 128         _sink = ::dup(rhs._sink);
 129         if (_sink == -1)
 130             ::boost::process::detail::throw_last_error("dup() failed");
 131
 132     }
 133 }
 134
 135 template<class CharT, class Traits>
 136 basic_pipe<CharT, Traits> &basic_pipe<CharT, Traits>::operator=(const basic_pipe & rhs)
 137 {
 138        if (rhs._source != -1)
 139        {
 140            _source = ::dup(rhs._source);
 141            if (_source == -1)
 142                ::boost::process::detail::throw_last_error("dup() failed");
 143        }
 144     if (rhs._sink != -1)
 145     {
 146         _sink = ::dup(rhs._sink);
 147         if (_sink == -1)
 148             ::boost::process::detail::throw_last_error("dup() failed");
 149
 150     }
 151     return *this;
 152 }
 153
 154
 155 template<class CharT, class Traits>
 156 basic_pipe<CharT, Traits>::basic_pipe(const std::string & name)
 157 {
 158     auto fifo = mkfifo(name.c_str(), 0666 );
 159
 160     if (fifo != 0)
 161         boost::process::detail::throw_last_error("mkfifo() failed");
 162
 163
 164     int  read_fd = open(name.c_str(), O_RDWR);
 165
 166     if (read_fd == -1)
 167         boost::process::detail::throw_last_error();
 168
 169     int write_fd = dup(read_fd);
 170
 171     if (write_fd == -1)
 172         boost::process::detail::throw_last_error();
 173
 174     _sink = write_fd;
 175     _source = read_fd;
 176     ::unlink(name.c_str());
 177 }
 178
 179 template<class Char, class Traits>
 180 inline bool operator==(const basic_pipe<Char, Traits> & lhs, const basic_pipe<Char, Traits> & rhs)
 181 {
 182     return compare_handles(lhs.native_source(), rhs.native_source()) &&
 183            compare_handles(lhs.native_sink(),   rhs.native_sink());
 184 }
 185
 186 template<class Char, class Traits>
 187 inline bool operator!=(const basic_pipe<Char, Traits> & lhs, const basic_pipe<Char, Traits> & rhs)
 188 {
 189     return !compare_handles(lhs.native_source(), rhs.native_source()) ||
 190            !compare_handles(lhs.native_sink(),   rhs.native_sink());
 191 }
 192
 193 }}}}
 194
 195 #endif