NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.3: NDN, CCN, CCNx, content centric networks
API Documentation
connection.hpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014, Peter Thorson. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are met:
6  * * Redistributions of source code must retain the above copyright
7  * notice, this list of conditions and the following disclaimer.
8  * * Redistributions in binary form must reproduce the above copyright
9  * notice, this list of conditions and the following disclaimer in the
10  * documentation and/or other materials provided with the distribution.
11  * * Neither the name of the WebSocket++ Project nor the
12  * names of its contributors may be used to endorse or promote products
13  * derived from this software without specific prior written permission.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  */
27 
28 #ifndef WEBSOCKETPP_CONNECTION_HPP
29 #define WEBSOCKETPP_CONNECTION_HPP
30 
31 #include <websocketpp/close.hpp>
32 #include <websocketpp/error.hpp>
33 #include <websocketpp/frame.hpp>
34 
39 
43 
44 #include <queue>
45 #include <sstream>
46 #include <string>
47 #include <vector>
48 
49 namespace websocketpp {
50 
52 
59 typedef lib::function<void(connection_hdl)> open_handler;
60 
62 
69 typedef lib::function<void(connection_hdl)> close_handler;
70 
72 
79 typedef lib::function<void(connection_hdl)> fail_handler;
80 
82 
91 typedef lib::function<void(connection_hdl)> interrupt_handler;
92 
94 
101 typedef lib::function<bool(connection_hdl,std::string)> ping_handler;
102 
104 
109 typedef lib::function<void(connection_hdl,std::string)> pong_handler;
110 
112 
116 typedef lib::function<void(connection_hdl,std::string)> pong_timeout_handler;
117 
119 
129 typedef lib::function<bool(connection_hdl)> validate_handler;
130 
132 
151 typedef lib::function<void(connection_hdl)> http_handler;
152 
153 //
154 typedef lib::function<void(lib::error_code const & ec, size_t bytes_transferred)> read_handler;
155 typedef lib::function<void(lib::error_code const & ec)> write_frame_handler;
156 
157 // constants related to the default WebSocket protocol versions available
158 #ifdef _WEBSOCKETPP_INITIALIZER_LISTS_ // simplified C++11 version
159 
164  static std::vector<int> const versions_supported = {0,7,8,13};
165 #else
166  static int const helper[] = {0,7,8,13};
169 
173  static std::vector<int> const versions_supported(helper,helper+4);
174 #endif
175 
176 namespace session {
177 namespace state {
178  // externally visible session state (states based on the RFC)
179  enum value {
181  open = 1,
182  closing = 2,
183  closed = 3
184  };
185 } // namespace state
186 
187 
188 namespace fail {
189 namespace status {
190  enum value {
191  GOOD = 0, // no failure yet!
192  SYSTEM = 1, // system call returned error, check that code
193  WEBSOCKET = 2, // websocket close codes contain error
194  UNKNOWN = 3, // No failure information is available
195  TIMEOUT_TLS = 4, // TLS handshake timed out
196  TIMEOUT_WS = 5 // WS handshake timed out
197  };
198 } // namespace status
199 } // namespace fail
200 
201 namespace internal_state {
202  // More granular internal states. These are used for multi-threaded
203  // connection synchronization and preventing values that are not yet or no
204  // longer available from being used.
205 
206  enum value {
215  };
216 } // namespace internal_state
217 
218 
219 namespace http_state {
220  // states to keep track of the progress of http connections
221 
222  enum value {
223  init = 0,
224  deferred = 1,
227  closed = 4
228  };
229 } // namespace http_state
230 
231 } // namespace session
232 
234 template <typename config>
237  , public config::connection_base
238 {
239 public:
243  typedef lib::shared_ptr<type> ptr;
245  typedef lib::weak_ptr<type> weak_ptr;
246 
250  typedef typename config::alog_type alog_type;
252  typedef typename config::elog_type elog_type;
253 
258  typedef typename transport_con_type::ptr transport_con_ptr;
259 
260  typedef lib::function<void(ptr)> termination_handler;
261 
262  typedef typename concurrency_type::scoped_lock_type scoped_lock_type;
263  typedef typename concurrency_type::mutex_type mutex_type;
264 
267 
269  typedef typename message_type::ptr message_ptr;
270 
272  typedef typename con_msg_manager_type::ptr con_msg_manager_ptr;
273 
275  typedef typename config::rng_type rng_type;
276 
278  typedef lib::shared_ptr<processor_type> processor_ptr;
279 
280  // Message handler (needs to know message type)
281  typedef lib::function<void(connection_hdl,message_ptr)> message_handler;
282 
284  typedef typename transport_con_type::timer_ptr timer_ptr;
285 
286  // Misc Convenience Types
288 
289 private:
290  enum terminate_status {
291  failed = 1,
292  closed,
293  unknown
294  };
295 public:
296 
297  explicit connection(bool p_is_server, std::string const & ua, alog_type& alog,
298  elog_type& elog, rng_type & rng)
299  : transport_con_type(p_is_server, alog, elog)
300  , m_handle_read_frame(lib::bind(
301  &type::handle_read_frame,
302  this,
303  lib::placeholders::_1,
304  lib::placeholders::_2
305  ))
306  , m_write_frame_handler(lib::bind(
307  &type::handle_write_frame,
308  this,
309  lib::placeholders::_1
310  ))
311  , m_user_agent(ua)
312  , m_open_handshake_timeout_dur(config::timeout_open_handshake)
313  , m_close_handshake_timeout_dur(config::timeout_close_handshake)
314  , m_pong_timeout_dur(config::timeout_pong)
315  , m_max_message_size(config::max_message_size)
316  , m_state(session::state::connecting)
317  , m_internal_state(session::internal_state::USER_INIT)
318  , m_msg_manager(new con_msg_manager_type())
319  , m_send_buffer_size(0)
320  , m_write_flag(false)
321  , m_read_flag(true)
322  , m_is_server(p_is_server)
323  , m_alog(alog)
324  , m_elog(elog)
325  , m_rng(rng)
326  , m_local_close_code(close::status::abnormal_close)
327  , m_remote_close_code(close::status::abnormal_close)
328  , m_is_http(false)
329  , m_http_state(session::http_state::init)
330  , m_was_clean(false)
331  {
332  m_alog.write(log::alevel::devel,"connection constructor");
333  }
334 
336  ptr get_shared() {
337  return lib::static_pointer_cast<type>(transport_con_type::get_shared());
338  }
339 
341  // Set Handler Callbacks //
343 
345 
351  void set_open_handler(open_handler h) {
352  m_open_handler = h;
353  }
354 
356 
361  void set_close_handler(close_handler h) {
362  m_close_handler = h;
363  }
364 
366 
372  void set_fail_handler(fail_handler h) {
373  m_fail_handler = h;
374  }
375 
377 
387  void set_ping_handler(ping_handler h) {
388  m_ping_handler = h;
389  }
390 
392 
398  void set_pong_handler(pong_handler h) {
399  m_pong_handler = h;
400  }
401 
403 
421  void set_pong_timeout_handler(pong_timeout_handler h) {
422  m_pong_timeout_handler = h;
423  }
424 
426 
432  void set_interrupt_handler(interrupt_handler h) {
433  m_interrupt_handler = h;
434  }
435 
437 
447  void set_http_handler(http_handler h) {
448  m_http_handler = h;
449  }
450 
452 
463  void set_validate_handler(validate_handler h) {
464  m_validate_handler = h;
465  }
466 
468 
473  void set_message_handler(message_handler h) {
474  m_message_handler = h;
475  }
476 
478  // Connection timeouts and other limits //
480 
482 
501  void set_open_handshake_timeout(long dur) {
502  m_open_handshake_timeout_dur = dur;
503  }
504 
506 
526  m_close_handshake_timeout_dur = dur;
527  }
528 
530 
546  void set_pong_timeout(long dur) {
547  m_pong_timeout_dur = dur;
548  }
549 
551 
559  size_t get_max_message_size() const {
560  return m_max_message_size;
561  }
562 
564 
575  void set_max_message_size(size_t new_value) {
576  m_max_message_size = new_value;
577  if (m_processor) {
578  m_processor->set_max_message_size(new_value);
579  }
580  }
581 
583 
594  size_t get_max_http_body_size() const {
595  return m_request.get_max_body_size();
596  }
597 
599 
610  void set_max_http_body_size(size_t new_value) {
611  m_request.set_max_body_size(new_value);
612  }
613 
615  // Uncategorized public methods //
617 
619 
629  size_t get_buffered_amount() const;
630 
632 
635  size_t buffered_amount() const {
636  return get_buffered_amount();
637  }
638 
640  // Action Methods //
642 
644 
655  lib::error_code send(std::string const & payload, frame::opcode::value op =
657 
659 
672  lib::error_code send(void const * payload, size_t len, frame::opcode::value
673  op = frame::opcode::binary);
674 
676 
688  lib::error_code send(message_ptr msg);
689 
691 
703  lib::error_code interrupt();
704 
706  void handle_interrupt();
707 
709 
728  lib::error_code pause_reading();
729 
731  void handle_pause_reading();
732 
734 
740  lib::error_code resume_reading();
741 
743  void handle_resume_reading();
744 
746 
757  void ping(std::string const & payload);
758 
760  void ping(std::string const & payload, lib::error_code & ec);
761 
763  void handle_pong_timeout(std::string payload, lib::error_code const & ec);
764 
766 
775  void pong(std::string const & payload);
776 
778  void pong(std::string const & payload, lib::error_code & ec);
779 
781 
800  void close(close::status::value const code, std::string const & reason);
801 
803  void close(close::status::value const code, std::string const & reason,
804  lib::error_code & ec);
805 
807  // Pass-through access to the uri information //
809 
811 
817  bool get_secure() const;
818 
820 
826  std::string const & get_host() const;
827 
829 
835  std::string const & get_resource() const;
836 
838 
844  uint16_t get_port() const;
845 
847 
853  uri_ptr get_uri() const;
854 
856 
862  void set_uri(uri_ptr uri);
863 
865  // Subprotocol negotiation //
867 
869 
875  std::string const & get_subprotocol() const;
876 
878 
884  std::vector<std::string> const & get_requested_subprotocols() const;
885 
887 
899  void add_subprotocol(std::string const & request, lib::error_code & ec);
900 
902 
912  void add_subprotocol(std::string const & request);
913 
915 
927  void select_subprotocol(std::string const & value, lib::error_code & ec);
928 
930 
940  void select_subprotocol(std::string const & value);
941 
943  // Pass-through access to the request and response objects //
945 
947 
953  std::string const & get_request_header(std::string const & key) const;
954 
956 
964  std::string const & get_request_body() const;
965 
967 
973  std::string const & get_response_header(std::string const & key) const;
974 
976 
984  return m_response.get_status_code();
985  }
986 
988 
995  std::string const & get_response_msg() const {
996  return m_response.get_status_msg();
997  }
998 
1000 
1013  void set_status(http::status_code::value code);
1014 
1016 
1028  void set_status(http::status_code::value code, std::string const & msg);
1029 
1031 
1043  void set_body(std::string const & value);
1044 
1046 
1059  void append_header(std::string const & key, std::string const & val);
1060 
1062 
1074  void replace_header(std::string const & key, std::string const & val);
1075 
1077 
1086  void remove_header(std::string const & key);
1087 
1089 
1102  request_type const & get_request() const {
1103  return m_request;
1104  }
1105 
1107 
1121  response_type const & get_response() const {
1122  return m_response;
1123  }
1124 
1126 
1138  lib::error_code defer_http_response();
1139 
1141 
1150  void send_http_response(lib::error_code & ec);
1151 
1153  void send_http_response();
1154 
1155  // TODO HTTPNBIO: write_headers
1156  // function that processes headers + status so far and writes it to the wire
1157  // beginning the HTTP response body state. This method will ignore anything
1158  // in the response body.
1159 
1160  // TODO HTTPNBIO: write_body_message
1161  // queues the specified message_buffer for async writing
1162 
1163  // TODO HTTPNBIO: finish connection
1164  //
1165 
1166  // TODO HTTPNBIO: write_response
1167  // Writes the whole response, headers + body and closes the connection
1168 
1169 
1170 
1172  // Pass-through access to the other connection information //
1174 
1176 
1184  return m_connection_hdl;
1185  }
1186 
1188 
1191  bool is_server() const {
1192  return m_is_server;
1193  }
1194 
1196 
1202  std::string const & get_origin() const;
1203 
1205 
1210  session::state::value get_state() const;
1211 
1212 
1214 
1218  return m_local_close_code;
1219  }
1220 
1222 
1225  std::string const & get_local_close_reason() const {
1226  return m_local_close_reason;
1227  }
1228 
1230 
1234  return m_remote_close_code;
1235  }
1236 
1238 
1241  std::string const & get_remote_close_reason() const {
1242  return m_remote_close_reason;
1243  }
1244 
1246 
1254  lib::error_code get_ec() const {
1255  return m_ec;
1256  }
1257 
1259 
1277  message_ptr get_message(websocketpp::frame::opcode::value op, size_t size)
1278  const
1279  {
1280  return m_msg_manager->get_message(op, size);
1281  }
1282 
1284  // The remaining public member functions are for internal/policy use //
1285  // only. Do not call from application code unless you understand what //
1286  // you are doing. //
1288 
1289 
1290 
1291  void read_handshake(size_t num_bytes);
1292 
1293  void handle_read_handshake(lib::error_code const & ec,
1294  size_t bytes_transferred);
1295  void handle_read_http_response(lib::error_code const & ec,
1296  size_t bytes_transferred);
1297 
1298 
1299  void handle_write_http_response(lib::error_code const & ec);
1300  void handle_send_http_request(lib::error_code const & ec);
1301 
1302  void handle_open_handshake_timeout(lib::error_code const & ec);
1303  void handle_close_handshake_timeout(lib::error_code const & ec);
1304 
1305  void handle_read_frame(lib::error_code const & ec, size_t bytes_transferred);
1306  void read_frame();
1307 
1309  std::vector<int> const & get_supported_versions() const;
1310 
1313  void set_termination_handler(termination_handler new_handler);
1314 
1315  void terminate(lib::error_code const & ec);
1316  void handle_terminate(terminate_status tstat, lib::error_code const & ec);
1317 
1319 
1324  void write_frame();
1325 
1327 
1338  void handle_write_frame(lib::error_code const & ec);
1339 // protected:
1340  // This set of methods would really like to be protected, but doing so
1341  // requires that the endpoint be able to friend the connection. This is
1342  // allowed with C++11, but not prior versions
1343 
1345  void start();
1346 
1348 
1357  m_connection_hdl = hdl;
1358  transport_con_type::set_handle(hdl);
1359  }
1360 protected:
1361  void handle_transport_init(lib::error_code const & ec);
1362 
1365  lib::error_code initialize_processor();
1366 
1369  lib::error_code process_handshake_request();
1370 private:
1371 
1372 
1374  void write_http_response(lib::error_code const & ec);
1375 
1377  void send_http_request();
1378 
1380  void write_http_response_error(lib::error_code const & ec);
1381 
1383 
1386  void process_control_frame(message_ptr msg);
1387 
1389 
1399  lib::error_code send_close_ack(close::status::value code =
1400  close::status::blank, std::string const & reason = std::string());
1401 
1403 
1417  lib::error_code send_close_frame(close::status::value code =
1418  close::status::blank, std::string const & reason = std::string(), bool ack = false,
1419  bool terminal = false);
1420 
1422 
1431  processor_ptr get_processor(int version) const;
1432 
1434 
1443  void write_push(message_ptr msg);
1444 
1446 
1456  message_ptr write_pop();
1457 
1459 
1464  void log_open_result();
1465 
1467 
1470  void log_close_result();
1471 
1473 
1476  void log_fail_result();
1477 
1479 
1482  void log_http_result();
1483 
1485  template <typename error_type>
1486  void log_err(log::level l, char const * msg, error_type const & ec) {
1487  std::stringstream s;
1488  s << msg << " error: " << ec << " (" << ec.message() << ")";
1489  m_elog.write(l, s.str());
1490  }
1491 
1492  // internal handler functions
1493  read_handler m_handle_read_frame;
1494  write_frame_handler m_write_frame_handler;
1495 
1496  // static settings
1497  std::string const m_user_agent;
1498 
1500  connection_hdl m_connection_hdl;
1501 
1503  open_handler m_open_handler;
1504  close_handler m_close_handler;
1505  fail_handler m_fail_handler;
1506  ping_handler m_ping_handler;
1507  pong_handler m_pong_handler;
1508  pong_timeout_handler m_pong_timeout_handler;
1509  interrupt_handler m_interrupt_handler;
1510  http_handler m_http_handler;
1511  validate_handler m_validate_handler;
1512  message_handler m_message_handler;
1513 
1515  long m_open_handshake_timeout_dur;
1516  long m_close_handshake_timeout_dur;
1517  long m_pong_timeout_dur;
1518  size_t m_max_message_size;
1519 
1521 
1524  session::state::value m_state;
1525 
1527 
1530  istate_type m_internal_state;
1531 
1532  mutable mutex_type m_connection_state_lock;
1533 
1535 
1539  mutex_type m_write_lock;
1540 
1541  // connection resources
1543  size_t m_buf_cursor;
1544  termination_handler m_termination_handler;
1545  con_msg_manager_ptr m_msg_manager;
1546  timer_ptr m_handshake_timer;
1547  timer_ptr m_ping_timer;
1548 
1551  std::string m_handshake_buffer;
1552 
1554 
1562  processor_ptr m_processor;
1563 
1565 
1568  std::queue<message_ptr> m_send_queue;
1569 
1571 
1574  size_t m_send_buffer_size;
1575 
1577 
1580  std::vector<transport::buffer> m_send_buffer;
1581 
1584  std::vector<message_ptr> m_current_msgs;
1585 
1587 
1590  bool m_write_flag;
1591 
1593  bool m_read_flag;
1594 
1595  // connection data
1596  request_type m_request;
1597  response_type m_response;
1598  uri_ptr m_uri;
1599  std::string m_subprotocol;
1600 
1601  // connection data that might not be necessary to keep around for the life
1602  // of the whole connection.
1603  std::vector<std::string> m_requested_subprotocols;
1604 
1605  bool const m_is_server;
1606  alog_type& m_alog;
1607  elog_type& m_elog;
1608 
1609  rng_type & m_rng;
1610 
1611  // Close state
1613  close::status::value m_local_close_code;
1614 
1616  std::string m_local_close_reason;
1617 
1619  close::status::value m_remote_close_code;
1620 
1622  std::string m_remote_close_reason;
1623 
1625  lib::error_code m_ec;
1626 
1629  bool m_is_http;
1630 
1633  session::http_state::value m_http_state;
1634 
1635  bool m_was_clean;
1636 
1638  bool m_closed_by_me;
1639 
1641  bool m_failed_by_me;
1642 
1644  bool m_dropped_by_me;
1645 };
1646 
1647 } // namespace websocketpp
1648 
1650 
1651 #endif // WEBSOCKETPP_CONNECTION_HPP
std::string const & get_remote_close_reason() const
Get the WebSocket close reason sent by the remote endpoint.
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition: connection.hpp:501
connection_hdl get_handle() const
Get Connection Handle.
void set_pong_timeout(long dur)
Set pong timeout.
Definition: connection.hpp:546
ptr get_shared()
Get a shared pointer to this component.
Definition: connection.hpp:336
uint16_t value
The type of a close code value.
Definition: close.hpp:49
message_ptr get_message(websocketpp::frame::opcode::value op, size_t size) const
Get a message buffer.
bool terminal(value code)
Determine if the code represents an unrecoverable error.
Definition: close.hpp:212
lib::function< void(connection_hdl)> close_handler
The type and function signature of a close handler.
Definition: connection.hpp:69
config::con_msg_manager_type con_msg_manager_type
Definition: connection.hpp:271
config::request_type request_type
Definition: connection.hpp:265
lib::function< void(connection_hdl)> open_handler
The type and function signature of an open handler.
Definition: connection.hpp:59
close::status::value get_local_close_code() const
Get the WebSocket close code sent by this endpoint.
lib::function< void(connection_hdl, std::string)> pong_timeout_handler
The type and function signature of a pong timeout handler.
Definition: connection.hpp:116
std::string const & get_local_close_reason() const
Get the WebSocket close reason sent by this endpoint.
lib::function< void(ptr)> termination_handler
Definition: connection.hpp:260
static std::vector< int > const versions_supported(helper, helper+4)
Container that stores the list of protocol versions supported.
lib::function< void(connection_hdl)> interrupt_handler
The type and function signature of an interrupt handler.
Definition: connection.hpp:91
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the transport component of this connection.
Definition: connection.hpp:258
asio::connection< config > transport_con_type
Type of the connection transport component associated with this endpoint transport component...
Definition: endpoint.hpp:74
void set_open_handler(open_handler h)
Set open handler.
Definition: connection.hpp:351
WebSocket protocol processor abstract base class.
Definition: processor.hpp:160
lib::function< bool(connection_hdl, std::string)> ping_handler
The type and function signature of a ping handler.
Definition: connection.hpp:101
lib::weak_ptr< type > weak_ptr
Type of a weak pointer to this connection.
Definition: connection.hpp:245
lib::function< void(lib::error_code const &ec)> write_frame_handler
Definition: connection.hpp:155
Represents an individual WebSocket connection.
Definition: connection.hpp:235
void set_fail_handler(fail_handler h)
Set fail handler.
Definition: connection.hpp:372
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
void set_http_handler(http_handler h)
Set http handler.
Definition: connection.hpp:447
lib::function< void(lib::error_code const &ec, size_t bytes_transferred)> read_handler
Definition: connection.hpp:154
void set_close_handler(close_handler h)
Set close handler.
Definition: connection.hpp:361
lib::error_code get_ec() const
Get the internal error code for a closed/failed connection.
lib::function< void(connection_hdl, message_ptr)> message_handler
Definition: connection.hpp:281
A package of types and methods for manipulating WebSocket close codes.
config::alog_type alog_type
Type of the access logging policy.
Definition: connection.hpp:250
processor::processor< config > processor_type
Definition: connection.hpp:277
Stores, parses, and manipulates HTTP responses.
Definition: response.hpp:57
static level const devel
Development messages (warning: very chatty)
Definition: levels.hpp:141
lib::function< bool(connection_hdl)> validate_handler
The type and function signature of a validate handler.
Definition: connection.hpp:129
close::status::value get_remote_close_code() const
Get the WebSocket close code sent by the remote endpoint.
message_type::ptr message_ptr
Definition: connection.hpp:269
void set_pong_handler(pong_handler h)
Set pong handler.
Definition: connection.hpp:398
connection< config > type
Type of this connection.
Definition: connection.hpp:241
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition: connection.hpp:525
bool is_server() const
Get whether or not this connection is part of a server or client.
void set_handle(connection_hdl hdl)
Set Connection Handle.
config::concurrency_type concurrency_type
Type of the concurrency component of this connection.
Definition: connection.hpp:248
config::rng_type rng_type
Type of RNG.
Definition: connection.hpp:275
config::transport_type::transport_con_type transport_con_type
Type of the transport component of this connection.
Definition: connection.hpp:256
config::response_type response_type
Definition: connection.hpp:266
lib::function< void(connection_hdl)> http_handler
The type and function signature of a http handler.
Definition: connection.hpp:151
void set_ping_handler(ping_handler h)
Set ping handler.
Definition: connection.hpp:387
Thread safe stub "random" integer generator.
Definition: none.hpp:46
std::string const & get_response_msg() const
Get response HTTP status message.
Definition: connection.hpp:995
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition: connection.hpp:610
Namespace for the WebSocket++ project.
Definition: base64.hpp:41
void set_max_message_size(size_t new_value)
Set maximum message size.
Definition: connection.hpp:575
Represents a buffer for a single WebSocket message.
Definition: message.hpp:84
concurrency_type::mutex_type mutex_type
Definition: connection.hpp:263
Stub concurrency policy that implements the interface using no-ops.
Definition: none.hpp:60
void close(T *e, websocketpp::connection_hdl hdl)
void set_pong_timeout_handler(pong_timeout_handler h)
Set pong timeout handler.
Definition: connection.hpp:421
lib::shared_ptr< processor_type > processor_ptr
Definition: connection.hpp:278
void set_interrupt_handler(interrupt_handler h)
Set interrupt handler.
Definition: connection.hpp:432
request_type const & get_request() const
Get request object.
static int const helper[]
Helper array to get around lack of initializer lists pre C++11.
Definition: connection.hpp:167
static const size_t connection_read_buffer_size
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition: uri.hpp:351
connection(bool p_is_server, std::string const &ua, alog_type &alog, elog_type &elog, rng_type &rng)
Definition: connection.hpp:297
websocketpp::connection_base connection_base
User overridable Connection base class.
void set_validate_handler(validate_handler h)
Set validate handler.
Definition: connection.hpp:463
session::internal_state::value istate_type
Definition: connection.hpp:287
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection.
Definition: connection.hpp:243
size_t get_max_message_size() const
Get maximum message size.
Definition: connection.hpp:559
void set_message_handler(message_handler h)
Set message handler.
Definition: connection.hpp:473
response_type const & get_response() const
Get response object.
Stores, parses, and manipulates HTTP requests.
Definition: request.hpp:50
static value const abnormal_close
A dummy value to indicate that the connection was closed abnormally.
Definition: close.hpp:104
size_t buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes)
Definition: connection.hpp:635
lib::function< void(connection_hdl, std::string)> pong_handler
The type and function signature of a pong handler.
Definition: connection.hpp:109
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition: connection.hpp:594
uint32_t level
Type of a channel package.
Definition: levels.hpp:37
concurrency_type::scoped_lock_type scoped_lock_type
Definition: connection.hpp:262
A connection message manager that allocates a new message for each request.
Definition: alloc.hpp:41
transport_con_type::timer_ptr timer_ptr
Type of a pointer to a transport timer handle.
Definition: connection.hpp:284
config::message_type message_type
Definition: connection.hpp:268
con_msg_manager_type::ptr con_msg_manager_ptr
Definition: connection.hpp:272
Stub logger that ignores all input.
Definition: stub.hpp:41
lib::function< void(connection_hdl)> fail_handler
The type and function signature of a fail handler.
Definition: connection.hpp:79
config::elog_type elog_type
Type of the error logging policy.
Definition: connection.hpp:252
http::status_code::value get_response_code() const
Get response HTTP status code.
Definition: connection.hpp:983
static value const blank
A blank value for internal use.
Definition: close.hpp:52