]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // connection.hpp | |
3 | // ~~~~~~~~~~~~~~ | |
4 | // | |
1e59de90 | 5 | // Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com) |
7c673cae FG |
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> | |
f67539c2 | 17 | #include <boost/bind/bind.hpp> |
7c673cae FG |
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. | |
92f5a8d4 TL |
38 | connection(const boost::asio::executor& ex) |
39 | : socket_(ex) | |
7c673cae FG |
40 | { |
41 | } | |
42 | ||
43 | /// Get the underlying socket. Used for making a connection or for accepting | |
44 | /// an incoming connection. | |
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> | |
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); | |
b32b8144 | 68 | boost::asio::post(socket_.get_executor(), boost::bind(handler, error)); |
7c673cae FG |
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> | |
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> | |
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> | |
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 |