WebSocket++  0.8.0-dev
C++ websocket client/server library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
endpoint.hpp
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_ENDPOINT_HPP
29 #define WEBSOCKETPP_ENDPOINT_HPP
30 
31 #include <websocketpp/connection.hpp>
32 
33 #include <websocketpp/logger/levels.hpp>
34 #include <websocketpp/version.hpp>
35 
36 #include <string>
37 
38 namespace websocketpp {
39 
40 /// Creates and manages connections associated with a WebSocket endpoint
41 template <typename connection, typename config>
42 class endpoint : public config::transport_type, public config::endpoint_base {
43 public:
44  // Import appropriate types from our helper class
45  // See endpoint_types for more details.
46  typedef endpoint<connection,config> type;
47 
48  /// Type of the transport component of this endpoint
49  typedef typename config::transport_type transport_type;
50  /// Type of the concurrency component of this endpoint
51  typedef typename config::concurrency_type concurrency_type;
52 
53  /// Type of the connections that this endpoint creates
54  typedef connection connection_type;
55  /// Shared pointer to connection_type
56  typedef typename connection_type::ptr connection_ptr;
57  /// Weak pointer to connection type
59 
60  /// Type of the transport component of the connections that this endpoint
61  /// creates
63  /// Type of a shared pointer to the transport component of the connections
64  /// that this endpoint creates.
66 
67  /// Type of message_handler
69  /// Type of message pointers that this endpoint uses
71 
72  /// Type of error logger
73  typedef typename config::elog_type elog_type;
74  /// Type of access logger
75  typedef typename config::alog_type alog_type;
76 
77  /// Type of our concurrency policy's scoped lock object
79  /// Type of our concurrency policy's mutex object
81 
82  /// Type of RNG
83  typedef typename config::rng_type rng_type;
84 
85  // TODO: organize these
86  typedef typename connection_type::termination_handler termination_handler;
87 
88  // This would be ideal. Requires C++11 though
89  //friend connection;
90 
91  explicit endpoint(bool p_is_server)
92  : m_alog(new alog_type(config::alog_level, log::channel_type_hint::access))
93  , m_elog(new elog_type(config::elog_level, log::channel_type_hint::error))
94  , m_user_agent(::websocketpp::user_agent)
95  , m_open_handshake_timeout_dur(config::timeout_open_handshake)
96  , m_close_handshake_timeout_dur(config::timeout_close_handshake)
97  , m_pong_timeout_dur(config::timeout_pong)
98  , m_max_message_size(config::max_message_size)
99  , m_max_http_body_size(config::max_http_body_size)
100  , m_is_server(p_is_server)
101  {
102  m_alog->set_channels(config::alog_level);
103  m_elog->set_channels(config::elog_level);
104 
105  m_alog->write(log::alevel::devel, "endpoint constructor");
106 
107  transport_type::init_logging(m_alog, m_elog);
108  }
109 
110 
111  /// Destructor
112  ~endpoint<connection,config>() {}
113 
114  #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
115  // no copy constructor because endpoints are not copyable
116  endpoint(endpoint &) = delete;
117 
118  // no copy assignment operator because endpoints are not copyable
119  endpoint & operator=(endpoint const &) = delete;
120  #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
121 
122  #ifdef _WEBSOCKETPP_MOVE_SEMANTICS_
123  /// Move constructor
124  endpoint(endpoint && o)
125  : config::transport_type(std::move(o))
126  , config::endpoint_base(std::move(o))
127  , m_alog(std::move(o.m_alog))
128  , m_elog(std::move(o.m_elog))
129  , m_user_agent(std::move(o.m_user_agent))
130  , m_open_handler(std::move(o.m_open_handler))
131 
132  , m_close_handler(std::move(o.m_close_handler))
133  , m_fail_handler(std::move(o.m_fail_handler))
134  , m_ping_handler(std::move(o.m_ping_handler))
135  , m_pong_handler(std::move(o.m_pong_handler))
136  , m_pong_timeout_handler(std::move(o.m_pong_timeout_handler))
137  , m_interrupt_handler(std::move(o.m_interrupt_handler))
138  , m_http_handler(std::move(o.m_http_handler))
139  , m_validate_handler(std::move(o.m_validate_handler))
140  , m_message_handler(std::move(o.m_message_handler))
141 
142  , m_open_handshake_timeout_dur(o.m_open_handshake_timeout_dur)
143  , m_close_handshake_timeout_dur(o.m_close_handshake_timeout_dur)
144  , m_pong_timeout_dur(o.m_pong_timeout_dur)
145  , m_max_message_size(o.m_max_message_size)
146  , m_max_http_body_size(o.m_max_http_body_size)
147 
148  , m_rng(std::move(o.m_rng))
149  , m_is_server(o.m_is_server)
150  {}
151 
152  #ifdef _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
153  // no move assignment operator because of const member variables
154  endpoint & operator=(endpoint &&) = delete;
155  #endif // _WEBSOCKETPP_DEFAULT_DELETE_FUNCTIONS_
156 
157  #endif // _WEBSOCKETPP_MOVE_SEMANTICS_
158 
159 
160  /// Returns the user agent string that this endpoint will use
161  /**
162  * Returns the user agent string that this endpoint will use when creating
163  * new connections.
164  *
165  * The default value for this version is stored in websocketpp::user_agent
166  *
167  * @return The user agent string.
168  */
169  std::string get_user_agent() const {
170  scoped_lock_type guard(m_mutex);
171  return m_user_agent;
172  }
173 
174  /// Sets the user agent string that this endpoint will use
175  /**
176  * Sets the identifier that this endpoint will use when creating new
177  * connections. Changing this value will only affect future connections.
178  * For client endpoints this will be sent as the "User-Agent" header in
179  * outgoing requests. For server endpoints this will be sent in the "Server"
180  * response header.
181  *
182  * Setting this value to the empty string will suppress the use of the
183  * Server and User-Agent headers. This is typically done to hide
184  * implementation details for security purposes.
185  *
186  * For best results set this before accepting or opening connections.
187  *
188  * The default value for this version is stored in websocketpp::user_agent
189  *
190  * This can be overridden on an individual connection basis by setting a
191  * custom "Server" header during the validate handler or "User-Agent"
192  * header on a connection before calling connect().
193  *
194  * @param ua The string to set the user agent to.
195  */
196  void set_user_agent(std::string const & ua) {
197  scoped_lock_type guard(m_mutex);
198  m_user_agent = ua;
199  }
200 
201  /// Returns whether or not this endpoint is a server.
202  /**
203  * @return Whether or not this endpoint is a server
204  */
205  bool is_server() const {
206  return m_is_server;
207  }
208 
209  /********************************/
210  /* Pass-through logging adaptor */
211  /********************************/
212 
213  /// Set Access logging channel
214  /**
215  * Set the access logger's channel value. The value is a number whose
216  * interpretation depends on the logging policy in use.
217  *
218  * @param channels The channel value(s) to set
219  */
220  void set_access_channels(log::level channels) {
221  m_alog->set_channels(channels);
222  }
223 
224  /// Clear Access logging channels
225  /**
226  * Clear the access logger's channel value. The value is a number whose
227  * interpretation depends on the logging policy in use.
228  *
229  * @param channels The channel value(s) to clear
230  */
231  void clear_access_channels(log::level channels) {
232  m_alog->clear_channels(channels);
233  }
234 
235  /// Set Error logging channel
236  /**
237  * Set the error logger's channel value. The value is a number whose
238  * interpretation depends on the logging policy in use.
239  *
240  * @param channels The channel value(s) to set
241  */
242  void set_error_channels(log::level channels) {
243  m_elog->set_channels(channels);
244  }
245 
246  /// Clear Error logging channels
247  /**
248  * Clear the error logger's channel value. The value is a number whose
249  * interpretation depends on the logging policy in use.
250  *
251  * @param channels The channel value(s) to clear
252  */
253  void clear_error_channels(log::level channels) {
254  m_elog->clear_channels(channels);
255  }
256 
257  /// Get reference to access logger
258  /**
259  * @return A reference to the access logger
260  */
262  return *m_alog;
263  }
264 
265  /// Get reference to error logger
266  /**
267  * @return A reference to the error logger
268  */
270  return *m_elog;
271  }
272 
273  /*************************/
274  /* Set Handler functions */
275  /*************************/
276 
277  void set_open_handler(open_handler h) {
278  m_alog->write(log::alevel::devel,"set_open_handler");
279  scoped_lock_type guard(m_mutex);
280  m_open_handler = h;
281  }
282  void set_close_handler(close_handler h) {
283  m_alog->write(log::alevel::devel,"set_close_handler");
284  scoped_lock_type guard(m_mutex);
285  m_close_handler = h;
286  }
287  void set_fail_handler(fail_handler h) {
288  m_alog->write(log::alevel::devel,"set_fail_handler");
289  scoped_lock_type guard(m_mutex);
290  m_fail_handler = h;
291  }
292  void set_ping_handler(ping_handler h) {
293  m_alog->write(log::alevel::devel,"set_ping_handler");
294  scoped_lock_type guard(m_mutex);
295  m_ping_handler = h;
296  }
297  void set_pong_handler(pong_handler h) {
298  m_alog->write(log::alevel::devel,"set_pong_handler");
299  scoped_lock_type guard(m_mutex);
300  m_pong_handler = h;
301  }
302  void set_pong_timeout_handler(pong_timeout_handler h) {
303  m_alog->write(log::alevel::devel,"set_pong_timeout_handler");
304  scoped_lock_type guard(m_mutex);
305  m_pong_timeout_handler = h;
306  }
307  void set_interrupt_handler(interrupt_handler h) {
308  m_alog->write(log::alevel::devel,"set_interrupt_handler");
309  scoped_lock_type guard(m_mutex);
310  m_interrupt_handler = h;
311  }
312  void set_http_handler(http_handler h) {
313  m_alog->write(log::alevel::devel,"set_http_handler");
314  scoped_lock_type guard(m_mutex);
315  m_http_handler = h;
316  }
317  void set_validate_handler(validate_handler h) {
318  m_alog->write(log::alevel::devel,"set_validate_handler");
319  scoped_lock_type guard(m_mutex);
320  m_validate_handler = h;
321  }
322  void set_message_handler(message_handler h) {
323  m_alog->write(log::alevel::devel,"set_message_handler");
324  scoped_lock_type guard(m_mutex);
325  m_message_handler = h;
326  }
327 
328  //////////////////////////////////////////
329  // Connection timeouts and other limits //
330  //////////////////////////////////////////
331 
332  /// Set open handshake timeout
333  /**
334  * Sets the length of time the library will wait after an opening handshake
335  * has been initiated before cancelling it. This can be used to prevent
336  * excessive wait times for outgoing clients or excessive resource usage
337  * from broken clients or DoS attacks on servers.
338  *
339  * Connections that time out will have their fail handlers called with the
340  * open_handshake_timeout error code.
341  *
342  * The default value is specified via the compile time config value
343  * 'timeout_open_handshake'. The default value in the core config
344  * is 5000ms. A value of 0 will disable the timer entirely.
345  *
346  * To be effective, the transport you are using must support timers. See
347  * the documentation for your transport policy for details about its
348  * timer support.
349  *
350  * @param dur The length of the open handshake timeout in ms
351  */
352  void set_open_handshake_timeout(long dur) {
353  scoped_lock_type guard(m_mutex);
354  m_open_handshake_timeout_dur = dur;
355  }
356 
357  /// Set close handshake timeout
358  /**
359  * Sets the length of time the library will wait after a closing handshake
360  * has been initiated before cancelling it. This can be used to prevent
361  * excessive wait times for outgoing clients or excessive resource usage
362  * from broken clients or DoS attacks on servers.
363  *
364  * Connections that time out will have their close handlers called with the
365  * close_handshake_timeout error code.
366  *
367  * The default value is specified via the compile time config value
368  * 'timeout_close_handshake'. The default value in the core config
369  * is 5000ms. A value of 0 will disable the timer entirely.
370  *
371  * To be effective, the transport you are using must support timers. See
372  * the documentation for your transport policy for details about its
373  * timer support.
374  *
375  * @param dur The length of the close handshake timeout in ms
376  */
378  scoped_lock_type guard(m_mutex);
379  m_close_handshake_timeout_dur = dur;
380  }
381 
382  /// Set pong timeout
383  /**
384  * Sets the length of time the library will wait for a pong response to a
385  * ping. This can be used as a keepalive or to detect broken connections.
386  *
387  * Pong responses that time out will have the pong timeout handler called.
388  *
389  * The default value is specified via the compile time config value
390  * 'timeout_pong'. The default value in the core config
391  * is 5000ms. A value of 0 will disable the timer entirely.
392  *
393  * To be effective, the transport you are using must support timers. See
394  * the documentation for your transport policy for details about its
395  * timer support.
396  *
397  * @param dur The length of the pong timeout in ms
398  */
399  void set_pong_timeout(long dur) {
400  scoped_lock_type guard(m_mutex);
401  m_pong_timeout_dur = dur;
402  }
403 
404  /// Get default maximum message size
405  /**
406  * Get the default maximum message size that will be used for new
407  * connections created by this endpoint. The maximum message size determines
408  * the point at which the connection will fail a connection with the
409  * message_too_big protocol error.
410  *
411  * The default is set by the max_message_size value from the template config
412  *
413  * @since 0.3.0
414  */
415  size_t get_max_message_size() const {
416  return m_max_message_size;
417  }
418 
419  /// Set default maximum message size
420  /**
421  * Set the default maximum message size that will be used for new
422  * connections created by this endpoint. Maximum message size determines the
423  * point at which the connection will fail a connection with the
424  * message_too_big protocol error.
425  *
426  * The default is set by the max_message_size value from the template config
427  *
428  * @since 0.3.0
429  *
430  * @param new_value The value to set as the maximum message size.
431  */
432  void set_max_message_size(size_t new_value) {
433  m_max_message_size = new_value;
434  }
435 
436  /// Get maximum HTTP message body size
437  /**
438  * Get maximum HTTP message body size. Maximum message body size determines
439  * the point at which the connection will stop reading an HTTP request whose
440  * body is too large.
441  *
442  * The default is set by the max_http_body_size value from the template
443  * config
444  *
445  * @since 0.5.0
446  *
447  * @return The maximum HTTP message body size
448  */
449  size_t get_max_http_body_size() const {
450  return m_max_http_body_size;
451  }
452 
453  /// Set maximum HTTP message body size
454  /**
455  * Set maximum HTTP message body size. Maximum message body size determines
456  * the point at which the connection will stop reading an HTTP request whose
457  * body is too large.
458  *
459  * The default is set by the max_http_body_size value from the template
460  * config
461  *
462  * @since 0.5.1
463  *
464  * @param new_value The value to set as the maximum message size.
465  */
466  void set_max_http_body_size(size_t new_value) {
467  m_max_http_body_size = new_value;
468  }
469 
470  /*************************************/
471  /* Connection pass through functions */
472  /*************************************/
473 
474  /**
475  * These functions act as adaptors to their counterparts in connection. They
476  * can produce one additional type of error, the bad_connection error, that
477  * indicates that the conversion from connection_hdl to connection_ptr
478  * failed due to the connection not existing anymore. Each method has a
479  * default and an exception free varient.
480  */
481 
482  void interrupt(connection_hdl hdl, lib::error_code & ec);
483  void interrupt(connection_hdl hdl);
484 
485  /// Pause reading of new data (exception free)
486  /**
487  * Signals to the connection to halt reading of new data. While reading is
488  * paused, the connection will stop reading from its associated socket. In
489  * turn this will result in TCP based flow control kicking in and slowing
490  * data flow from the remote endpoint.
491  *
492  * This is useful for applications that push new requests to a queue to be
493  * processed by another thread and need a way to signal when their request
494  * queue is full without blocking the network processing thread.
495  *
496  * Use `resume_reading()` to resume.
497  *
498  * If supported by the transport this is done asynchronously. As such
499  * reading may not stop until the current read operation completes.
500  * Typically you can expect to receive no more bytes after initiating a read
501  * pause than the size of the read buffer.
502  *
503  * If reading is paused for this connection already nothing is changed.
504  */
505  void pause_reading(connection_hdl hdl, lib::error_code & ec);
506 
507  /// Pause reading of new data
508  void pause_reading(connection_hdl hdl);
509 
510  /// Resume reading of new data (exception free)
511  /**
512  * Signals to the connection to resume reading of new data after it was
513  * paused by `pause_reading()`.
514  *
515  * If reading is not paused for this connection already nothing is changed.
516  */
517  void resume_reading(connection_hdl hdl, lib::error_code & ec);
518 
519  /// Resume reading of new data
520  void resume_reading(connection_hdl hdl);
521 
522  /// Send deferred HTTP Response
523  /**
524  * Sends an http response to an HTTP connection that was deferred. This will
525  * send a complete response including all headers, status line, and body
526  * text. The connection will be closed afterwards.
527  *
528  * Exception free variant
529  *
530  * @since 0.6.0
531  *
532  * @param hdl The connection to send the response on
533  * @param ec A status code, zero on success, non-zero otherwise
534  */
535  void send_http_response(connection_hdl hdl, lib::error_code & ec);
536 
537  /// Send deferred HTTP Response (exception free)
538  /**
539  * Sends an http response to an HTTP connection that was deferred. This will
540  * send a complete response including all headers, status line, and body
541  * text. The connection will be closed afterwards.
542  *
543  * Exception variant
544  *
545  * @since 0.6.0
546  *
547  * @param hdl The connection to send the response on
548  */
549  void send_http_response(connection_hdl hdl);
550 
551  /// Create a message and add it to the outgoing send queue (exception free)
552  /**
553  * Convenience method to send a message given a payload string and an opcode
554  *
555  * @param [in] hdl The handle identifying the connection to send via.
556  * @param [in] payload The payload string to generated the message with
557  * @param [in] op The opcode to generated the message with.
558  * @param [out] ec A code to fill in for errors
559  */
560  void send(connection_hdl hdl, std::string const & payload,
561  frame::opcode::value op, lib::error_code & ec);
562  /// Create a message and add it to the outgoing send queue
563  /**
564  * Convenience method to send a message given a payload string and an opcode
565  *
566  * @param [in] hdl The handle identifying the connection to send via.
567  * @param [in] payload The payload string to generated the message with
568  * @param [in] op The opcode to generated the message with.
569  * @param [out] ec A code to fill in for errors
570  */
571  void send(connection_hdl hdl, std::string const & payload,
572  frame::opcode::value op);
573 
574  void send(connection_hdl hdl, void const * payload, size_t len,
575  frame::opcode::value op, lib::error_code & ec);
576  void send(connection_hdl hdl, void const * payload, size_t len,
577  frame::opcode::value op);
578 
579  void send(connection_hdl hdl, message_ptr msg, lib::error_code & ec);
580  void send(connection_hdl hdl, message_ptr msg);
581 
582  void close(connection_hdl hdl, close::status::value const code,
583  std::string const & reason, lib::error_code & ec);
584  void close(connection_hdl hdl, close::status::value const code,
585  std::string const & reason);
586 
587  /// Send a ping to a specific connection
588  /**
589  * @since 0.3.0-alpha3
590  *
591  * @param [in] hdl The connection_hdl of the connection to send to.
592  * @param [in] payload The payload string to send.
593  * @param [out] ec A reference to an error code to fill in
594  */
595  void ping(connection_hdl hdl, std::string const & payload,
596  lib::error_code & ec);
597  /// Send a ping to a specific connection
598  /**
599  * Exception variant of `ping`
600  *
601  * @since 0.3.0-alpha3
602  *
603  * @param [in] hdl The connection_hdl of the connection to send to.
604  * @param [in] payload The payload string to send.
605  */
606  void ping(connection_hdl hdl, std::string const & payload);
607 
608  /// Send a pong to a specific connection
609  /**
610  * @since 0.3.0-alpha3
611  *
612  * @param [in] hdl The connection_hdl of the connection to send to.
613  * @param [in] payload The payload string to send.
614  * @param [out] ec A reference to an error code to fill in
615  */
616  void pong(connection_hdl hdl, std::string const & payload,
617  lib::error_code & ec);
618  /// Send a pong to a specific connection
619  /**
620  * Exception variant of `pong`
621  *
622  * @since 0.3.0-alpha3
623  *
624  * @param [in] hdl The connection_hdl of the connection to send to.
625  * @param [in] payload The payload string to send.
626  */
627  void pong(connection_hdl hdl, std::string const & payload);
628 
629  /// Retrieves a connection_ptr from a connection_hdl (exception free)
630  /**
631  * Converting a weak pointer to shared_ptr is not thread safe because the
632  * pointer could be deleted at any time.
633  *
634  * NOTE: This method may be called by handler to upgrade its handle to a
635  * full connection_ptr. That full connection may then be used safely for the
636  * remainder of the handler body. get_con_from_hdl and the resulting
637  * connection_ptr are NOT safe to use outside the handler loop.
638  *
639  * @param hdl The connection handle to translate
640  *
641  * @return the connection_ptr. May be NULL if the handle was invalid.
642  */
643  connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code & ec) {
644  connection_ptr con = lib::static_pointer_cast<connection_type>(
645  hdl.lock());
646  if (!con) {
647  ec = error::make_error_code(error::bad_connection);
648  }
649  return con;
650  }
651 
652  /// Retrieves a connection_ptr from a connection_hdl (exception version)
653  connection_ptr get_con_from_hdl(connection_hdl hdl) {
654  lib::error_code ec;
655  connection_ptr con = this->get_con_from_hdl(hdl,ec);
656  if (ec) {
657  throw exception(ec);
658  }
659  return con;
660  }
661 protected:
662  connection_ptr create_connection();
663 
664  lib::shared_ptr<alog_type> m_alog;
665  lib::shared_ptr<elog_type> m_elog;
666 private:
667  // dynamic settings
668  std::string m_user_agent;
669 
670  open_handler m_open_handler;
671  close_handler m_close_handler;
672  fail_handler m_fail_handler;
673  ping_handler m_ping_handler;
674  pong_handler m_pong_handler;
675  pong_timeout_handler m_pong_timeout_handler;
676  interrupt_handler m_interrupt_handler;
677  http_handler m_http_handler;
678  validate_handler m_validate_handler;
679  message_handler m_message_handler;
680 
681  long m_open_handshake_timeout_dur;
682  long m_close_handshake_timeout_dur;
683  long m_pong_timeout_dur;
684  size_t m_max_message_size;
685  size_t m_max_http_body_size;
686 
687  rng_type m_rng;
688 
689  // static settings
690  bool const m_is_server;
691 
692  // endpoint state
693  mutable mutex_type m_mutex;
694 };
695 
696 } // namespace websocketpp
697 
698 #include <websocketpp/impl/endpoint_impl.hpp>
699 
700 #endif // WEBSOCKETPP_ENDPOINT_HPP
void send_http_response(connection_hdl hdl, lib::error_code &ec)
Send deferred HTTP Response.
config::concurrency_type concurrency_type
Type of the concurrency component of this endpoint.
Definition: endpoint.hpp:51
void send_http_response(connection_hdl hdl)
Send deferred HTTP Response (exception free)
size_t get_max_message_size() const
Get default maximum message size.
Definition: endpoint.hpp:415
bool is_server() const
Returns whether or not this endpoint is a server.
Definition: endpoint.hpp:205
void ping(connection_hdl hdl, std::string const &payload, lib::error_code &ec)
Send a ping to a specific connection.
config::rng_type rng_type
Type of RNG.
Definition: endpoint.hpp:83
void send(connection_hdl hdl, std::string const &payload, frame::opcode::value op)
Create a message and add it to the outgoing send queue.
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition: endpoint.hpp:377
connection_type::message_ptr message_ptr
Type of message pointers that this endpoint uses.
Definition: endpoint.hpp:70
void interrupt(connection_hdl hdl, lib::error_code &ec)
connection_type::message_handler message_handler
Type of message_handler.
Definition: endpoint.hpp:68
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition: endpoint.hpp:352
transport_con_type::ptr transport_con_ptr
Definition: endpoint.hpp:65
alog_type & get_alog()
Get reference to access logger.
Definition: endpoint.hpp:261
void pong(connection_hdl hdl, std::string const &payload)
Send a pong to a specific connection.
connection_ptr get_con_from_hdl(connection_hdl hdl, lib::error_code &ec)
Retrieves a connection_ptr from a connection_hdl (exception free)
Definition: endpoint.hpp:643
concurrency_type::scoped_lock_type scoped_lock_type
Type of our concurrency policy's scoped lock object.
Definition: endpoint.hpp:78
void pause_reading(connection_hdl hdl, lib::error_code &ec)
Pause reading of new data (exception free)
std::string get_user_agent() const
Returns the user agent string that this endpoint will use.
Definition: endpoint.hpp:169
concurrency_type::mutex_type mutex_type
Type of our concurrency policy's mutex object.
Definition: endpoint.hpp:80
void resume_reading(connection_hdl hdl, lib::error_code &ec)
Resume reading of new data (exception free)
void pause_reading(connection_hdl hdl)
Pause reading of new data.
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition: endpoint.hpp:466
void set_max_message_size(size_t new_value)
Set default maximum message size.
Definition: endpoint.hpp:432
transport_type::transport_con_type transport_con_type
Definition: endpoint.hpp:62
config::alog_type alog_type
Type of access logger.
Definition: endpoint.hpp:75
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition: endpoint.hpp:449
config::transport_type transport_type
Type of the transport component of this endpoint.
Definition: endpoint.hpp:49
connection_type::ptr connection_ptr
Shared pointer to connection_type.
Definition: endpoint.hpp:56
void pong(connection_hdl hdl, std::string const &payload, lib::error_code &ec)
Send a pong to a specific connection.
void clear_error_channels(log::level channels)
Clear Error logging channels.
Definition: endpoint.hpp:253
void set_access_channels(log::level channels)
Set Access logging channel.
Definition: endpoint.hpp:220
elog_type & get_elog()
Get reference to error logger.
Definition: endpoint.hpp:269
config::elog_type elog_type
Type of error logger.
Definition: endpoint.hpp:73
void resume_reading(connection_hdl hdl)
Resume reading of new data.
connection_type::weak_ptr connection_weak_ptr
Weak pointer to connection type.
Definition: endpoint.hpp:58
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
void ping(connection_hdl hdl, std::string const &payload)
Send a ping to a specific connection.
connection connection_type
Type of the connections that this endpoint creates.
Definition: endpoint.hpp:54
void clear_access_channels(log::level channels)
Clear Access logging channels.
Definition: endpoint.hpp:231
void set_error_channels(log::level channels)
Set Error logging channel.
Definition: endpoint.hpp:242
void set_pong_timeout(long dur)
Set pong timeout.
Definition: endpoint.hpp:399
connection_ptr get_con_from_hdl(connection_hdl hdl)
Retrieves a connection_ptr from a connection_hdl (exception version)
Definition: endpoint.hpp:653
void set_user_agent(std::string const &ua)
Sets the user agent string that this endpoint will use.
Definition: endpoint.hpp:196
void send(connection_hdl hdl, std::string const &payload, frame::opcode::value op, lib::error_code &ec)
Create a message and add it to the outgoing send queue (exception free)