1 // 2 // connection.hpp 3 // ~~~~~~~~~~~~~~ 4 // 5 // Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) 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 11 #ifndef SERIALIZATION_CONNECTION_HPP 12 #define SERIALIZATION_CONNECTION_HPP 13 14 #include <boost/asio.hpp> 15 #include <boost/archive/text_iarchive.hpp> 16 #include <boost/archive/text_oarchive.hpp> 17 #include <boost/bind/bind.hpp> 18 #include <boost/shared_ptr.hpp> 19 #include <boost/tuple/tuple.hpp> 20 #include <iomanip> 21 #include <string> 22 #include <sstream> 23 #include <vector> 24 25 namespace s11n_example { 26 27 /// The connection class provides serialization primitives on top of a socket. 28 /** 29 * Each message sent using this class consists of: 30 * @li An 8-byte header containing the length of the serialized data in 31 * hexadecimal. 32 * @li The serialized data. 33 */ 34 class connection 35 { 36 public: 37 /// Constructor. connection(const boost::asio::executor & ex)38 connection(const boost::asio::executor& ex) 39 : socket_(ex) 40 { 41 } 42 43 /// Get the underlying socket. Used for making a connection or for accepting 44 /// an incoming connection. socket()45 boost::asio::ip::tcp::socket& socket() 46 { 47 return socket_; 48 } 49 50 /// Asynchronously write a data structure to the socket. 51 template <typename T, typename Handler> async_write(const T & t,Handler handler)52 void async_write(const T& t, Handler handler) 53 { 54 // Serialize the data first so we know how large it is. 55 std::ostringstream archive_stream; 56 boost::archive::text_oarchive archive(archive_stream); 57 archive << t; 58 outbound_data_ = archive_stream.str(); 59 60 // Format the header. 61 std::ostringstream header_stream; 62 header_stream << std::setw(header_length) 63 << std::hex << outbound_data_.size(); 64 if (!header_stream || header_stream.str().size() != header_length) 65 { 66 // Something went wrong, inform the caller. 67 boost::system::error_code error(boost::asio::error::invalid_argument); 68 boost::asio::post(socket_.get_executor(), boost::bind(handler, error)); 69 return; 70 } 71 outbound_header_ = header_stream.str(); 72 73 // Write the serialized data to the socket. We use "gather-write" to send 74 // both the header and the data in a single write operation. 75 std::vector<boost::asio::const_buffer> buffers; 76 buffers.push_back(boost::asio::buffer(outbound_header_)); 77 buffers.push_back(boost::asio::buffer(outbound_data_)); 78 boost::asio::async_write(socket_, buffers, handler); 79 } 80 81 /// Asynchronously read a data structure from the socket. 82 template <typename T, typename Handler> async_read(T & t,Handler handler)83 void async_read(T& t, Handler handler) 84 { 85 // Issue a read operation to read exactly the number of bytes in a header. 86 void (connection::*f)( 87 const boost::system::error_code&, 88 T&, boost::tuple<Handler>) 89 = &connection::handle_read_header<T, Handler>; 90 boost::asio::async_read(socket_, boost::asio::buffer(inbound_header_), 91 boost::bind(f, 92 this, boost::asio::placeholders::error, boost::ref(t), 93 boost::make_tuple(handler))); 94 } 95 96 /// Handle a completed read of a message header. The handler is passed using 97 /// a tuple since boost::bind seems to have trouble binding a function object 98 /// created using boost::bind as a parameter. 99 template <typename T, typename Handler> handle_read_header(const boost::system::error_code & e,T & t,boost::tuple<Handler> handler)100 void handle_read_header(const boost::system::error_code& e, 101 T& t, boost::tuple<Handler> handler) 102 { 103 if (e) 104 { 105 boost::get<0>(handler)(e); 106 } 107 else 108 { 109 // Determine the length of the serialized data. 110 std::istringstream is(std::string(inbound_header_, header_length)); 111 std::size_t inbound_data_size = 0; 112 if (!(is >> std::hex >> inbound_data_size)) 113 { 114 // Header doesn't seem to be valid. Inform the caller. 115 boost::system::error_code error(boost::asio::error::invalid_argument); 116 boost::get<0>(handler)(error); 117 return; 118 } 119 120 // Start an asynchronous call to receive the data. 121 inbound_data_.resize(inbound_data_size); 122 void (connection::*f)( 123 const boost::system::error_code&, 124 T&, boost::tuple<Handler>) 125 = &connection::handle_read_data<T, Handler>; 126 boost::asio::async_read(socket_, boost::asio::buffer(inbound_data_), 127 boost::bind(f, this, 128 boost::asio::placeholders::error, boost::ref(t), handler)); 129 } 130 } 131 132 /// Handle a completed read of message data. 133 template <typename T, typename Handler> handle_read_data(const boost::system::error_code & e,T & t,boost::tuple<Handler> handler)134 void handle_read_data(const boost::system::error_code& e, 135 T& t, boost::tuple<Handler> handler) 136 { 137 if (e) 138 { 139 boost::get<0>(handler)(e); 140 } 141 else 142 { 143 // Extract the data structure from the data just received. 144 try 145 { 146 std::string archive_data(&inbound_data_[0], inbound_data_.size()); 147 std::istringstream archive_stream(archive_data); 148 boost::archive::text_iarchive archive(archive_stream); 149 archive >> t; 150 } 151 catch (std::exception& e) 152 { 153 // Unable to decode data. 154 boost::system::error_code error(boost::asio::error::invalid_argument); 155 boost::get<0>(handler)(error); 156 return; 157 } 158 159 // Inform caller that data has been received ok. 160 boost::get<0>(handler)(e); 161 } 162 } 163 164 private: 165 /// The underlying socket. 166 boost::asio::ip::tcp::socket socket_; 167 168 /// The size of a fixed length header. 169 enum { header_length = 8 }; 170 171 /// Holds an outbound header. 172 std::string outbound_header_; 173 174 /// Holds the outbound data. 175 std::string outbound_data_; 176 177 /// Holds an inbound header. 178 char inbound_header_[header_length]; 179 180 /// Holds the inbound data. 181 std::vector<char> inbound_data_; 182 }; 183 184 typedef boost::shared_ptr<connection> connection_ptr; 185 186 } // namespace s11n_example 187 188 #endif // SERIALIZATION_CONNECTION_HPP 189