WebSocket++ 0.8.2
C++ websocket client/server library
Loading...
Searching...
No Matches
hybi13.hpp
1/*
2 * Copyright (c) 2015, 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_PROCESSOR_HYBI13_HPP
29#define WEBSOCKETPP_PROCESSOR_HYBI13_HPP
30
31#include <websocketpp/processors/processor.hpp>
32
33#include <websocketpp/frame.hpp>
34#include <websocketpp/http/constants.hpp>
35
36#include <websocketpp/utf8_validator.hpp>
37#include <websocketpp/sha1/sha1.hpp>
38#include <websocketpp/base64/base64.hpp>
39
40#include <websocketpp/common/network.hpp>
41#include <websocketpp/common/platforms.hpp>
42
43#include <algorithm>
44#include <cassert>
45#include <string>
46#include <vector>
47#include <utility>
48
49namespace websocketpp {
50namespace processor {
51
52/// Processor for Hybi version 13 (RFC6455)
53template <typename config>
54class hybi13 : public processor<config> {
55public:
56 typedef processor<config> base;
57
58 typedef typename config::request_type request_type;
59 typedef typename config::response_type response_type;
60
61 typedef typename config::message_type message_type;
62 typedef typename message_type::ptr message_ptr;
63
64 typedef typename config::con_msg_manager_type msg_manager_type;
65 typedef typename msg_manager_type::ptr msg_manager_ptr;
66 typedef typename config::rng_type rng_type;
67
68 typedef typename config::permessage_deflate_type permessage_deflate_type;
69
70 typedef std::pair<lib::error_code,std::string> err_str_pair;
71
72 explicit hybi13(bool secure, bool p_is_server, msg_manager_ptr manager, rng_type& rng)
73 : processor<config>(secure, p_is_server)
74 , m_msg_manager(manager)
75 , m_rng(rng)
76 {
77 reset_headers();
78 }
79
80 int get_version() const {
81 return 13;
82 }
83
84 bool has_permessage_deflate() const {
85 return m_permessage_deflate.is_implemented();
86 }
87
88 err_str_pair negotiate_extensions(request_type const & request) {
89 return negotiate_extensions_helper(request);
90 }
91
92 err_str_pair negotiate_extensions(response_type const & response) {
93 return negotiate_extensions_helper(response);
94 }
95
96 /// Extension negotiation helper function
97 /**
98 * This exists mostly because the code for requests and responses is
99 * identical and I can't have virtual template methods.
100 */
101 template <typename header_type>
102 err_str_pair negotiate_extensions_helper(header_type const & header) {
103 err_str_pair ret;
104
105 // Respect blanket disabling of all extensions and don't even parse
106 // the extension header
107 if (!config::enable_extensions) {
109 return ret;
110 }
111
113
114 bool error = header.get_header_as_plist("Sec-WebSocket-Extensions",p);
115
116 if (error) {
118 return ret;
119 }
120
121 // If there are no extensions parsed then we are done!
122 if (p.size() == 0) {
123 return ret;
124 }
125
126 http::parameter_list::const_iterator it;
127
128 // look through the list of extension requests to find the first
129 // one that we can accept.
130 if (m_permessage_deflate.is_implemented()) {
131 err_str_pair neg_ret;
132 for (it = p.begin(); it != p.end(); ++it) {
133 // not a permessage-deflate extension request, ignore
134 if (it->first != "permessage-deflate") {
135 continue;
136 }
137
138 // if we have already successfully negotiated this extension
139 // then skip any other requests to negotiate the same one
140 // with different parameters
141 if (m_permessage_deflate.is_enabled()) {
142 continue;
143 }
144
145 // attempt to negotiate this offer
146 neg_ret = m_permessage_deflate.negotiate(it->second);
147
148 if (neg_ret.first) {
149 // negotiation offer failed. Do nothing. We will continue
150 // searching for a permessage-deflate config that succeeds
151 continue;
152 }
153
154 // Negotiation tentatively succeeded
155
156 // Actually try to initialize the extension before we
157 // deem negotiation complete
158 lib::error_code ec = m_permessage_deflate.init(base::m_server);
159
160 if (ec) {
161 // Negotiation succeeded but initialization failed this is
162 // an error that should stop negotiation of permessage
163 // deflate. Return the reason for the init failure
164
165 ret.first = ec;
166 break;
167 } else {
168 // Successfully initialized, push the negotiated response into
169 // the reply and stop looking for additional permessage-deflate
170 // extensions
171 ret.second += neg_ret.second;
172 break;
173 }
174 }
175 }
176
177 // support for future extensions would go here. Should check the value of
178 // ret.first before continuing. Might need to consider whether failure of
179 // negotiation of an earlier extension should stop negotiation of subsequent
180 // ones
181
182 return ret;
183 }
184
185 lib::error_code validate_handshake(request_type const & r) const {
186 if (r.get_method() != "GET") {
188 }
189
190 if (r.get_version() != "HTTP/1.1") {
192 }
193
194 // required headers
195 // Host is required by HTTP/1.1
196 // Connection is required by is_websocket_handshake
197 // Upgrade is required by is_websocket_handshake
198 if (r.get_header("Sec-WebSocket-Key").empty()) {
200 }
201
202 return lib::error_code();
203 }
204
205 /* TODO: the 'subprotocol' parameter may need to be expanded into a more
206 * generic struct if other user input parameters to the processed handshake
207 * are found.
208 */
209 lib::error_code process_handshake(request_type const & request,
210 std::string const & subprotocol, response_type & response) const
211 {
212 std::string server_key = request.get_header("Sec-WebSocket-Key");
213
214 lib::error_code ec = process_handshake_key(server_key);
215
216 if (ec) {
217 return ec;
218 }
219
220 response.replace_header("Sec-WebSocket-Accept",server_key);
221 response.append_header("Upgrade",constants::upgrade_token);
222 response.append_header("Connection",constants::connection_token);
223
224 if (!subprotocol.empty()) {
225 response.replace_header("Sec-WebSocket-Protocol",subprotocol);
226 }
227
228 return lib::error_code();
229 }
230
231 /// Fill in a set of request headers for a client connection request
232 /**
233 * @param [out] req Set of headers to fill in
234 * @param [in] uri The uri being connected to
235 * @param [in] subprotocols The list of subprotocols to request
236 */
237 lib::error_code client_handshake_request(request_type & req, uri_ptr
238 uri, std::vector<std::string> const & subprotocols) const
239 {
240 req.set_method("GET");
241 req.set_uri(uri->get_resource());
242 req.set_version("HTTP/1.1");
243
244 req.append_header("Upgrade","websocket");
245 req.append_header("Connection","Upgrade");
246 req.replace_header("Sec-WebSocket-Version","13");
247 req.replace_header("Host",uri->get_host_port());
248
249 if (!subprotocols.empty()) {
250 std::ostringstream result;
251 std::vector<std::string>::const_iterator it = subprotocols.begin();
252 result << *it++;
253 while (it != subprotocols.end()) {
254 result << ", " << *it++;
255 }
256
257 req.replace_header("Sec-WebSocket-Protocol",result.str());
258 }
259
260 // Generate handshake key
262 unsigned char raw_key[16];
263
264 for (int i = 0; i < 4; i++) {
265 conv.i = m_rng();
266 std::copy(conv.c,conv.c+4,&raw_key[i*4]);
267 }
268
269 req.replace_header("Sec-WebSocket-Key",base64_encode(raw_key, 16));
270
271 if (m_permessage_deflate.is_implemented()) {
272 std::string offer = m_permessage_deflate.generate_offer();
273 if (!offer.empty()) {
274 req.replace_header("Sec-WebSocket-Extensions",offer);
275 }
276 }
277
278 return lib::error_code();
279 }
280
281 /// Validate the server's response to an outgoing handshake request
282 /**
283 * @param req The original request sent
284 * @param res The reponse to generate
285 * @return An error code, 0 on success, non-zero for other errors
286 */
287 lib::error_code validate_server_handshake_response(request_type const & req,
288 response_type& res) const
289 {
290 // A valid response has an HTTP 101 switching protocols code
291 if (res.get_status_code() != http::status_code::switching_protocols) {
293 }
294
295 // And the upgrade token in an upgrade header
296 std::string const & upgrade_header = res.get_header("Upgrade");
297 if (utility::ci_find_substr(upgrade_header, constants::upgrade_token,
298 sizeof(constants::upgrade_token)-1) == upgrade_header.end())
299 {
301 }
302
303 // And the websocket token in the connection header
304 std::string const & con_header = res.get_header("Connection");
305 if (utility::ci_find_substr(con_header, constants::connection_token,
306 sizeof(constants::connection_token)-1) == con_header.end())
307 {
309 }
310
311 // And has a valid Sec-WebSocket-Accept value
312 std::string key = req.get_header("Sec-WebSocket-Key");
313 lib::error_code ec = process_handshake_key(key);
314
315 if (ec || key != res.get_header("Sec-WebSocket-Accept")) {
317 }
318
319 // check extensions
320
321 return lib::error_code();
322 }
323
324 std::string get_raw(response_type const & res) const {
325 return res.raw();
326 }
327
328 std::string const & get_origin(request_type const & r) const {
329 return r.get_header("Origin");
330 }
331
332 lib::error_code extract_subprotocols(request_type const & req,
333 std::vector<std::string> & subprotocol_list)
334 {
335 if (!req.get_header("Sec-WebSocket-Protocol").empty()) {
337
338 if (!req.get_header_as_plist("Sec-WebSocket-Protocol",p)) {
339 http::parameter_list::const_iterator it;
340
341 for (it = p.begin(); it != p.end(); ++it) {
342 subprotocol_list.push_back(it->first);
343 }
344 } else {
346 }
347 }
348 return lib::error_code();
349 }
350
351 uri_ptr get_uri(request_type const & request) const {
352 return get_uri_from_host(request,(base::m_secure ? "wss" : "ws"));
353 }
354
355 /// Process new websocket connection bytes
356 /**
357 *
358 * Hybi 13 data streams represent a series of variable length frames. Each
359 * frame is made up of a series of fixed length fields. The lengths of later
360 * fields are contained in earlier fields. The first field length is fixed
361 * by the spec.
362 *
363 * This processor represents a state machine that keeps track of what field
364 * is presently being read and how many more bytes are needed to complete it
365 *
366 *
367 *
368 *
369 * Read two header bytes
370 * Extract full frame length.
371 * Read extra header bytes
372 * Validate frame header (including extension validate)
373 * Read extension data into extension message state object
374 * Read payload data into payload
375 *
376 * @param buf Input buffer
377 *
378 * @param len Length of input buffer
379 *
380 * @return Number of bytes processed or zero on error
381 */
382 size_t consume(uint8_t * buf, size_t len, lib::error_code & ec) {
383 size_t p = 0;
384
385 ec = lib::error_code();
386
387 //std::cout << "consume: " << utility::to_hex(buf,len) << std::endl;
388
389 // Loop while we don't have a message ready and we still have bytes
390 // left to process.
391 while (m_state != READY && m_state != FATAL_ERROR &&
392 (p < len || m_bytes_needed == 0))
393 {
394 if (m_state == HEADER_BASIC) {
395 p += this->copy_basic_header_bytes(buf+p,len-p);
396
397 if (m_bytes_needed > 0) {
398 continue;
399 }
400
402 m_basic_header, base::m_server, !m_data_msg.msg_ptr
403 );
404 if (ec) {break;}
405
406 // extract full header size and adjust consume state accordingly
407 m_state = HEADER_EXTENDED;
408 m_cursor = 0;
409 m_bytes_needed = frame::get_header_len(m_basic_header) -
410 frame::BASIC_HEADER_LENGTH;
411 } else if (m_state == HEADER_EXTENDED) {
412 p += this->copy_extended_header_bytes(buf+p,len-p);
413
414 if (m_bytes_needed > 0) {
415 continue;
416 }
417
418 ec = validate_incoming_extended_header(m_basic_header,m_extended_header);
419 if (ec){break;}
420
421 m_state = APPLICATION;
422 m_bytes_needed = static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
423
424 // check if this frame is the start of a new message and set up
425 // the appropriate message metadata.
426 frame::opcode::value op = frame::get_opcode(m_basic_header);
427
428 // TODO: get_message failure conditions
429
431 m_control_msg = msg_metadata(
432 m_msg_manager->get_message(op,m_bytes_needed),
433 frame::get_masking_key(m_basic_header,m_extended_header)
434 );
435
436 m_current_msg = &m_control_msg;
437 } else {
438 if (!m_data_msg.msg_ptr) {
439 if (m_bytes_needed > base::m_max_message_size) {
441 break;
442 }
443
444 m_data_msg = msg_metadata(
445 m_msg_manager->get_message(op,m_bytes_needed),
446 frame::get_masking_key(m_basic_header,m_extended_header)
447 );
448
449 if (m_permessage_deflate.is_enabled()) {
450 m_data_msg.msg_ptr->set_compressed(frame::get_rsv1(m_basic_header));
451 }
452 } else {
453 // Fetch the underlying payload buffer from the data message we
454 // are writing into.
455 std::string & out = m_data_msg.msg_ptr->get_raw_payload();
456
457 if (out.size() + m_bytes_needed > base::m_max_message_size) {
459 break;
460 }
461
462 // Each frame starts a new masking key. All other state
463 // remains between frames.
464 m_data_msg.prepared_key = prepare_masking_key(
466 m_basic_header,
467 m_extended_header
468 )
469 );
470
471 out.reserve(out.size() + m_bytes_needed);
472 }
473 m_current_msg = &m_data_msg;
474 }
475 } else if (m_state == EXTENSION) {
476 m_state = APPLICATION;
477 } else if (m_state == APPLICATION) {
478 size_t bytes_to_process = (std::min)(m_bytes_needed,len-p);
479
480 if (bytes_to_process > 0) {
481 p += this->process_payload_bytes(buf+p,bytes_to_process,ec);
482
483 if (ec) {break;}
484 }
485
486 if (m_bytes_needed > 0) {
487 continue;
488 }
489
490 // If this was the last frame in the message set the ready flag.
491 // Otherwise, reset processor state to read additional frames.
492 if (frame::get_fin(m_basic_header)) {
494 if (ec) {
495 break;
496 }
497 } else {
498 this->reset_headers();
499 }
500 } else {
501 // shouldn't be here
503 return 0;
504 }
505 }
506
507 return p;
508 }
509
510 /// Perform any finalization actions on an incoming message
511 /**
512 * Called after the full message is received. Provides the opportunity for
513 * extensions to complete any data post processing as well as final UTF8
514 * validation checks for text messages.
515 *
516 * @return A code indicating errors, if any
517 */
518 lib::error_code finalize_message() {
519 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
520
521 // if the frame is compressed, append the compression
522 // trailer and flush the compression buffer.
523 if (m_permessage_deflate.is_enabled()
524 && m_current_msg->msg_ptr->get_compressed())
525 {
526 uint8_t trailer[4] = {0x00, 0x00, 0xff, 0xff};
527
528 // Decompress current buffer into the message buffer
529 lib::error_code ec;
530 ec = m_permessage_deflate.decompress(trailer,4,out);
531 if (ec) {
532 return ec;
533 }
534 }
535
536 // ensure that text messages end on a valid UTF8 code point
537 if (frame::get_opcode(m_basic_header) == frame::opcode::TEXT) {
538 if (!m_current_msg->validator.complete()) {
540 }
541 }
542
543 m_state = READY;
544
545 return lib::error_code();
546 }
547
548 void reset_headers() {
549 m_state = HEADER_BASIC;
550 m_bytes_needed = frame::BASIC_HEADER_LENGTH;
551
552 m_basic_header.b0 = 0x00;
553 m_basic_header.b1 = 0x00;
554
555 std::fill_n(
556 m_extended_header.bytes,
558 0x00
559 );
560 }
561
562 /// Test whether or not the processor has a message ready
563 bool ready() const {
564 return (m_state == READY);
565 }
566
567 message_ptr get_message() {
568 if (!ready()) {
569 return message_ptr();
570 }
571 message_ptr ret = m_current_msg->msg_ptr;
572 m_current_msg->msg_ptr.reset();
573
574 if (frame::opcode::is_control(ret->get_opcode())) {
575 m_control_msg.msg_ptr.reset();
576 } else {
577 m_data_msg.msg_ptr.reset();
578 }
579
580 this->reset_headers();
581
582 return ret;
583 }
584
585 /// Test whether or not the processor is in a fatal error state.
586 bool get_error() const {
587 return m_state == FATAL_ERROR;
588 }
589
591 return m_bytes_needed;
592 }
593
594 /// Prepare a user data message for writing
595 /**
596 * Performs validation, masking, compression, etc. will return an error if
597 * there was an error, otherwise msg will be ready to be written
598 *
599 * TODO: tests
600 *
601 * @param in An unprepared message to prepare
602 * @param out A message to be overwritten with the prepared message
603 * @return error code
604 */
605 virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
606 {
607 if (!in || !out) {
609 }
610
611 frame::opcode::value op = in->get_opcode();
612
613 // validate opcode: only regular data frames
616 }
617
618 std::string& i = in->get_raw_payload();
619 std::string& o = out->get_raw_payload();
620
621 // validate payload utf8
622 if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
624 }
625
626 frame::masking_key_type key;
627 bool masked = !base::m_server;
628 bool compressed = m_permessage_deflate.is_enabled()
629 && in->get_compressed();
630 bool fin = in->get_fin();
631
632 if (masked) {
633 // Generate masking key.
634 key.i = m_rng();
635 } else {
636 key.i = 0;
637 }
638
639 // prepare payload
640 if (compressed) {
641 // compress and store in o after header.
642 m_permessage_deflate.compress(i,o);
643
644 if (o.size() < 4) {
646 }
647
648 // Strip trailing 4 0x00 0x00 0xff 0xff bytes before writing to the
649 // wire
650 o.resize(o.size()-4);
651
652 // mask in place if necessary
653 if (masked) {
654 this->masked_copy(o,o,key);
655 }
656 } else {
657 // no compression, just copy data into the output buffer
658 o.resize(i.size());
659
660 // if we are masked, have the masking function write to the output
661 // buffer directly to avoid another copy. If not masked, copy
662 // directly without masking.
663 if (masked) {
664 this->masked_copy(i,o,key);
665 } else {
666 std::copy(i.begin(),i.end(),o.begin());
667 }
668 }
669
670 // generate header
671 frame::basic_header h(op,o.size(),fin,masked,compressed);
672
673 if (masked) {
674 frame::extended_header e(o.size(),key.i);
675 out->set_header(frame::prepare_header(h,e));
676 } else {
677 frame::extended_header e(o.size());
678 out->set_header(frame::prepare_header(h,e));
679 }
680
681 out->set_prepared(true);
682 out->set_opcode(op);
683
684 return lib::error_code();
685 }
686
687 /// Get URI
688 lib::error_code prepare_ping(std::string const & in, message_ptr out) const {
689 return this->prepare_control(frame::opcode::PING,in,out);
690 }
691
692 lib::error_code prepare_pong(std::string const & in, message_ptr out) const {
693 return this->prepare_control(frame::opcode::PONG,in,out);
694 }
695
696 virtual lib::error_code prepare_close(close::status::value code,
697 std::string const & reason, message_ptr out) const
698 {
701 }
702
705 }
706
707 if (code == close::status::no_status && reason.size() > 0) {
709 }
710
711 if (reason.size() > frame:: limits::payload_size_basic-2) {
713 }
714
715 std::string payload;
716
717 if (code != close::status::no_status) {
719 val.i = htons(code);
720
721 payload.resize(reason.size()+2);
722
723 payload[0] = val.c[0];
724 payload[1] = val.c[1];
725
726 std::copy(reason.begin(),reason.end(),payload.begin()+2);
727 }
728
729 return this->prepare_control(frame::opcode::CLOSE,payload,out);
730 }
731protected:
732 /// Convert a client handshake key into a server response key in place
733 lib::error_code process_handshake_key(std::string & key) const {
734 key.append(constants::handshake_guid);
735
736 unsigned char message_digest[20];
737 sha1::calc(key.c_str(),key.length(),message_digest);
738 key = base64_encode(message_digest,20);
739
740 return lib::error_code();
741 }
742
743 /// Reads bytes from buf into m_basic_header
744 size_t copy_basic_header_bytes(uint8_t const * buf, size_t len) {
745 if (len == 0 || m_bytes_needed == 0) {
746 return 0;
747 }
748
749 if (len > 1) {
750 // have at least two bytes
751 if (m_bytes_needed == 2) {
752 m_basic_header.b0 = buf[0];
753 m_basic_header.b1 = buf[1];
754 m_bytes_needed -= 2;
755 return 2;
756 } else {
757 m_basic_header.b1 = buf[0];
758 m_bytes_needed--;
759 return 1;
760 }
761 } else {
762 // have exactly one byte
763 if (m_bytes_needed == 2) {
764 m_basic_header.b0 = buf[0];
765 m_bytes_needed--;
766 return 1;
767 } else {
768 m_basic_header.b1 = buf[0];
769 m_bytes_needed--;
770 return 1;
771 }
772 }
773 }
774
775 /// Reads bytes from buf into m_extended_header
776 size_t copy_extended_header_bytes(uint8_t const * buf, size_t len) {
777 size_t bytes_to_read = (std::min)(m_bytes_needed,len);
778
779 std::copy(buf,buf+bytes_to_read,m_extended_header.bytes+m_cursor);
780 m_cursor += bytes_to_read;
781 m_bytes_needed -= bytes_to_read;
782
783 return bytes_to_read;
784 }
785
786 /// Reads bytes from buf into message payload
787 /**
788 * This function performs unmasking and uncompression, validates the
789 * decoded bytes, and writes them to the appropriate message buffer.
790 *
791 * This member function will use the input buffer as stratch space for its
792 * work. The raw input bytes will not be preserved. This applies only to the
793 * bytes actually needed. At most min(m_bytes_needed,len) will be processed.
794 *
795 * @param buf Input/working buffer
796 * @param len Length of buf
797 * @return Number of bytes processed or zero in case of an error
798 */
799 size_t process_payload_bytes(uint8_t * buf, size_t len, lib::error_code& ec)
800 {
801 // unmask if masked
802 if (frame::get_masked(m_basic_header)) {
803 m_current_msg->prepared_key = frame::byte_mask_circ(
804 buf, len, m_current_msg->prepared_key);
805 // TODO: SIMD masking
806 }
807
808 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
809 size_t offset = out.size();
810
811 // decompress message if needed.
812 if (m_permessage_deflate.is_enabled()
813 && m_current_msg->msg_ptr->get_compressed())
814 {
815 // Decompress current buffer into the message buffer
816 ec = m_permessage_deflate.decompress(buf,len,out);
817 if (ec) {
818 return 0;
819 }
820 } else {
821 // No compression, straight copy
822 out.append(reinterpret_cast<char *>(buf),len);
823 }
824
825 // validate unmasked, decompressed values
826 if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
827 if (!m_current_msg->validator.decode(out.begin()+offset,out.end())) {
829 return 0;
830 }
831 }
832
833 m_bytes_needed -= len;
834
835 return len;
836 }
837
838 /// Validate an incoming basic header
839 /**
840 * Validates an incoming hybi13 basic header.
841 *
842 * @param h The basic header to validate
843 * @param is_server Whether or not the endpoint that received this frame
844 * is a server.
845 * @param new_msg Whether or not this is the first frame of the message
846 * @return 0 on success or a non-zero error code on failure
847 */
849 bool is_server, bool new_msg) const
850 {
851 frame::opcode::value op = frame::get_opcode(h);
852
853 // Check control frame size limit
856 {
858 }
859
860 // Check that RSV bits are clear
861 // The only RSV bits allowed are rsv1 if the permessage_compress
862 // extension is enabled for this connection and the message is not
863 // a control message.
864 //
865 // TODO: unit tests for this
866 if (frame::get_rsv1(h) && (!m_permessage_deflate.is_enabled()
868 {
870 }
871
874 }
875
876 // Check for reserved opcodes
879 }
880
881 // Check for invalid opcodes
882 // TODO: unit tests for this?
885 }
886
887 // Check for fragmented control message
890 }
891
892 // Check for continuation without an active message
893 if (new_msg && op == frame::opcode::CONTINUATION) {
895 }
896
897 // Check for new data frame when expecting continuation
898 if (!new_msg && !frame::opcode::is_control(op) &&
899 op != frame::opcode::CONTINUATION)
900 {
902 }
903
904 // Servers should reject any unmasked frames from clients.
905 // Clients should reject any masked frames from servers.
906 if (is_server && !frame::get_masked(h)) {
908 } else if (!is_server && frame::get_masked(h)) {
910 }
911
912 return lib::error_code();
913 }
914
915 /// Validate an incoming extended header
916 /**
917 * Validates an incoming hybi13 full header.
918 *
919 * @todo unit test for the >32 bit frames on 32 bit systems case
920 *
921 * @param h The basic header to validate
922 * @param e The extended header to validate
923 * @return An error_code, non-zero values indicate why the validation
924 * failed
925 */
927 frame::extended_header e) const
928 {
929 uint8_t basic_size = frame::get_basic_size(h);
930 uint64_t payload_size = frame::get_payload_size(h,e);
931
932 // Check for non-minimally encoded payloads
933 if (basic_size == frame::payload_size_code_16bit &&
934 payload_size <= frame::limits::payload_size_basic)
935 {
937 }
938
939 if (basic_size == frame::payload_size_code_64bit &&
941 {
943 }
944
945 // Check for >32bit frames on 32 bit systems
946 if (sizeof(size_t) == 4 && (payload_size >> 32)) {
948 }
949
950 return lib::error_code();
951 }
952
953 /// Copy and mask/unmask in one operation
954 /**
955 * Reads input from one string and writes unmasked output to another.
956 *
957 * @param [in] i The input string.
958 * @param [out] o The output string.
959 * @param [in] key The masking key to use for masking/unmasking
960 */
961 void masked_copy (std::string const & i, std::string & o,
962 frame::masking_key_type key) const
963 {
964 frame::byte_mask(i.begin(),i.end(),o.begin(),key);
965 // TODO: SIMD masking
966 }
967
968 /// Generic prepare control frame with opcode and payload.
969 /**
970 * Internal control frame building method. Handles validation, masking, etc
971 *
972 * @param op The control opcode to use
973 * @param payload The payload to use
974 * @param out The message buffer to store the prepared frame in
975 * @return Status code, zero on success, non-zero on error
976 */
977 lib::error_code prepare_control(frame::opcode::value op,
978 std::string const & payload, message_ptr out) const
979 {
980 if (!out) {
982 }
983
986 }
987
988 if (payload.size() > frame::limits::payload_size_basic) {
990 }
991
992 frame::masking_key_type key;
993 bool masked = !base::m_server;
994
995 frame::basic_header h(op,payload.size(),true,masked);
996
997 std::string & o = out->get_raw_payload();
998 o.resize(payload.size());
999
1000 if (masked) {
1001 // Generate masking key.
1002 key.i = m_rng();
1003
1004 frame::extended_header e(payload.size(),key.i);
1005 out->set_header(frame::prepare_header(h,e));
1006 this->masked_copy(payload,o,key);
1007 } else {
1008 frame::extended_header e(payload.size());
1009 out->set_header(frame::prepare_header(h,e));
1010 std::copy(payload.begin(),payload.end(),o.begin());
1011 }
1012
1013 out->set_opcode(op);
1014 out->set_prepared(true);
1015
1016 return lib::error_code();
1017 }
1018
1019 enum state {
1020 HEADER_BASIC = 0,
1021 HEADER_EXTENDED = 1,
1022 EXTENSION = 2,
1023 APPLICATION = 3,
1024 READY = 4,
1025 FATAL_ERROR = 5
1026 };
1027
1028 /// This data structure holds data related to processing a message, such as
1029 /// the buffer it is being written to, its masking key, its UTF8 validation
1030 /// state, and sometimes its compression state.
1032 msg_metadata() {}
1033 msg_metadata(message_ptr m, size_t p) : msg_ptr(m),prepared_key(p) {}
1034 msg_metadata(message_ptr m, frame::masking_key_type p)
1035 : msg_ptr(m)
1036 , prepared_key(prepare_masking_key(p)) {}
1037
1038 message_ptr msg_ptr; // pointer to the message data buffer
1039 size_t prepared_key; // prepared masking key
1040 utf8_validator::validator validator; // utf8 validation state
1041 };
1042
1043 // Basic header of the frame being read
1044 frame::basic_header m_basic_header;
1045
1046 // Pointer to a manager that can create message buffers for us.
1047 msg_manager_ptr m_msg_manager;
1048
1049 // Number of bytes needed to complete the current operation
1050 size_t m_bytes_needed;
1051
1052 // Number of extended header bytes read
1053 size_t m_cursor;
1054
1055 // Metadata for the current data msg
1056 msg_metadata m_data_msg;
1057 // Metadata for the current control msg
1058 msg_metadata m_control_msg;
1059
1060 // Pointer to the metadata associated with the frame being read
1061 msg_metadata * m_current_msg;
1062
1063 // Extended header of current frame
1064 frame::extended_header m_extended_header;
1065
1066 rng_type & m_rng;
1067
1068 // Overall state of the processor
1069 state m_state;
1070
1071 // Extensions
1072 permessage_deflate_type m_permessage_deflate;
1073};
1074
1075} // namespace processor
1076} // namespace websocketpp
1077
1078#endif //WEBSOCKETPP_PROCESSOR_HYBI13_HPP
#define _WEBSOCKETPP_CPP11_FUNCTIONAL_
#define _WEBSOCKETPP_CPP11_THREAD_
#define _WEBSOCKETPP_CPP11_MEMORY_
#define _WEBSOCKETPP_CPP11_SYSTEM_ERROR_
#define _WEBSOCKETPP_INITIALIZER_LISTS_
Concurrency policy that uses std::mutex / boost::mutex.
Definition basic.hpp:37
Stub for user supplied base class.
Represents an individual WebSocket connection.
ptr get_shared()
Get a shared pointer to this component.
config::concurrency_type concurrency_type
Type of the concurrency component of this connection.
void handle_interrupt()
Transport inturrupt callback.
void set_message_handler(message_handler h)
Set message handler.
config::elog_type elog_type
Type of the error logging policy.
lib::error_code interrupt()
Asyncronously invoke handler::on_inturrupt.
void start()
Start the connection state machine.
std::string const & get_request_body() const
Retrieve a request body.
void set_close_handler(close_handler h)
Set close handler.
lib::error_code send(message_ptr msg)
Add a message to the outgoing send queue.
http::status_code::value get_response_code() const
Get response HTTP status code.
lib::error_code defer_http_response()
Defer HTTP Response until later (Exception free)
lib::error_code resume_reading()
Resume reading of new data.
bool get_secure() const
Returns the secure flag from the connection URI.
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
config::alog_type alog_type
Type of the access logging policy.
size_t get_buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes)
std::string const & get_origin() const
Return the same origin policy origin value from the opening request.
std::string const & get_host() const
Returns the host component of the connection URI.
transport_con_type::timer_ptr timer_ptr
Type of a pointer to a transport timer handle.
response_type const & get_response() const
Get response object.
void set_max_message_size(size_t new_value)
Set maximum message size.
std::string const & get_resource() const
Returns the resource component of the connection URI.
lib::error_code process_handshake_request()
void handle_pause_reading()
Pause reading callback.
std::vector< int > const & get_supported_versions() const
Get array of WebSocket protocol versions that this connection supports.
config::rng_type rng_type
Type of RNG.
lib::error_code send(void const *payload, size_t len, frame::opcode::value op=frame::opcode::binary)
Send a message (raw array overload)
uri_ptr get_uri() const
Gets the connection URI.
connection_hdl get_handle() const
Get Connection Handle.
void send_http_response(lib::error_code &ec)
Send deferred HTTP Response (exception free)
void set_http_handler(http_handler h)
Set http handler.
std::string const & get_response_msg() const
Get response HTTP status message.
message_ptr get_message(websocketpp::frame::opcode::value op, size_t size) const
Get a message buffer.
void handle_write_frame(lib::error_code const &ec)
Process the results of a frame write operation and start the next write.
close::status::value get_local_close_code() const
Get the WebSocket close code sent by this endpoint.
lib::error_code get_ec() const
Get the internal error code for a closed/failed connection.
void set_fail_handler(fail_handler h)
Set fail handler.
void write_frame()
Checks if there are frames in the send queue and if there are sends one.
session::state::value get_state() const
Return the connection state.
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the transport component of this connection.
void set_status(http::status_code::value code)
Set response status code and message.
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
void set_validate_handler(validate_handler h)
Set validate handler.
void set_interrupt_handler(interrupt_handler h)
Set interrupt handler.
size_t buffered_amount() const
Get the size of the outgoing write buffer (in payload bytes)
void send_http_response()
Send deferred HTTP Response.
close::status::value get_remote_close_code() const
Get the WebSocket close code sent by the remote endpoint.
void set_open_handler(open_handler h)
Set open handler.
bool is_server() const
Get whether or not this connection is part of a server or client.
std::string const & get_remote_close_reason() const
Get the WebSocket close reason sent by the remote endpoint.
void set_pong_timeout(long dur)
Set pong timeout.
lib::error_code initialize_processor()
void set_uri(uri_ptr uri)
Sets the connection URI.
void set_termination_handler(termination_handler new_handler)
request_type const & get_request() const
Get request object.
connection< config > type
Type of this connection.
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
lib::error_code pause_reading()
Pause reading of new data.
void handle_resume_reading()
Resume reading callback.
std::vector< std::string > const & get_requested_subprotocols() const
Gets all of the subprotocols requested by the client.
config::transport_type::transport_con_type transport_con_type
Type of the transport component of this connection.
std::string const & get_subprotocol() const
Gets the negotated subprotocol.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void read_frame()
Issue a new transport read unless reading is paused.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection.
uint16_t get_port() const
Returns the port component of the connection URI.
std::string const & get_local_close_reason() const
Get the WebSocket close reason sent by this endpoint.
size_t get_max_message_size() const
Get maximum message size.
Stub for user supplied base class.
Creates and manages connections associated with a WebSocket endpoint.
Definition endpoint.hpp:42
void set_max_http_body_size(size_t new_value)
Set maximum HTTP message body size.
Definition endpoint.hpp:466
concurrency_type::scoped_lock_type scoped_lock_type
Type of our concurrency policy's scoped lock object.
Definition endpoint.hpp:78
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
alog_type & get_alog()
Get reference to access logger.
Definition endpoint.hpp:261
config::rng_type rng_type
Type of RNG.
Definition endpoint.hpp:83
std::string get_user_agent() const
Returns the user agent string that this endpoint will use.
Definition endpoint.hpp:169
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:65
void clear_access_channels(log::level channels)
Clear Access logging channels.
Definition endpoint.hpp:231
void resume_reading(connection_hdl hdl)
Resume reading of new data.
connection connection_type
Type of the connections that this endpoint creates.
Definition endpoint.hpp:54
elog_type & get_elog()
Get reference to error logger.
Definition endpoint.hpp:269
bool is_server() const
Returns whether or not this endpoint is a server.
Definition endpoint.hpp:205
connection_type::message_handler message_handler
Type of message_handler.
Definition endpoint.hpp:68
void set_close_handshake_timeout(long dur)
Set close handshake timeout.
Definition endpoint.hpp:377
void set_access_channels(log::level channels)
Set Access logging channel.
Definition endpoint.hpp:220
void set_max_message_size(size_t new_value)
Set default maximum message size.
Definition endpoint.hpp:432
size_t get_max_message_size() const
Get default maximum message size.
Definition endpoint.hpp:415
connection_ptr get_con_from_hdl(connection_hdl hdl)
Retrieves a connection_ptr from a connection_hdl (exception version)
Definition endpoint.hpp:653
connection_type::weak_ptr connection_weak_ptr
Weak pointer to connection type.
Definition endpoint.hpp:58
connection_type::message_ptr message_ptr
Type of message pointers that this endpoint uses.
Definition endpoint.hpp:70
void set_error_channels(log::level channels)
Set Error logging channel.
Definition endpoint.hpp:242
void clear_error_channels(log::level channels)
Clear Error logging channels.
Definition endpoint.hpp:253
config::elog_type elog_type
Type of error logger.
Definition endpoint.hpp:73
void resume_reading(connection_hdl hdl, lib::error_code &ec)
Resume reading of new data (exception free)
concurrency_type::mutex_type mutex_type
Type of our concurrency policy's mutex object.
Definition endpoint.hpp:80
connection_type::ptr connection_ptr
Shared pointer to connection_type.
Definition endpoint.hpp:56
void interrupt(connection_hdl hdl, lib::error_code &ec)
void set_pong_timeout(long dur)
Set pong timeout.
Definition endpoint.hpp:399
config::transport_type transport_type
Type of the transport component of this endpoint.
Definition endpoint.hpp:49
size_t get_max_http_body_size() const
Get maximum HTTP message body size.
Definition endpoint.hpp:449
config::concurrency_type concurrency_type
Type of the concurrency component of this endpoint.
Definition endpoint.hpp:51
void set_open_handshake_timeout(long dur)
Set open handshake timeout.
Definition endpoint.hpp:352
config::alog_type alog_type
Type of access logger.
Definition endpoint.hpp:75
void send_http_response(connection_hdl hdl, lib::error_code &ec)
Send deferred HTTP Response.
transport_type::transport_con_type transport_con_type
Definition endpoint.hpp:62
void pause_reading(connection_hdl hdl, lib::error_code &ec)
Pause reading of new data (exception free)
void send_http_response(connection_hdl hdl)
Send deferred HTTP Response (exception free)
void pause_reading(connection_hdl hdl)
Pause reading of new data.
Stub class for use when disabling permessage_deflate extension.
Definition disabled.hpp:53
err_str_pair negotiate(http::attribute_list const &)
Negotiate extension.
Definition disabled.hpp:65
std::string generate_offer() const
Generate extension offer.
Definition disabled.hpp:99
lib::error_code init(bool)
Initialize state.
Definition disabled.hpp:76
header_list const & get_headers() const
Return a list of all HTTP headers.
Definition parser.hpp:179
size_t process_body(char const *buf, size_t len)
Process body data.
Definition parser.hpp:145
std::string const & get_body() const
Get HTTP body.
Definition parser.hpp:505
void process_header(std::string::iterator begin, std::string::iterator end)
Process a header line.
Definition parser.hpp:161
bool body_ready() const
Check if the parser is done parsing the body.
Definition parser.hpp:599
bool prepare_body()
Prepare the parser to begin parsing body data.
Definition parser.hpp:119
void set_max_body_size(size_t value)
Set body size limit.
Definition parser.hpp:542
std::string raw_headers() const
Generate and return the HTTP headers as a string.
Definition parser.hpp:183
std::string const & get_version() const
Get the HTTP version string.
Definition parser.hpp:410
size_t get_max_body_size() const
Get body size limit.
Definition parser.hpp:529
Stores, parses, and manipulates HTTP requests.
Definition request.hpp:50
std::string raw() const
Returns the full raw request (including the body)
Definition request.hpp:131
std::string const & get_uri() const
Return the requested URI.
Definition request.hpp:104
std::string const & get_method() const
Return the request method.
Definition request.hpp:96
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition request.hpp:41
bool ready() const
Returns whether or not the request is ready for reading.
Definition request.hpp:82
std::string raw_head() const
Returns the raw request headers only (similar to an HTTP HEAD request)
Definition request.hpp:141
Stores, parses, and manipulates HTTP responses.
Definition response.hpp:57
void set_status(status_code::value code)
Set response status code and message.
Definition response.hpp:191
std::string raw() const
Returns the full raw response.
Definition response.hpp:178
size_t consume(std::istream &s)
Process bytes in the input buffer (istream version)
Definition response.hpp:139
bool headers_ready() const
Returns true if the response headers are fully parsed.
Definition response.hpp:121
bool ready() const
Returns true if the response is ready.
Definition response.hpp:116
const std::string & get_status_msg() const
Return the response status message.
Definition response.hpp:157
status_code::value get_status_code() const
Return the response status code.
Definition response.hpp:152
size_t consume(char const *buf, size_t len)
Process bytes in the input buffer.
Definition response.hpp:42
Basic logger that outputs to an ostream.
Definition basic.hpp:59
void write(level channel, char const *msg)
Write a cstring message to the given channel.
Definition basic.hpp:151
bool recycle(message *)
Recycle a message.
Definition alloc.hpp:80
message_ptr get_message(frame::opcode::value op, size_t size)
Get a message buffer with specified size and opcode.
Definition alloc.hpp:66
message_ptr get_message()
Get an empty message buffer.
Definition alloc.hpp:55
con_msg_man_ptr get_manager() const
Get a pointer to a connection message manager.
Definition alloc.hpp:96
Represents a buffer for a single WebSocket message.
Definition pool.hpp:101
message(const con_msg_man_ptr manager, frame::opcode::value op, size_t size=128)
Construct a message and fill in some values.
Definition message.hpp:107
std::string & get_raw_payload()
Get a non-const reference to the payload string.
Definition message.hpp:254
bool recycle()
Recycle the message.
Definition message.hpp:316
bool get_compressed() const
Return whether or not the message is flagged as compressed.
Definition message.hpp:143
bool get_terminal() const
Get whether or not the message is terminal.
Definition message.hpp:169
std::string const & get_header() const
Return the prepared frame header.
Definition message.hpp:224
void set_payload(void const *payload, size_t len)
Set payload data.
Definition message.hpp:275
bool get_fin() const
Read the fin bit.
Definition message.hpp:195
void append_payload(void const *payload, size_t len)
Append payload data.
Definition message.hpp:298
void set_opcode(frame::opcode::value op)
Set the opcode.
Definition message.hpp:215
void set_prepared(bool value)
Set or clear the flag that indicates that the message has been prepared.
Definition message.hpp:135
frame::opcode::value get_opcode() const
Return the message opcode.
Definition message.hpp:210
void set_terminal(bool value)
Set the terminal flag.
Definition message.hpp:181
bool get_prepared() const
Return whether or not the message has been prepared for sending.
Definition message.hpp:125
void set_compressed(bool value)
Set or clear the compression flag.
Definition message.hpp:156
message(const con_msg_man_ptr manager)
Construct an empty message.
Definition message.hpp:96
void set_fin(bool value)
Set the fin bit.
Definition message.hpp:205
std::string const & get_payload() const
Get a reference to the payload string.
Definition message.hpp:246
Category for processor errors.
Definition base.hpp:161
Processor for Hybi Draft version 00.
Definition hybi00.hpp:54
std::string get_raw(response_type const &res) const
Given a completed response, get the raw bytes to put on the wire.
Definition hybi00.hpp:179
lib::error_code prepare_ping(std::string const &, message_ptr) const
Prepare a ping frame.
Definition hybi00.hpp:373
lib::error_code prepare_pong(std::string const &, message_ptr) const
Prepare a pong frame.
Definition hybi00.hpp:386
lib::error_code process_handshake(request_type const &req, std::string const &subprotocol, response_type &res) const
Calculate the appropriate response for this websocket request.
Definition hybi00.hpp:100
lib::error_code client_handshake_request(request_type &, uri_ptr, std::vector< std::string > const &) const
Fill in a set of request headers for a client connection request.
Definition hybi00.hpp:158
std::string get_key3() const
Get hybi00 handshake key3.
Definition hybi00.hpp:247
size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)
Process new websocket connection bytes.
Definition hybi00.hpp:252
bool get_error() const
Tests whether the processor is in a fatal error state.
Definition hybi00.hpp:313
bool ready() const
Checks if there is a message ready.
Definition hybi00.hpp:309
lib::error_code validate_server_handshake_response(request_type const &, response_type &) const
Validate the server's response to an outgoing handshake request.
Definition hybi00.hpp:173
lib::error_code prepare_close(close::status::value, std::string const &, message_ptr out) const
Prepare a close frame.
Definition hybi00.hpp:401
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
Prepare a message for writing.
Definition hybi00.hpp:329
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
Definition hybi00.hpp:77
int get_version() const
Get the protocol version of this processor.
Definition hybi00.hpp:73
uri_ptr get_uri(request_type const &request) const
Extracts client uri from a handshake request.
Definition hybi00.hpp:217
lib::error_code extract_subprotocols(request_type const &req, std::vector< std::string > &subprotocol_list)
Extracts requested subprotocols from a handshake request.
Definition hybi00.hpp:198
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
Definition hybi00.hpp:185
message_ptr get_message()
Retrieves the most recently processed message.
Definition hybi00.hpp:317
Processor for Hybi Draft version 07.
Definition hybi07.hpp:44
int get_version() const
Get the protocol version of this processor.
Definition hybi07.hpp:69
lib::error_code client_handshake_request(request_type &, uri_ptr, std::vector< std::string > const &) const
Fill in a set of request headers for a client connection request.
Definition hybi07.hpp:63
Processor for Hybi Draft version 08.
Definition hybi08.hpp:44
lib::error_code client_handshake_request(request_type &, uri_ptr, std::vector< std::string > const &) const
Fill in a set of request headers for a client connection request.
Definition hybi08.hpp:64
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
Definition hybi08.hpp:74
int get_version() const
Get the protocol version of this processor.
Definition hybi08.hpp:70
Processor for Hybi version 13 (RFC6455)
Definition hybi13.hpp:54
lib::error_code validate_incoming_basic_header(frame::basic_header const &h, bool is_server, bool new_msg) const
Validate an incoming basic header.
Definition hybi13.hpp:848
size_t get_bytes_needed() const
Definition hybi13.hpp:590
err_str_pair negotiate_extensions_helper(header_type const &header)
Extension negotiation helper function.
Definition hybi13.hpp:102
lib::error_code prepare_ping(std::string const &in, message_ptr out) const
Get URI.
Definition hybi13.hpp:688
lib::error_code extract_subprotocols(request_type const &req, std::vector< std::string > &subprotocol_list)
Extracts requested subprotocols from a handshake request.
Definition hybi13.hpp:332
uri_ptr get_uri(request_type const &request) const
Extracts client uri from a handshake request.
Definition hybi13.hpp:351
lib::error_code client_handshake_request(request_type &req, uri_ptr uri, std::vector< std::string > const &subprotocols) const
Fill in a set of request headers for a client connection request.
Definition hybi13.hpp:237
lib::error_code prepare_control(frame::opcode::value op, std::string const &payload, message_ptr out) const
Generic prepare control frame with opcode and payload.
Definition hybi13.hpp:977
err_str_pair negotiate_extensions(response_type const &response)
Initializes extensions based on the Sec-WebSocket-Extensions header.
Definition hybi13.hpp:92
size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)
Process new websocket connection bytes.
Definition hybi13.hpp:382
bool get_error() const
Test whether or not the processor is in a fatal error state.
Definition hybi13.hpp:586
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
Prepare a user data message for writing.
Definition hybi13.hpp:605
size_t copy_basic_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_basic_header.
Definition hybi13.hpp:744
size_t copy_extended_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_extended_header.
Definition hybi13.hpp:776
void masked_copy(std::string const &i, std::string &o, frame::masking_key_type key) const
Copy and mask/unmask in one operation.
Definition hybi13.hpp:961
lib::error_code validate_server_handshake_response(request_type const &req, response_type &res) const
Validate the server's response to an outgoing handshake request.
Definition hybi13.hpp:287
message_ptr get_message()
Retrieves the most recently processed message.
Definition hybi13.hpp:567
lib::error_code finalize_message()
Perform any finalization actions on an incoming message.
Definition hybi13.hpp:518
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
Definition hybi13.hpp:328
lib::error_code process_handshake(request_type const &request, std::string const &subprotocol, response_type &response) const
Calculate the appropriate response for this websocket request.
Definition hybi13.hpp:209
size_t process_payload_bytes(uint8_t *buf, size_t len, lib::error_code &ec)
Reads bytes from buf into message payload.
Definition hybi13.hpp:799
std::string get_raw(response_type const &res) const
Given a completed response, get the raw bytes to put on the wire.
Definition hybi13.hpp:324
lib::error_code validate_incoming_extended_header(frame::basic_header h, frame::extended_header e) const
Validate an incoming extended header.
Definition hybi13.hpp:926
err_str_pair negotiate_extensions(request_type const &request)
Initializes extensions based on the Sec-WebSocket-Extensions header.
Definition hybi13.hpp:88
bool ready() const
Test whether or not the processor has a message ready.
Definition hybi13.hpp:563
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
Definition hybi13.hpp:185
lib::error_code process_handshake_key(std::string &key) const
Convert a client handshake key into a server response key in place.
Definition hybi13.hpp:733
int get_version() const
Get the protocol version of this processor.
Definition hybi13.hpp:80
WebSocket protocol processor abstract base class.
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)=0
Prepare a data message for writing.
virtual size_t get_bytes_needed() const
virtual size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)=0
process new websocket connection bytes
virtual err_str_pair negotiate_extensions(response_type const &)
Initializes extensions based on the Sec-WebSocket-Extensions header.
virtual int get_version() const =0
Get the protocol version of this processor.
virtual std::string get_raw(response_type const &request) const =0
Given a completed response, get the raw bytes to put on the wire.
virtual bool ready() const =0
Checks if there is a message ready.
virtual lib::error_code validate_handshake(request_type const &request) const =0
validate a WebSocket handshake request for this version
virtual uri_ptr get_uri(request_type const &request) const =0
Extracts client uri from a handshake request.
virtual err_str_pair negotiate_extensions(request_type const &)
Initializes extensions based on the Sec-WebSocket-Extensions header.
virtual bool has_permessage_compress() const
Returns whether or not the permessage_compress extension is implemented.
virtual lib::error_code validate_server_handshake_response(request_type const &req, response_type &res) const =0
Validate the server's response to an outgoing handshake request.
virtual lib::error_code client_handshake_request(request_type &req, uri_ptr uri, std::vector< std::string > const &subprotocols) const =0
Fill in an HTTP request for an outgoing connection handshake.
virtual lib::error_code extract_subprotocols(const request_type &req, std::vector< std::string > &subprotocol_list)=0
Extracts requested subprotocols from a handshake request.
virtual bool get_error() const =0
Tests whether the processor is in a fatal error state.
void set_max_message_size(size_t new_value)
Set maximum message size.
virtual std::string const & get_origin(request_type const &request) const =0
Return the value of the header containing the CORS origin.
size_t get_max_message_size() const
Get maximum message size.
virtual message_ptr get_message()=0
Retrieves the most recently processed message.
Thread safe stub "random" integer generator.
Definition none.hpp:46
int_type operator()()
advances the engine's state and returns the generated value
Definition none.hpp:51
Server endpoint role based on the given config.
void start_accept(lib::error_code &ec)
Starts the server's async connection acceptance loop (exception free)
transport_type::transport_con_type transport_con_type
Type of the connection transport component.
config::transport_type transport_type
Type of the endpoint transport component.
transport_con_type::ptr transport_con_ptr
Type of a shared pointer to the connection transport component.
connection< config > connection_type
Type of the connections this server will create.
endpoint< connection_type, config > endpoint_type
Type of the endpoint component of this server.
connection_ptr get_connection()
Create and initialize a new connection.
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
server< config > type
Type of this endpoint.
config::concurrency_type concurrency_type
Type of the endpoint concurrency component.
void start_accept()
Starts the server's async connection acceptance loop.
connection_type::ptr connection_ptr
Type of a shared pointer to the connections this server will create.
Basic Asio connection socket component.
Definition none.hpp:58
lib::asio::ip::tcp::socket socket_type
Type of the ASIO socket being used.
Definition none.hpp:70
lib::asio::ip::tcp::socket & get_raw_socket()
Retrieve a pointer to the underlying socket.
Definition none.hpp:124
void set_socket_init_handler(socket_init_handler h)
Set the socket initialization handler.
Definition none.hpp:100
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service strand being used.
Definition none.hpp:68
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
Definition none.hpp:66
lib::asio::ip::tcp::socket & get_socket()
Retrieve a pointer to the underlying socket.
Definition none.hpp:108
bool is_secure() const
Check whether or not this connection is secure.
Definition none.hpp:88
connection type
Type of this connection socket component.
Definition none.hpp:61
static lib::error_code translate_ec(lib::error_code ec)
Definition none.hpp:292
static lib::error_code translate_ec(ErrorCodeType)
Translate any security policy specific information about an error code.
Definition none.hpp:284
void set_handle(connection_hdl hdl)
Sets the connection handle.
Definition none.hpp:234
lib::asio::error_code cancel_socket()
Cancel all async operations on this socket.
Definition none.hpp:247
lib::shared_ptr< socket_type > socket_ptr
Type of a shared pointer to the socket being used.
Definition none.hpp:72
void pre_init(init_handler callback)
Pre-initialize security policy.
Definition none.hpp:204
std::string get_remote_endpoint(lib::error_code &ec) const
Get the remote endpoint address.
Definition none.hpp:138
void post_init(init_handler callback)
Post-initialize security policy.
Definition none.hpp:223
lib::error_code init_asio(io_service_ptr service, strand_ptr, bool)
Perform one time initializations.
Definition none.hpp:165
ptr get_shared()
Get a shared pointer to this component.
Definition none.hpp:80
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection socket component.
Definition none.hpp:63
lib::asio::ip::tcp::socket & get_next_layer()
Retrieve a pointer to the underlying socket.
Definition none.hpp:116
Basic ASIO endpoint socket component.
Definition none.hpp:317
void set_socket_init_handler(socket_init_handler h)
Set socket init handler.
Definition none.hpp:346
endpoint type
The type of this endpoint socket component.
Definition none.hpp:320
lib::error_code init(socket_con_ptr scon)
Initialize a connection.
Definition none.hpp:359
connection socket_con_type
The type of the corresponding connection socket component.
Definition none.hpp:323
bool is_secure() const
Checks whether the endpoint creates secure connections.
Definition none.hpp:334
Asio based connection transport component.
void set_proxy_timeout(long duration)
Set the proxy timeout duration (exception)
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
void set_proxy_timeout(long duration, lib::error_code &ec)
Set the proxy timeout duration (exception free)
strand_ptr get_strand()
Get a pointer to this connection's strand.
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
read at least num_bytes bytes into buf and then call handler.
lib::error_code interrupt(interrupt_handler handler)
Trigger the on_interrupt handler.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
void handle_async_write(write_handler handler, lib::asio::error_code const &ec, size_t)
Async write callback.
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer callback.
lib::error_code init_asio(io_service_ptr io_service)
Finish constructing the transport.
config::socket_type::socket_con_type socket_con_type
Type of the socket connection component.
void handle_post_init(timer_ptr post_timer, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
lib::shared_ptr< lib::asio::io_service::strand > strand_ptr
Type of a pointer to the Asio io_service::strand being used.
void async_shutdown(shutdown_handler callback)
close and clean up the underlying socket
config::alog_type alog_type
Type of this transport's access logging policy.
lib::asio::error_code get_transport_ec() const
Get the internal transport error code for a closed/failed connection.
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of a pointer to the Asio timer class.
void handle_post_init_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Post init timeout callback.
void handle_async_shutdown_timeout(timer_ptr, init_handler callback, lib::error_code const &ec)
Async shutdown timeout handler.
void async_write(const char *buf, size_t len, write_handler handler)
Initiate a potentially asyncronous write of the given buffer.
void async_write(std::vector< buffer > const &bufs, write_handler handler)
Initiate a potentially asyncronous write of the given buffers.
connection< config > type
Type of this connection transport component.
lib::asio::io_service * io_service_ptr
Type of a pointer to the Asio io_service being used.
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
void handle_proxy_read(init_handler callback, lib::asio::error_code const &ec, size_t)
Proxy read callback.
void set_uri(uri_ptr u)
Set uri hook.
std::string get_remote_endpoint() const
Get the remote endpoint address.
ptr get_shared()
Get a shared pointer to this component.
void cancel_socket_checked()
Cancel the underlying socket and log any errors.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
config::elog_type elog_type
Type of this transport's error logging policy.
void init(init_handler callback)
Initialize transport for reading.
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
connection_hdl get_handle() const
Get the connection handle.
Asio based endpoint transport component.
Definition base.hpp:143
std::size_t run_one()
wraps the run_one method of the internal io_service object
Definition endpoint.hpp:648
void stop_listening(lib::error_code &ec)
Stop listening (exception free)
Definition endpoint.hpp:604
config::concurrency_type concurrency_type
Type of the concurrency policy.
Definition endpoint.hpp:60
asio::connection< config > transport_con_type
Definition endpoint.hpp:75
void async_connect(transport_con_ptr tcon, uri_ptr u, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:849
void init_asio()
Initialize asio transport with internal io_service.
Definition endpoint.hpp:249
void init_logging(const lib::shared_ptr< alog_type > &a, const lib::shared_ptr< elog_type > &e)
Initialize logging.
Definition endpoint.hpp:823
bool is_secure() const
Return whether or not the endpoint produces secure connections.
Definition endpoint.hpp:172
void init_asio(io_service_ptr ptr)
initialize asio transport with external io_service
Definition endpoint.hpp:212
lib::asio::ip::tcp::endpoint get_local_endpoint(lib::asio::error_code &ec)
Get local TCP endpoint.
Definition endpoint.hpp:395
socket_type::socket_con_type socket_con_type
Type of the socket connection component.
Definition endpoint.hpp:69
void set_reuse_addr(bool value)
Sets whether to use the SO_REUSEADDR flag when opening listening sockets.
Definition endpoint.hpp:363
void set_tcp_init_handler(tcp_init_handler h)
Sets the tcp pre init handler (deprecated)
Definition endpoint.hpp:302
void handle_timer(timer_ptr, timer_handler callback, lib::asio::error_code const &ec)
Timer handler.
Definition endpoint.hpp:745
void start_perpetual()
Marks the endpoint as perpetual, stopping it from exiting when empty.
Definition endpoint.hpp:689
void stop()
wraps the stop method of the internal io_service object
Definition endpoint.hpp:653
std::size_t run()
wraps the run method of the internal io_service object
Definition endpoint.hpp:640
config::socket_type socket_type
Type of the socket policy.
Definition endpoint.hpp:62
socket_con_type::ptr socket_con_ptr
Type of a shared pointer to the socket connection component.
Definition endpoint.hpp:71
config::elog_type elog_type
Type of the error logging policy.
Definition endpoint.hpp:64
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:78
void set_tcp_post_init_handler(tcp_init_handler h)
Sets the tcp post init handler.
Definition endpoint.hpp:317
void set_listen_backlog(int backlog)
Sets the maximum length of the queue of pending connections.
Definition endpoint.hpp:342
bool stopped() const
wraps the stopped method of the internal io_service object
Definition endpoint.hpp:673
timer_ptr set_timer(long duration, timer_handler callback)
Call back a function after a period of time.
Definition endpoint.hpp:717
void init_asio(io_service_ptr ptr, lib::error_code &ec)
initialize asio transport with external io_service (exception free)
Definition endpoint.hpp:185
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
void init_asio(lib::error_code &ec)
Initialize asio transport with internal io_service (exception free)
Definition endpoint.hpp:227
void async_accept(transport_con_ptr tcon, accept_handler callback)
Accept the next connection attempt and assign it to con.
Definition endpoint.hpp:807
void listen(uint16_t port)
Set up endpoint for listening on a port.
Definition endpoint.hpp:536
lib::shared_ptr< lib::asio::steady_timer > timer_ptr
Type of timer handle.
Definition endpoint.hpp:87
lib::asio::io_service & get_io_service()
Retrieve a reference to the endpoint's io_service.
Definition endpoint.hpp:378
std::size_t poll()
wraps the poll method of the internal io_service object
Definition endpoint.hpp:658
void stop_perpetual()
Clears the endpoint's perpetual flag, allowing it to exit when empty.
Definition endpoint.hpp:701
endpoint< config > type
Type of this endpoint transport component.
Definition endpoint.hpp:57
lib::shared_ptr< lib::asio::ip::tcp::resolver > resolver_ptr
Type of a shared pointer to the resolver being used.
Definition endpoint.hpp:85
void listen(lib::asio::ip::tcp::endpoint const &ep)
Set up endpoint for listening manually.
Definition endpoint.hpp:460
void handle_resolve_timeout(timer_ptr, connect_handler callback, lib::error_code const &ec)
DNS resolution timeout handler.
Definition endpoint.hpp:944
void listen(lib::asio::ip::tcp::endpoint const &ep, lib::error_code &ec)
Set up endpoint for listening manually (exception free)
Definition endpoint.hpp:412
lib::function< lib::error_code(acceptor_ptr)> tcp_pre_bind_handler
Type of socket pre-bind handler.
Definition endpoint.hpp:92
lib::shared_ptr< lib::asio::io_service::work > work_ptr
Type of a shared pointer to an io_service work object.
Definition endpoint.hpp:89
void reset()
wraps the reset method of the internal io_service object
Definition endpoint.hpp:668
void set_tcp_pre_bind_handler(tcp_pre_bind_handler h)
Sets the tcp pre bind handler.
Definition endpoint.hpp:274
void listen(InternetProtocol const &internet_protocol, uint16_t port)
Set up endpoint for listening with protocol and port.
Definition endpoint.hpp:502
lib::asio::io_service * io_service_ptr
Type of a pointer to the ASIO io_service being used.
Definition endpoint.hpp:81
void set_tcp_pre_init_handler(tcp_init_handler h)
Sets the tcp pre init handler.
Definition endpoint.hpp:288
lib::shared_ptr< lib::asio::ip::tcp::acceptor > acceptor_ptr
Type of a shared pointer to the acceptor being used.
Definition endpoint.hpp:83
void handle_connect_timeout(transport_con_ptr tcon, timer_ptr, connect_handler callback, lib::error_code const &ec)
Asio connect timeout handler.
void async_accept(transport_con_ptr tcon, accept_handler callback, lib::error_code &ec)
Accept the next connection attempt and assign it to con (exception free)
Definition endpoint.hpp:768
std::size_t poll_one()
wraps the poll_one method of the internal io_service object
Definition endpoint.hpp:663
void listen(InternetProtocol const &internet_protocol, uint16_t port, lib::error_code &ec)
Set up endpoint for listening with protocol and port (exception free)
Definition endpoint.hpp:481
void listen(uint16_t port, lib::error_code &ec)
Set up endpoint for listening on a port (exception free)
Definition endpoint.hpp:520
config::alog_type alog_type
Type of the access logging policy.
Definition endpoint.hpp:66
bool is_listening() const
Check if the endpoint is listening.
Definition endpoint.hpp:635
void stop_listening()
Stop listening.
Definition endpoint.hpp:625
Asio transport error category.
Definition base.hpp:184
Error category related to asio transport socket policies.
Definition base.hpp:110
connection_hdl get_handle() const
Get the connection handle.
lib::error_code dispatch(dispatch_handler handler)
Call given handler back within the transport's event system (if present)
config::concurrency_type concurrency_type
transport concurrency policy
void async_shutdown(transport::shutdown_handler handler)
Perform cleanup on socket shutdown_handler.
void set_write_handler(write_handler h)
Sets the write handler.
void set_secure(bool value)
Set whether or not this connection is secure.
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
void fatal_error()
Signal transport error.
size_t read_some(char const *buf, size_t len)
Manual input supply (read some)
size_t read_all(char const *buf, size_t len)
Manual input supply (read all)
config::elog_type elog_type
Type of this transport's error logging policy.
lib::shared_ptr< type > ptr
Type of a shared pointer to this connection transport component.
config::alog_type alog_type
Type of this transport's access logging policy.
void async_write(char const *buf, size_t len, transport::write_handler handler)
Asyncronous Transport Write.
size_t readsome(char const *buf, size_t len)
Manual input supply (DEPRECATED)
void init(init_handler handler)
Initialize the connection transport.
timer_ptr set_timer(long, timer_handler)
Call back a function after a period of time.
friend std::istream & operator>>(std::istream &in, type &t)
Overloaded stream input operator.
void set_vector_write_handler(vector_write_handler h)
Sets the vectored write handler.
bool is_secure() const
Tests whether or not the underlying transport is secure.
std::string get_remote_endpoint() const
Get human readable remote endpoint address.
void set_handle(connection_hdl hdl)
Set Connection Handle.
void register_ostream(std::ostream *o)
Register a std::ostream with the transport for writing output.
void async_read_at_least(size_t num_bytes, char *buf, size_t len, read_handler handler)
Initiate an async_read for at least num_bytes bytes into buf.
void async_write(std::vector< buffer > const &bufs, transport::write_handler handler)
Asyncronous Transport Write (scatter-gather)
ptr get_shared()
Get a shared pointer to this component.
connection< config > type
Type of this connection transport component.
transport_con_type::ptr transport_con_ptr
Definition endpoint.hpp:65
void set_write_handler(write_handler h)
Sets the write handler.
Definition endpoint.hpp:134
config::concurrency_type concurrency_type
Type of this endpoint's concurrency policy.
Definition endpoint.hpp:54
void set_shutdown_handler(shutdown_handler h)
Sets the shutdown handler.
Definition endpoint.hpp:154
bool is_secure() const
Tests whether or not the underlying transport is secure.
Definition endpoint.hpp:116
void async_connect(transport_con_ptr, uri_ptr, connect_handler cb)
Initiate a new connection.
Definition endpoint.hpp:183
config::alog_type alog_type
Type of this endpoint's access logging policy.
Definition endpoint.hpp:58
lib::error_code init(transport_con_ptr tcon)
Initialize a connection.
Definition endpoint.hpp:197
void init_logging(lib::shared_ptr< alog_type > a, lib::shared_ptr< elog_type > e)
Initialize logging.
Definition endpoint.hpp:171
endpoint type
Type of this endpoint transport component.
Definition endpoint.hpp:49
iostream::connection< config > transport_con_type
Definition endpoint.hpp:62
void register_ostream(std::ostream *o)
Register a default output stream.
Definition endpoint.hpp:80
void set_secure(bool value)
Set whether or not endpoint can create secure connections.
Definition endpoint.hpp:102
config::elog_type elog_type
Type of this endpoint's error logging policy.
Definition endpoint.hpp:56
lib::shared_ptr< type > ptr
Type of a pointer to this endpoint transport component.
Definition endpoint.hpp:51
iostream transport error category
Definition base.hpp:85
std::string get_query() const
Return the query portion.
Definition uri.hpp:294
Provides streaming UTF8 validation functionality.
bool decode(iterator_type begin, iterator_type end)
Advance validator state with input from an iterator pair.
validator()
Construct and initialize the validator.
bool complete()
Return whether the input sequence ended on a valid utf8 codepoint.
void reset()
Reset the validator to decode another message.
bool consume(uint8_t byte)
Advance the state of the validator with the next input byte.
#define _WEBSOCKETPP_CONSTEXPR_TOKEN_
Definition cpp11.hpp:132
#define _WEBSOCKETPP_NOEXCEPT_TOKEN_
Definition cpp11.hpp:113
#define __has_extension
Definition cpp11.hpp:40
#define __has_feature(x)
Definition cpp11.hpp:37
#define ZSW_MD5_BYTE_ORDER
Definition md5.hpp:101
#define ZSW_MD5_T54
Definition md5.hpp:158
#define ZSW_MD5_T40
Definition md5.hpp:144
#define ZSW_MD5_T55
Definition md5.hpp:159
#define ZSW_MD5_T29
Definition md5.hpp:133
#define ZSW_MD5_T37
Definition md5.hpp:141
#define ZSW_MD5_T5
Definition md5.hpp:109
#define ZSW_MD5_T44
Definition md5.hpp:148
#define ZSW_MD5_T52
Definition md5.hpp:156
#define ZSW_MD5_T20
Definition md5.hpp:124
#define ZSW_MD5_T26
Definition md5.hpp:130
#define ZSW_MD5_T33
Definition md5.hpp:137
#define ZSW_MD5_T8
Definition md5.hpp:112
#define ZSW_MD5_T36
Definition md5.hpp:140
#define ZSW_MD5_H(x, y, z)
#define ZSW_MD5_T50
Definition md5.hpp:154
#define ZSW_MD5_T61
Definition md5.hpp:165
#define ZSW_MD5_T12
Definition md5.hpp:116
#define ZSW_MD5_I(x, y, z)
#define ZSW_MD5_T_MASK
Definition md5.hpp:104
#define ZSW_MD5_T35
Definition md5.hpp:139
#define ZSW_MD5_T63
Definition md5.hpp:167
#define ZSW_MD5_T1
Definition md5.hpp:105
#define ZSW_MD5_T53
Definition md5.hpp:157
#define ZSW_MD5_T41
Definition md5.hpp:145
#define ZSW_MD5_T60
Definition md5.hpp:164
#define ZSW_MD5_T11
Definition md5.hpp:115
#define ZSW_MD5_T39
Definition md5.hpp:143
#define ZSW_MD5_T21
Definition md5.hpp:125
#define ZSW_MD5_T2
Definition md5.hpp:106
#define ZSW_MD5_T16
Definition md5.hpp:120
#define ZSW_MD5_T57
Definition md5.hpp:161
#define ZSW_MD5_T32
Definition md5.hpp:136
#define SET(a, b, c, d, k, s, Ti)
#define ZSW_MD5_T47
Definition md5.hpp:151
#define ZSW_MD5_T28
Definition md5.hpp:132
#define ZSW_MD5_T46
Definition md5.hpp:150
#define ZSW_MD5_T58
Definition md5.hpp:162
#define ZSW_MD5_T62
Definition md5.hpp:166
#define ZSW_MD5_T13
Definition md5.hpp:117
#define ZSW_MD5_T7
Definition md5.hpp:111
#define ZSW_MD5_T31
Definition md5.hpp:135
#define ZSW_MD5_T6
Definition md5.hpp:110
#define ZSW_MD5_G(x, y, z)
#define ZSW_MD5_T48
Definition md5.hpp:152
#define ZSW_MD5_T15
Definition md5.hpp:119
#define ZSW_MD5_T43
Definition md5.hpp:147
#define ZSW_MD5_T10
Definition md5.hpp:114
#define ZSW_MD5_T34
Definition md5.hpp:138
#define ZSW_MD5_T4
Definition md5.hpp:108
#define ZSW_MD5_T22
Definition md5.hpp:126
#define ZSW_MD5_T64
Definition md5.hpp:168
#define ZSW_MD5_T14
Definition md5.hpp:118
#define ZSW_MD5_T25
Definition md5.hpp:129
#define ZSW_MD5_T38
Definition md5.hpp:142
#define ZSW_MD5_T3
Definition md5.hpp:107
#define ZSW_MD5_T45
Definition md5.hpp:149
#define ZSW_MD5_T17
Definition md5.hpp:121
#define ZSW_MD5_T24
Definition md5.hpp:128
#define ZSW_MD5_F(x, y, z)
#define ZSW_MD5_T59
Definition md5.hpp:163
#define ZSW_MD5_T18
Definition md5.hpp:122
#define ZSW_MD5_T9
Definition md5.hpp:113
#define ZSW_MD5_T27
Definition md5.hpp:131
#define ZSW_MD5_T56
Definition md5.hpp:160
#define ZSW_MD5_T23
Definition md5.hpp:127
#define ZSW_MD5_T19
Definition md5.hpp:123
#define ZSW_MD5_T30
Definition md5.hpp:134
#define ZSW_MD5_T51
Definition md5.hpp:155
#define ZSW_MD5_ROTATE_LEFT(x, n)
#define ZSW_MD5_T49
Definition md5.hpp:153
#define ZSW_MD5_T42
Definition md5.hpp:146
A package of types and methods for manipulating WebSocket close status'.
Definition close.hpp:47
static value const service_restart
Definition close.hpp:138
static value const message_too_big
An endpoint received a message too large to process.
Definition close.hpp:121
static value const try_again_later
Definition close.hpp:143
static value const force_tcp_drop
Close the connection with a forced TCP drop.
Definition close.hpp:72
static value const tls_handshake
An endpoint failed to perform a TLS handshake.
Definition close.hpp:157
static value const rsv_end
Last value in range reserved for future protocol use.
Definition close.hpp:177
static value const invalid_payload
An endpoint received message data inconsistent with its type.
Definition close.hpp:110
bool terminal(value code)
Determine if the code represents an unrecoverable error.
Definition close.hpp:217
static value const protocol_error
A protocol error occurred.
Definition close.hpp:83
std::string get_string(value code)
Return a human readable interpretation of a WebSocket close code.
Definition close.hpp:232
static value const bad_gateway
Definition close.hpp:148
static value const invalid_subprotocol_data
A invalid subprotocol data.
Definition close.hpp:172
static value const invalid_high
Last value in range that is always invalid on the wire.
Definition close.hpp:192
static value const unsupported_data
Definition close.hpp:91
static value const no_status
A dummy value to indicate that no status code was received.
Definition close.hpp:97
static value const omit_handshake
Close the connection without a WebSocket close handshake.
Definition close.hpp:62
static value const normal
Definition close.hpp:76
static value const blank
A blank value for internal use.
Definition close.hpp:52
static value const invalid_low
First value in range that is always invalid on the wire.
Definition close.hpp:190
static value const abnormal_close
A dummy value to indicate that the connection was closed abnormally.
Definition close.hpp:104
static value const rsv_start
First value in range reserved for future protocol use.
Definition close.hpp:175
uint16_t value
The type of a close code value.
Definition close.hpp:49
static value const policy_violation
An endpoint received a message that violated its policy.
Definition close.hpp:118
static value const extension_required
A client expected the server to accept a required extension request.
Definition close.hpp:129
bool invalid(value code)
Test whether a close code is invalid on the wire.
Definition close.hpp:199
static value const internal_endpoint_error
Definition close.hpp:133
static value const subprotocol_error
A generic subprotocol error.
Definition close.hpp:165
bool reserved(value code)
Test whether a close code is in a reserved range.
Definition close.hpp:184
static value const going_away
Definition close.hpp:80
A package of types and methods for manipulating WebSocket close codes.
Definition close.hpp:45
Concurrency handling support.
Definition basic.hpp:34
Library level error codes.
Definition error.hpp:44
@ general
Catch-all library error.
Definition error.hpp:47
@ unrequested_subprotocol
Selected subprotocol was not requested by the client.
Definition error.hpp:102
@ invalid_port
Invalid port in URI.
Definition error.hpp:120
@ client_only
Attempted to use a client specific feature on a server endpoint.
Definition error.hpp:105
@ http_connection_ended
HTTP connection ended.
Definition error.hpp:111
@ operation_canceled
The requested operation was canceled.
Definition error.hpp:127
@ no_outgoing_buffers
The endpoint is out of outgoing message buffers.
Definition error.hpp:68
@ http_parse_error
HTTP parse error.
Definition error.hpp:143
@ reserved_close_code
Close code is in a reserved range.
Definition error.hpp:80
@ con_creation_failed
Connection creation attempted failed.
Definition error.hpp:99
@ no_incoming_buffers
The endpoint is out of incoming message buffers.
Definition error.hpp:71
@ invalid_state
The connection was in the wrong state for this operation.
Definition error.hpp:74
@ extension_neg_failed
Extension negotiation failed.
Definition error.hpp:146
@ rejected
Connection rejected.
Definition error.hpp:130
@ unsupported_version
Unsupported WebSocket protocol version.
Definition error.hpp:140
@ invalid_utf8
Invalid UTF-8.
Definition error.hpp:86
@ invalid_close_code
Close code is invalid.
Definition error.hpp:83
@ server_only
Attempted to use a server specific feature on a client endpoint.
Definition error.hpp:108
@ endpoint_not_secure
Attempted to open a secure connection with an insecure endpoint.
Definition error.hpp:57
@ close_handshake_timeout
WebSocket close handshake timed out.
Definition error.hpp:117
@ invalid_subprotocol
Invalid subprotocol.
Definition error.hpp:89
@ bad_close_code
Unable to parse close code.
Definition error.hpp:77
@ open_handshake_timeout
WebSocket opening handshake timed out.
Definition error.hpp:114
@ invalid_version
Invalid WebSocket protocol version.
Definition error.hpp:137
@ send_queue_full
send attempted when endpoint write queue was full
Definition error.hpp:50
@ test
Unit testing utility error code.
Definition error.hpp:96
@ invalid_uri
An invalid uri was supplied.
Definition error.hpp:65
Implementation of RFC 7692, the permessage-deflate WebSocket extension.
Definition disabled.hpp:44
Constants related to frame and payload limits.
Definition frame.hpp:145
static uint8_t const close_reason_size
Maximum size of close frame reason.
Definition frame.hpp:169
static uint64_t const payload_size_jumbo
Maximum size of a jumbo WebSocket payload (basic payload = 127)
Definition frame.hpp:162
static unsigned int const max_extended_header_length
Maximum length of the variable portion of the WebSocket header.
Definition frame.hpp:153
static unsigned int const max_header_length
Maximum length of a WebSocket header.
Definition frame.hpp:150
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126)
Definition frame.hpp:159
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
Definition frame.hpp:156
static unsigned int const basic_header_length
Minimum length of a WebSocket frame header.
Definition frame.hpp:147
Constants and utility functions related to WebSocket opcodes.
Definition frame.hpp:76
bool invalid(value v)
Check if an opcode is invalid.
Definition frame.hpp:130
bool reserved(value v)
Check if an opcode is reserved.
Definition frame.hpp:118
bool is_control(value v)
Check if an opcode is for a control frame.
Definition frame.hpp:139
Data structures and utility functions for manipulating WebSocket frames.
Definition frame.hpp:45
unsigned int get_masking_key_offset(basic_header const &)
Calculate the offset location of the masking key within the extended header.
Definition frame.hpp:469
void set_rsv2(basic_header &h, bool value)
Set the frame's RSV2 bit.
Definition frame.hpp:366
static unsigned int const MAX_HEADER_LENGTH
Maximum length of a WebSocket header.
Definition frame.hpp:50
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
Definition frame.hpp:393
void set_rsv3(basic_header &h, bool value)
Set the frame's RSV3 bit.
Definition frame.hpp:384
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
Definition frame.hpp:573
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
Definition frame.hpp:431
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
Definition frame.hpp:830
void byte_mask(input_iter b, input_iter e, output_iter o, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask.
Definition frame.hpp:645
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
Definition frame.hpp:52
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
Definition frame.hpp:375
bool get_masked(basic_header const &h)
check whether the frame is masked
Definition frame.hpp:402
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
Definition frame.hpp:357
void byte_mask(iter_type b, iter_type e, masking_key_type const &key, size_t key_offset=0)
Byte by byte mask/unmask (in place)
Definition frame.hpp:675
uint16_t get_extended_size(extended_header const &)
Extract the extended size field from an extended header.
Definition frame.hpp:540
size_t byte_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask (in place)
Definition frame.hpp:857
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
Definition frame.hpp:321
size_t circshift_prepared_key(size_t prepared_key, size_t offset)
circularly shifts the supplied prepared masking key by offset bytes
Definition frame.hpp:612
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
Definition frame.hpp:339
void set_masked(basic_header &h, bool value)
Set the frame's MASK bit.
Definition frame.hpp:411
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
Definition frame.hpp:768
void word_mask_exact(uint8_t *data, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask (in place)
Definition frame.hpp:731
void set_rsv1(basic_header &h, bool value)
Set the frame's RSV1 bit.
Definition frame.hpp:348
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Definition frame.hpp:445
void set_fin(basic_header &h, bool value)
Set the frame's FIN bit.
Definition frame.hpp:330
uint64_t get_jumbo_size(extended_header const &)
Extract the jumbo size field from an extended header.
Definition frame.hpp:555
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
Definition frame.hpp:702
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
Definition frame.hpp:489
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
Definition frame.hpp:516
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
Definition frame.hpp:48
size_t word_mask_circ(uint8_t *data, size_t length, size_t prepared_key)
Circular word aligned mask/unmask (in place)
Definition frame.hpp:805
size_t prepare_masking_key(masking_key_type const &key)
Extract a masking key into a value the size of a machine word.
Definition frame.hpp:595
HTTP handling support.
Definition request.hpp:37
size_t const max_body_size
Default Maximum size in bytes for HTTP message bodies.
Definition constants.hpp:68
static char const header_separator[]
Literal value of the HTTP header separator.
Definition constants.hpp:59
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
Definition constants.hpp:53
size_t const istream_buffer
Number of bytes to use for temporary istream read buffers.
Definition constants.hpp:71
bool is_not_token_char(unsigned char c)
Is the character a non-token.
size_t const max_header_size
Maximum size in bytes before rejecting an HTTP header as too big.
Definition constants.hpp:65
static char const header_delimiter[]
Literal value of the HTTP header delimiter.
Definition constants.hpp:56
bool is_whitespace_char(unsigned char c)
Is the character whitespace.
static char const header_token[]
invalid HTTP token characters
Definition constants.hpp:78
bool is_not_whitespace_char(unsigned char c)
Is the character non-whitespace.
std::map< std::string, std::string > attribute_list
The type of an HTTP attribute list.
Definition constants.hpp:45
bool is_token_char(unsigned char c)
Is the character a token.
Definition constants.hpp:98
static std::string const empty_header
Literal value of an empty header.
Definition constants.hpp:62
Provides MD5 hashing functionality.
Definition md5.hpp:76
Constants related to processing WebSocket connections.
Definition base.hpp:44
Processor class related error codes.
Definition base.hpp:54
Error code category and codes used by all processor types.
Definition base.hpp:65
lib::error_category const & get_processor_category()
Get a reference to a static copy of the processor error category.
Definition base.hpp:238
close::status::value to_ws(lib::error_code ec)
Converts a processor error_code into a websocket close code.
Definition base.hpp:261
@ missing_required_header
Missing Required Header.
Definition base.hpp:129
@ control_too_big
Control frame too large.
Definition base.hpp:90
@ invalid_http_method
Invalid HTTP method.
Definition base.hpp:120
@ invalid_rsv_bit
Illegal use of reserved bit.
Definition base.hpp:93
@ reason_requires_code
Using a reason requires a close code.
Definition base.hpp:144
@ invalid_close_code
Invalid close code used.
Definition base.hpp:141
@ masking_required
Clients may not send unmasked frames.
Definition base.hpp:102
@ protocol_violation
Processor encountered a protocol violation in an incoming message.
Definition base.hpp:75
@ extensions_disabled
Extension related operation was ignored because extensions are disabled.
Definition base.hpp:153
@ reserved_close_code
Reserved close code used.
Definition base.hpp:138
@ extension_parse_error
Error parsing extensions.
Definition base.hpp:150
@ masking_forbidden
Servers may not send masked frames.
Definition base.hpp:105
@ not_implemented
Operation required not implemented functionality.
Definition base.hpp:117
@ invalid_opcode
Opcode was invalid for requested operation.
Definition base.hpp:87
@ sha1_library
Embedded SHA-1 library error.
Definition base.hpp:132
@ requires_64bit
Not supported on 32 bit systems.
Definition base.hpp:111
@ subprotocol_parse_error
Error parsing subprotocols.
Definition base.hpp:147
@ bad_request
Error was the result of improperly formatted user input.
Definition base.hpp:72
@ invalid_utf8
Invalid UTF-8 encoding.
Definition base.hpp:114
@ invalid_http_status
Invalid HTTP status.
Definition base.hpp:126
@ invalid_payload
Processor encountered invalid payload data.
Definition base.hpp:81
@ invalid_http_version
Invalid HTTP version.
Definition base.hpp:123
@ message_too_big
Processor encountered a message that was too large.
Definition base.hpp:78
@ no_protocol_support
No support for this feature in this protocol version.
Definition base.hpp:135
@ invalid_arguments
The processor method was called with invalid arguments.
Definition base.hpp:84
@ invalid_continuation
Continuation without message.
Definition base.hpp:99
@ non_minimal_encoding
Payload length not minimally encoded.
Definition base.hpp:108
@ fragmented_control
Fragmented control message.
Definition base.hpp:96
lib::error_code make_error_code(error::processor_errors e)
Create an error code with the given value and the processor category.
Definition base.hpp:244
Processors encapsulate the protocol rules specific to each WebSocket version.
Definition processor.hpp:59
int get_websocket_version(request_type &r)
Extract the version from a WebSocket handshake request.
bool is_websocket_handshake(request_type &r)
Determine whether or not a generic HTTP request is a WebSocket handshake.
Definition processor.hpp:68
Stub RNG policy that always returns 0.
Definition none.hpp:35
Random number generation policies.
lib::function< void(connection_hdl, lib::asio::ip::tcp::socket &)> socket_init_handler
The signature of the socket init handler for this socket policy.
Definition none.hpp:51
Asio transport errors.
Definition base.hpp:161
lib::error_category const & get_category()
Get a reference to a static copy of the asio transport error category.
Definition base.hpp:211
lib::error_code make_error_code(error::value e)
Create an error code with the given value and the asio transport category.
Definition base.hpp:217
@ proxy_invalid
Invalid Proxy URI.
Definition base.hpp:177
@ pass_through
there was an error in the underlying transport library
Definition base.hpp:171
@ proxy_failed
The connection to the requested proxy server failed.
Definition base.hpp:174
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition base.hpp:168
@ invalid_host_service
Invalid host or service.
Definition base.hpp:180
Errors related to asio transport sockets.
Definition base.hpp:75
@ missing_tls_init_handler
Required tls_init handler not present.
Definition base.hpp:99
@ invalid_state
A function was called in a state that it was illegal to do so.
Definition base.hpp:86
@ tls_failed_sni_hostname
Failed to set TLS SNI hostname.
Definition base.hpp:105
@ tls_handshake_failed
TLS Handshake Failed.
Definition base.hpp:102
@ tls_handshake_timeout
TLS Handshake Timeout.
Definition base.hpp:93
@ pass_through
pass_through from underlying library
Definition base.hpp:96
Transport policy that uses asio.
Definition endpoint.hpp:46
Generic transport related errors.
@ pass_through
underlying transport pass through
@ operation_not_supported
Operation not supported.
@ operation_aborted
Operation aborted.
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
@ action_after_shutdown
read or write after shutdown
@ tls_short_read
TLS short read.
@ double_read
async_read called while another async_read was in progress
iostream transport errors
Definition base.hpp:64
@ invalid_num_bytes
async_read_at_least call requested more bytes than buffer can store
Definition base.hpp:71
@ double_read
async_read called while another async_read was in progress
Definition base.hpp:74
lib::error_code make_error_code(error::value e)
Get an error code with the given value and the iostream transport category.
Definition base.hpp:118
lib::error_category const & get_category()
Get a reference to a static copy of the iostream transport error category.
Definition base.hpp:112
Transport policy that uses STL iostream for I/O and does not support timers.
Definition endpoint.hpp:43
lib::function< lib::error_code(connection_hdl, std::vector< transport::buffer > const &bufs)> vector_write_handler
Definition base.hpp:57
lib::function< lib::error_code(connection_hdl)> shutdown_handler
Definition base.hpp:61
lib::function< lib::error_code(connection_hdl, char const *, size_t)> write_handler
The type and signature of the callback used by iostream transport to write.
Definition base.hpp:48
Transport policies provide network connectivity and timers.
Definition endpoint.hpp:45
lib::function< void(lib::error_code const &, size_t)> read_handler
The type and signature of the callback passed to the read method.
lib::function< void()> dispatch_handler
The type and signature of the callback passed to the dispatch method.
lib::function< void()> interrupt_handler
The type and signature of the callback passed to the interrupt method.
lib::function< void(lib::error_code const &)> accept_handler
The type and signature of the callback passed to the accept method.
Definition endpoint.hpp:69
lib::function< void(lib::error_code const &)> timer_handler
The type and signature of the callback passed to the read method.
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
lib::function< void(lib::error_code const &)> write_handler
The type and signature of the callback passed to the write method.
lib::function< void(lib::error_code const &)> init_handler
The type and signature of the callback passed to the init hook.
lib::function< void(lib::error_code const &)> shutdown_handler
The type and signature of the callback passed to the shutdown method.
Generic non-websocket specific utility functions and data structures.
Definition utilities.hpp:39
std::string to_hex(uint8_t const *input, size_t length)
Convert byte array (uint8_t) to ascii printed string of hex digits.
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive)
T::const_iterator ci_find_substr(T const &haystack, typename T::value_type const *needle, typename T::size_type size, std::locale const &loc=std::locale())
Find substring (case insensitive)
std::string to_hex(char const *input, size_t length)
Convert char array to ascii printed string of hex digits.
Namespace for the WebSocket++ project.
lib::function< void(connection_hdl, std::string)> pong_handler
The type and function signature of a pong handler.
lib::function< void(connection_hdl)> close_handler
The type and function signature of a close handler.
lib::function< void(connection_hdl, std::string)> pong_timeout_handler
The type and function signature of a pong timeout handler.
lib::function< void(connection_hdl)> http_handler
The type and function signature of a http handler.
lib::function< void(connection_hdl)> open_handler
The type and function signature of an open handler.
lib::function< void(connection_hdl)> interrupt_handler
The type and function signature of an interrupt handler.
static uint16_t const uri_default_secure_port
Default port for wss://.
Definition uri.hpp:47
lib::function< void(connection_hdl)> fail_handler
The type and function signature of a fail handler.
lib::weak_ptr< void > connection_hdl
A handle to uniquely identify a connection.
static uint16_t const uri_default_port
Default port for ws://.
Definition uri.hpp:45
lib::function< bool(connection_hdl, std::string)> ping_handler
The type and function signature of a ping handler.
static char const user_agent[]
Default user agent string.
Definition version.hpp:57
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition uri.hpp:352
std::pair< lib::error_code, std::string > err_str_pair
Combination error code / string type for returning two values.
Definition error.hpp:41
lib::function< bool(connection_hdl)> validate_handler
The type and function signature of a validate handler.
static bool is_base64(unsigned char c)
Test whether a character is a valid base64 character.
Definition base64.hpp:53
std::string base64_encode(unsigned char const *input, size_t len)
Encode a char buffer into a base64 string.
Definition base64.hpp:66
#define TYP_BIGE
Definition network.hpp:53
#define TYP_SMLE
Definition network.hpp:52
#define TYP_INIT
Definition network.hpp:51
Server config with asio transport and TLS disabled.
static const long timeout_socket_shutdown
Length of time to wait for socket shutdown.
Definition core.hpp:137
static const long timeout_connect
Length of time to wait for TCP connect.
Definition core.hpp:134
static const long timeout_dns_resolve
Length of time to wait for dns resolution.
Definition core.hpp:131
static const long timeout_proxy
Length of time to wait before a proxy handshake is aborted.
Definition core.hpp:121
static const long timeout_socket_pre_init
Default timer values (in ms)
Definition core.hpp:118
static const long timeout_socket_post_init
Length of time to wait for socket post-initialization.
Definition core.hpp:128
Server config with iostream transport.
Definition core.hpp:68
websocketpp::random::none::int_generator< uint32_t > rng_type
RNG policies.
Definition core.hpp:93
static const websocketpp::log::level elog_level
Default static error logging channels.
Definition core.hpp:176
websocketpp::transport::iostream::endpoint< transport_config > transport_type
Transport Endpoint Component.
Definition core.hpp:142
static const size_t max_http_body_size
Default maximum http body size.
Definition core.hpp:252
static const long timeout_open_handshake
Default timer values (in ms)
Definition core.hpp:152
static const size_t max_message_size
Default maximum message size.
Definition core.hpp:240
websocketpp::log::basic< concurrency_type, websocketpp::log::elevel > elog_type
Logging policies.
Definition core.hpp:88
static const bool drop_on_protocol_error
Drop connections immediately on protocol error.
Definition core.hpp:213
static const long timeout_close_handshake
Length of time before a closing handshake is aborted.
Definition core.hpp:154
static const websocketpp::log::level alog_level
Default static access logging channels.
Definition core.hpp:189
static const long timeout_pong
Length of time to wait for a pong after a ping.
Definition core.hpp:156
static const bool silent_close
Suppresses the return of detailed connection close information.
Definition core.hpp:228
static bool const enable_multithreading
Definition core.hpp:98
static const size_t connection_read_buffer_size
Size of the per-connection read buffer.
Definition core.hpp:204
static const bool enable_extensions
Global flag for enabling/disabling extensions.
Definition core.hpp:255
static const int client_version
WebSocket Protocol version to use as a client.
Definition core.hpp:164
The constant size component of a WebSocket frame header.
Definition frame.hpp:189
The variable size component of a WebSocket frame header.
Definition frame.hpp:235
Package of log levels for logging access events.
Definition levels.hpp:112
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition levels.hpp:164
static level const fail
One line for each failed WebSocket connection with details.
Definition levels.hpp:147
static level const none
Special aggregate value representing "no levels".
Definition levels.hpp:114
static level const debug_handshake
Extra information about opening handshakes.
Definition levels.hpp:137
static level const devel
Development messages (warning: very chatty)
Definition levels.hpp:141
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:152
static level const debug_close
Extra information about closing handshakes.
Definition levels.hpp:139
static level const frame_payload
One line per frame, includes the full message payload (warning: chatty)
Definition levels.hpp:129
static level const connect
Information about new connections.
Definition levels.hpp:121
static level const app
Special channel for application specific logs. Not used by the library.
Definition levels.hpp:143
static level const frame_header
One line per frame, includes the full frame header.
Definition levels.hpp:127
static level const message_payload
Reserved.
Definition levels.hpp:133
static level const endpoint
Reserved.
Definition levels.hpp:135
static level const message_header
Reserved.
Definition levels.hpp:131
static level const control
One line per control frame.
Definition levels.hpp:125
static level const disconnect
One line for each closed connection. Includes closing codes and reasons.
Definition levels.hpp:123
static level const access_core
Definition levels.hpp:150
static level const http
Access related to HTTP requests.
Definition levels.hpp:145
Package of values for hinting at the nature of a given logger.
Definition levels.hpp:46
static value const none
No information.
Definition levels.hpp:51
uint32_t value
Type of a channel type hint value.
Definition levels.hpp:48
static value const access
Access log.
Definition levels.hpp:53
static value const error
Error log.
Definition levels.hpp:55
Package of log levels for logging errors.
Definition levels.hpp:59
static level const devel
Low level debugging information (warning: very chatty)
Definition levels.hpp:63
static char const * channel_name(level channel)
Get the textual name of a channel given a channel id.
Definition levels.hpp:91
static level const library
Definition levels.hpp:66
static level const info
Definition levels.hpp:69
static level const all
Special aggregate value representing "all levels".
Definition levels.hpp:80
static level const fatal
Definition levels.hpp:78
static level const none
Special aggregate value representing "no levels".
Definition levels.hpp:61
static level const rerror
Definition levels.hpp:75
static level const warn
Definition levels.hpp:72
A simple utility buffer class.
Helper less than functor for case insensitive find.
Definition utilities.hpp:75
Helper functor for case insensitive find.
Definition utilities.hpp:49
bool operator()(charT ch1, charT ch2)
Perform a case insensitive comparison.
Definition utilities.hpp:63
my_equal(std::locale const &loc)
Construct the functor with the given locale.
Definition utilities.hpp:54
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
#define _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
Type used to convert close statuses between integer and wire representations.
Definition close.hpp:275
Two byte conversion union.
Definition frame.hpp:55
Four byte conversion union.
Definition frame.hpp:61
Eight byte conversion union.
Definition frame.hpp:67