SockBuffer.hpp

   1 #ifndef SOCKBUFFER_DOT_HPP
   2 #define SOCKBUFFER_DOT_HPP
   3
   4 #include <cerrno>
   5 #include <chrono>
   6 #include <cstdlib>
   7 #include <streambuf>
   8 #include <string>
   9
  10 #include "POSIX.hpp"
  11 #include "TLS-OpenSSL.hpp"
  12
  13 // We must define this to account for args to Sockbuffer ctor.
  14 #define BOOST_IOSTREAMS_MAX_FORWARDING_ARITY 6
  15
  16 #include <boost/iostreams/concepts.hpp>
  17 #include <boost/iostreams/stream.hpp>
  18
  19 namespace Config {
  20 constexpr std::chrono::seconds default_read_timeout{2};
  21 constexpr std::chrono::seconds default_write_timeout{2};
  22 constexpr std::chrono::seconds default_starttls_timeout{2};
  23 } // namespace Config
  24
  25 class SockBuffer
  26   : public boost::iostreams::device<boost::iostreams::bidirectional> {
  27 public:
  28   SockBuffer(
  29       int                       fd_in,
  30       int                       fd_out,
  31       std::function<void(void)> read_hook     = []() {},
  32       std::chrono::milliseconds read_timeout  = Config::default_read_timeout,
  33       std::chrono::milliseconds write_timeout = Config::default_write_timeout,
  34       std::chrono::milliseconds starttls_timeout
  35       = Config::default_starttls_timeout);
  36
  37   SockBuffer& operator=(const SockBuffer&) = delete;
  38   SockBuffer(SockBuffer const& that);
  39
  40   bool input_ready(std::chrono::milliseconds wait) const
  41   {
  42     return (tls_active_ && tls_.pending()) || POSIX::input_ready(fd_in_, wait);
  43   }
  44   bool output_ready(std::chrono::milliseconds wait) const
  45   {
  46     return POSIX::output_ready(fd_out_, wait);
  47   }
  48   bool maxed_out() const
  49   {
  50     return limit_read_ && (octets_read_ >= read_limit_);
  51   }
  52   bool timed_out() const { return timed_out_; }
  53
  54   std::streamsize read(char* s, std::streamsize n);
  55   std::streamsize write(const char* s, std::streamsize n);
  56
  57   bool starttls_server(fs::path config_path)
  58   {
  59     return tls_active_ = tls_.starttls_server(config_path, fd_in_, fd_out_,
  60                                               starttls_timeout_);
  61   }
  62   bool starttls_client(fs::path                  config_path,
  63                        char const*               client_name,
  64                        char const*               server_name,
  65                        DNS::RR_collection const& tlsa_rrs,
  66                        bool                      enforce_dane)
  67   {
  68     return tls_active_ = tls_.starttls_client(
  69                config_path, fd_in_, fd_out_, client_name, server_name, tlsa_rrs,
  70                enforce_dane, starttls_timeout_);
  71   }
  72   bool        tls() const { return tls_active_; }
  73   std::string tls_info() const { return tls() ? tls_.info() : ""; }
  74   bool        verified() const { return tls_.verified(); };
  75
  76   void set_max_read(std::streamsize max)
  77   {
  78     limit_read_     = true;
  79     read_limit_     = max;
  80     octets_read_    = 0;
  81     octets_written_ = 0;
  82   }
  83
  84   void log_stats() const;
  85   void log_totals() const;
  86
  87   void close_fds()
  88   {
  89     if (fd_in_ != fd_out_)
  90       ::close(fd_in_);
  91     ::close(fd_out_);
  92     fd_in_ = fd_out_ = -1;
  93   }
  94
  95 private:
  96   int fd_in_;
  97   int fd_out_;
  98
  99   std::streamsize read_limit_{0};
 100   std::streamsize octets_read_{0};
 101   std::streamsize octets_written_{0};
 102   std::streamsize total_octets_read_{0};
 103   std::streamsize total_octets_written_{0};
 104
 105   std::function<void(void)> read_hook_;
 106
 107   std::chrono::milliseconds read_timeout_;
 108   std::chrono::milliseconds write_timeout_;
 109   std::chrono::milliseconds starttls_timeout_;
 110
 111   bool timed_out_{false};
 112   bool tls_active_{false};
 113   bool limit_read_{false};
 114   bool log_data_{false};
 115
 116   TLS tls_;
 117 };
 118
 119 #endif // SOCKBUFFER_DOT_HPP