WebSocket++  0.8.0-dev
C++ websocket client/server library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
connection.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_TRANSPORT_BASE_CON_HPP
29 #define WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
30 
31 #include <websocketpp/common/cpp11.hpp>
32 #include <websocketpp/common/connection_hdl.hpp>
33 #include <websocketpp/common/functional.hpp>
34 #include <websocketpp/common/system_error.hpp>
35 
36 #include <string>
37 
38 namespace websocketpp {
39 /// Transport policies provide network connectivity and timers
40 /**
41  * ### Connection Interface
42  *
43  * Transport connection components needs to provide:
44  *
45  * **init**\n
46  * `void init(init_handler handler)`\n
47  * Called once shortly after construction to give the policy the chance to
48  * perform one time initialization. When complete, the policy must call the
49  * supplied `init_handler` to continue setup. The handler takes one argument
50  * with the error code if any. If an error is returned here setup will fail and
51  * the connection will be aborted or terminated.
52  *
53  * WebSocket++ will call init only once. The transport must call `handler`
54  * exactly once.
55  *
56  * **async_read_at_least**\n
57  * `void async_read_at_least(size_t num_bytes, char *buf, size_t len,
58  * read_handler handler)`\n
59  * start an async read for at least num_bytes and at most len
60  * bytes into buf. Call handler when done with number of bytes read.
61  *
62  * WebSocket++ promises to have only one async_read_at_least in flight at a
63  * time. The transport must promise to only call read_handler once per async
64  * read.
65  *
66  * **async_write**\n
67  * `void async_write(const char* buf, size_t len, write_handler handler)`\n
68  * `void async_write(std::vector<buffer> & bufs, write_handler handler)`\n
69  * Start a write of all of the data in buf or bufs. In second case data is
70  * written sequentially and in place without copying anything to a temporary
71  * location.
72  *
73  * Websocket++ promises to have only one async_write in flight at a time.
74  * The transport must promise to only call the write_handler once per async
75  * write
76  *
77  * **set_handle**\n
78  * `void set_handle(connection_hdl hdl)`\n
79  * Called by WebSocket++ to let this policy know the hdl to the connection. It
80  * may be stored for later use or ignored/discarded. This handle should be used
81  * if the policy adds any connection handlers. Connection handlers must be
82  * called with the handle as the first argument so that the handler code knows
83  * which connection generated the callback.
84  *
85  * **set_timer**\n
86  * `timer_ptr set_timer(long duration, timer_handler handler)`\n
87  * WebSocket++ uses the timers provided by the transport policy as the
88  * implementation of timers is often highly coupled with the implementation of
89  * the networking event loops.
90  *
91  * Transport timer support is an optional feature. A transport method may elect
92  * to implement a dummy timer object and have this method return an empty
93  * pointer. If so, all timer related features of WebSocket++ core will be
94  * disabled. This includes many security features designed to prevent denial of
95  * service attacks. Use timer-free transport policies with caution.
96  *
97  * **get_remote_endpoint**\n
98  * `std::string get_remote_endpoint()`\n
99  * retrieve address of remote endpoint
100  *
101  * **is_secure**\n
102  * `void is_secure()`\n
103  * whether or not the connection to the remote endpoint is secure
104  *
105  * **dispatch**\n
106  * `lib::error_code dispatch(dispatch_handler handler)`: invoke handler within
107  * the transport's event system if it uses one. Otherwise, this method should
108  * simply call `handler` immediately.
109  *
110  * **async_shutdown**\n
111  * `void async_shutdown(shutdown_handler handler)`\n
112  * Perform any cleanup necessary (if any). Call `handler` when complete.
113  */
114 namespace transport {
115 
116 /// The type and signature of the callback passed to the init hook
117 typedef lib::function<void(lib::error_code const &)> init_handler;
118 
119 /// The type and signature of the callback passed to the read method
120 typedef lib::function<void(lib::error_code const &,size_t)> read_handler;
121 
122 /// The type and signature of the callback passed to the write method
123 typedef lib::function<void(lib::error_code const &)> write_handler;
124 
125 /// The type and signature of the callback passed to the read method
126 typedef lib::function<void(lib::error_code const &)> timer_handler;
127 
128 /// The type and signature of the callback passed to the shutdown method
129 typedef lib::function<void(lib::error_code const &)> shutdown_handler;
130 
131 /// The type and signature of the callback passed to the interrupt method
132 typedef lib::function<void()> interrupt_handler;
133 
134 /// The type and signature of the callback passed to the dispatch method
135 typedef lib::function<void()> dispatch_handler;
136 
137 /// A simple utility buffer class
138 struct buffer {
139  buffer(char const * b, size_t l) : buf(b),len(l) {}
140 
141  char const * buf;
142  size_t len;
143 };
144 
145 /// Generic transport related errors
146 namespace error {
147 enum value {
148  /// Catch-all error for transport policy errors that don't fit in other
149  /// categories
150  general = 1,
151 
152  /// underlying transport pass through
154 
155  /// async_read_at_least call requested more bytes than buffer can store
157 
158  /// async_read called while another async_read was in progress
160 
161  /// Operation aborted
163 
164  /// Operation not supported
166 
167  /// End of file
169 
170  /// TLS short read
172 
173  /// Timer expired
175 
176  /// read or write after shutdown
178 
179  /// Other TLS error
181 };
182 
183 class category : public lib::error_category {
184  public:
185  category() {}
186 
187  char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
188  return "websocketpp.transport";
189  }
190 
191  std::string message(int value) const {
192  switch(value) {
193  case general:
194  return "Generic transport policy error";
195  case pass_through:
196  return "Underlying Transport Error";
197  case invalid_num_bytes:
198  return "async_read_at_least call requested more bytes than buffer can store";
199  case operation_aborted:
200  return "The operation was aborted";
201  case operation_not_supported:
202  return "The operation is not supported by this transport";
203  case eof:
204  return "End of File";
205  case tls_short_read:
206  return "TLS Short Read";
207  case timeout:
208  return "Timer Expired";
209  case action_after_shutdown:
210  return "A transport action was requested after shutdown";
211  case tls_error:
212  return "Generic TLS related error";
213  default:
214  return "Unknown";
215  }
216  }
217 };
218 
219 inline lib::error_category const & get_category() {
220  static category instance;
221  return instance;
222 }
223 
224 inline lib::error_code make_error_code(error::value e) {
225  return lib::error_code(static_cast<int>(e), get_category());
226 }
227 
228 } // namespace error
229 } // namespace transport
230 } // namespace websocketpp
231 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
232 template<> struct is_error_code_enum<websocketpp::transport::error::value>
233 {
234  static bool const value = true;
235 };
236 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
237 
238 #endif // WEBSOCKETPP_TRANSPORT_BASE_CON_HPP
async_read_at_least call requested more bytes than buffer can store
Definition: connection.hpp:156
underlying transport pass through
Definition: connection.hpp:153
async_read called while another async_read was in progress
Definition: connection.hpp:159
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
A simple utility buffer class.
Definition: connection.hpp:138
lib::function< void(lib::error_code const &)> connect_handler
The type and signature of the callback passed to the connect method.
Definition: endpoint.hpp:72