WebSocket++
0.8.2
C++ websocket client/server library
websocketpp
transport
base
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
153
pass_through
,
154
155
/// async_read_at_least call requested more bytes than buffer can store
156
invalid_num_bytes
,
157
158
/// async_read called while another async_read was in progress
159
double_read
,
160
161
/// Operation aborted
162
operation_aborted
,
163
164
/// Operation not supported
165
operation_not_supported
,
166
167
/// End of file
168
eof
,
169
170
/// TLS short read
171
tls_short_read
,
172
173
/// Timer expired
174
timeout
,
175
176
/// read or write after shutdown
177
action_after_shutdown
,
178
179
/// Other TLS error
180
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
Generated by
1.9.1