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
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
97
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) {
108 ret.first = make_error_code(error::extensions_disabled);
109 return ret;
110 }
111
113
114 bool error = header.get_header_as_plist("Sec-WebSocket-Extensions",p);
115
116 if (error) {
117 ret.first = make_error_code(error::extension_parse_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") {
187 return make_error_code(error::invalid_http_method);
188 }
189
190 if (r.get_version() != "HTTP/1.1") {
191 return make_error_code(error::invalid_http_version);
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()) {
199 return make_error_code(error::missing_required_header);
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
232
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
282
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
356
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) -
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) {
440 ec = make_error_code(error::message_too_big);
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) {
458 ec = make_error_code(error::message_too_big);
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)) {
493 ec = finalize_message();
494 if (ec) {
495 break;
496 }
497 } else {
498 this->reset_headers();
499 }
500 } else {
501 // shouldn't be here
502 ec = make_error_code(error::general);
503 return 0;
504 }
505 }
506
507 return p;
508 }
509
511
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()) {
539 return make_error_code(error::invalid_utf8);
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
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
586 bool get_error() const {
587 return m_state == FATAL_ERROR;
588 }
589
590 size_t get_bytes_needed() const {
591 return m_bytes_needed;
592 }
593
595
605 virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
606 {
607 if (!in || !out) {
608 return make_error_code(error::invalid_arguments);
609 }
610
611 frame::opcode::value op = in->get_opcode();
612
613 // validate opcode: only regular data frames
615 return make_error_code(error::invalid_opcode);
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)) {
623 return make_error_code(error::invalid_payload);
624 }
625
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) {
645 return make_error_code(error::general);
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
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 {
699 if (close::status::reserved(code)) {
700 return make_error_code(error::reserved_close_code);
701 }
702
704 return make_error_code(error::invalid_close_code);
705 }
706
707 if (code == close::status::no_status && reason.size() > 0) {
708 return make_error_code(error::reason_requires_code);
709 }
710
711 if (reason.size() > frame:: limits::payload_size_basic-2) {
712 return make_error_code(error::control_too_big);
713 }
714
715 std::string payload;
716
717 if (code != close::status::no_status) {
718 close::code_converter val;
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:
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
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
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
787
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())) {
828 ec = make_error_code(error::invalid_utf8);
829 return 0;
830 }
831 }
832
833 m_bytes_needed -= len;
834
835 return len;
836 }
837
839
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 {
857 return make_error_code(error::control_too_big);
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 {
869 return make_error_code(error::invalid_rsv_bit);
870 }
871
872 if (frame::get_rsv2(h) || frame::get_rsv3(h)) {
873 return make_error_code(error::invalid_rsv_bit);
874 }
875
876 // Check for reserved opcodes
877 if (frame::opcode::reserved(op)) {
878 return make_error_code(error::invalid_opcode);
879 }
880
881 // Check for invalid opcodes
882 // TODO: unit tests for this?
883 if (frame::opcode::invalid(op)) {
884 return make_error_code(error::invalid_opcode);
885 }
886
887 // Check for fragmented control message
889 return make_error_code(error::fragmented_control);
890 }
891
892 // Check for continuation without an active message
893 if (new_msg && op == frame::opcode::CONTINUATION) {
894 return make_error_code(error::invalid_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 {
901 return make_error_code(error::invalid_continuation);
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)) {
907 return make_error_code(error::masking_required);
908 } else if (!is_server && frame::get_masked(h)) {
909 return make_error_code(error::masking_forbidden);
910 }
911
912 return lib::error_code();
913 }
914
916
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 {
936 return make_error_code(error::non_minimal_encoding);
937 }
938
939 if (basic_size == frame::payload_size_code_64bit &&
941 {
942 return make_error_code(error::non_minimal_encoding);
943 }
944
945 // Check for >32bit frames on 32 bit systems
946 if (sizeof(size_t) == 4 && (payload_size >> 32)) {
947 return make_error_code(error::requires_64bit);
948 }
949
950 return lib::error_code();
951 }
952
954
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
969
977 lib::error_code prepare_control(frame::opcode::value op,
978 std::string const & payload, message_ptr out) const
979 {
980 if (!out) {
981 return make_error_code(error::invalid_arguments);
982 }
983
984 if (!frame::opcode::is_control(op)) {
985 return make_error_code(error::invalid_opcode);
986 }
987
988 if (payload.size() > frame::limits::payload_size_basic) {
989 return make_error_code(error::control_too_big);
990 }
991
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
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
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.
Provides streaming UTF8 validation functionality.
bool decode(iterator_type begin, iterator_type end)
Advance validator state with input from an iterator pair.
bool complete()
Return whether the input sequence ended on a valid utf8 codepoint.
static value const no_status
A dummy value to indicate that no status code was received.
Definition close.hpp:97
uint16_t value
The type of a close code value.
Definition close.hpp:49
bool invalid(value code)
Test whether a close code is invalid on the wire.
Definition close.hpp:199
bool reserved(value code)
Test whether a close code is in a reserved range.
Definition close.hpp:184
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
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
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
Definition frame.hpp:393
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
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
Definition frame.hpp:321
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
Definition frame.hpp:339
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Definition frame.hpp:445
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
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
Definition constants.hpp:53
@ 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
@ 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
@ invalid_opcode
Opcode was invalid for requested operation.
Definition base.hpp:87
@ requires_64bit
Not supported on 32 bit systems.
Definition base.hpp:111
@ subprotocol_parse_error
Error parsing subprotocols.
Definition base.hpp:147
@ 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
@ 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
uri_ptr get_uri_from_host(request_type &request, std::string scheme)
Extract a URI ptr from the host header of the request.
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive)
Namespace for the WebSocket++ project.
Definition base64.hpp:41
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
Definition uri.hpp:352
std::string base64_encode(unsigned char const *input, size_t len)
Encode a char buffer into a base64 string.
Definition base64.hpp:66
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
Four byte conversion union.
Definition frame.hpp:61