28 #ifndef WEBSOCKETPP_PROCESSOR_HYBI13_HPP 29 #define WEBSOCKETPP_PROCESSOR_HYBI13_HPP 31 #include <websocketpp/processors/processor.hpp> 33 #include <websocketpp/frame.hpp> 34 #include <websocketpp/http/constants.hpp> 36 #include <websocketpp/utf8_validator.hpp> 37 #include <websocketpp/sha1/sha1.hpp> 38 #include <websocketpp/base64/base64.hpp> 40 #include <websocketpp/common/network.hpp> 41 #include <websocketpp/common/platforms.hpp> 53 template <
typename config>
56 typedef processor<config> base;
58 typedef typename config::request_type request_type;
59 typedef typename config::response_type response_type;
61 typedef typename config::message_type message_type;
62 typedef typename message_type::ptr message_ptr;
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;
68 typedef typename config::permessage_deflate_type permessage_deflate_type;
70 typedef std::pair<lib::error_code,std::string> err_str_pair;
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)
84 bool has_permessage_deflate()
const {
85 return m_permessage_deflate.is_implemented();
89 return negotiate_extensions_helper(request);
93 return negotiate_extensions_helper(response);
101 template <
typename header_type>
107 if (!config::enable_extensions) {
108 ret.first = make_error_code(error::extensions_disabled);
112 http::parameter_list p;
114 bool error = header.get_header_as_plist(
"Sec-WebSocket-Extensions",p);
117 ret.first = make_error_code(error::extension_parse_error);
126 http::parameter_list::const_iterator it;
128 if (m_permessage_deflate.is_implemented()) {
129 err_str_pair neg_ret;
130 for (it = p.begin(); it != p.end(); ++it) {
132 if (it->first ==
"permessage-deflate") {
136 if (m_permessage_deflate.is_enabled()) {
141 neg_ret = m_permessage_deflate.negotiate(it->second);
152 ret.second += neg_ret.second;
153 m_permessage_deflate.init(base::m_server);
164 if (r.get_method() !=
"GET") {
165 return make_error_code(error::invalid_http_method);
168 if (r.get_version() !=
"HTTP/1.1") {
169 return make_error_code(error::invalid_http_version);
176 if (r.get_header(
"Sec-WebSocket-Key").empty()) {
177 return make_error_code(error::missing_required_header);
180 return lib::error_code();
190 std::string server_key = request.get_header(
"Sec-WebSocket-Key");
192 lib::error_code ec = process_handshake_key(server_key);
198 response.replace_header(
"Sec-WebSocket-Accept",server_key);
199 response.append_header(
"Upgrade",constants::upgrade_token);
200 response.append_header(
"Connection",constants::connection_token);
202 if (!subprotocol.empty()) {
203 response.replace_header(
"Sec-WebSocket-Protocol",subprotocol);
206 return lib::error_code();
218 req.set_method(
"GET");
219 req.set_uri(uri->get_resource());
220 req.set_version(
"HTTP/1.1");
222 req.append_header(
"Upgrade",
"websocket");
223 req.append_header(
"Connection",
"Upgrade");
224 req.replace_header(
"Sec-WebSocket-Version",
"13");
225 req.replace_header(
"Host",uri->get_host_port());
227 if (!subprotocols.empty()) {
228 std::ostringstream result;
229 std::vector<std::string>::const_iterator it = subprotocols.begin();
231 while (it != subprotocols.end()) {
232 result <<
", " << *it++;
235 req.replace_header(
"Sec-WebSocket-Protocol",result.str());
239 frame::uint32_converter conv;
240 unsigned char raw_key[16];
242 for (
int i = 0; i < 4; i++) {
244 std::copy(conv.c,conv.c+4,&raw_key[i*4]);
247 req.replace_header(
"Sec-WebSocket-Key",base64_encode(raw_key, 16));
249 if (m_permessage_deflate.is_implemented()) {
250 std::string offer = m_permessage_deflate.generate_offer();
251 if (!offer.empty()) {
252 req.replace_header(
"Sec-WebSocket-Extensions",offer);
256 return lib::error_code();
269 if (res.get_status_code() != http::status_code::switching_protocols) {
270 return error::make_error_code(error::invalid_http_status);
274 std::string
const & upgrade_header = res.get_header(
"Upgrade");
275 if (utility::ci_find_substr(upgrade_header, constants::upgrade_token,
276 sizeof(constants::upgrade_token)-1) == upgrade_header.end())
278 return error::make_error_code(error::missing_required_header);
282 std::string
const & con_header = res.get_header(
"Connection");
283 if (utility::ci_find_substr(con_header, constants::connection_token,
284 sizeof(constants::connection_token)-1) == con_header.end())
286 return error::make_error_code(error::missing_required_header);
290 std::string key = req.get_header(
"Sec-WebSocket-Key");
291 lib::error_code ec = process_handshake_key(key);
293 if (ec || key != res.get_header(
"Sec-WebSocket-Accept")) {
294 return error::make_error_code(error::missing_required_header);
299 return lib::error_code();
302 std::string
get_raw(response_type
const & res)
const {
306 std::string
const &
get_origin(request_type
const & r)
const {
307 return r.get_header(
"Origin");
313 if (!req.get_header(
"Sec-WebSocket-Protocol").empty()) {
314 http::parameter_list p;
316 if (!req.get_header_as_plist(
"Sec-WebSocket-Protocol",p)) {
317 http::parameter_list::const_iterator it;
319 for (it = p.begin(); it != p.end(); ++it) {
320 subprotocol_list.push_back(it->first);
323 return error::make_error_code(error::subprotocol_parse_error);
326 return lib::error_code();
330 return get_uri_from_host(request,(base::m_secure ?
"wss" :
"ws"));
363 ec = lib::error_code();
369 while (m_state != READY && m_state != FATAL_ERROR &&
370 (p < len || m_bytes_needed == 0))
372 if (m_state == HEADER_BASIC) {
373 p +=
this->copy_basic_header_bytes(buf+p,len-p);
375 if (m_bytes_needed > 0) {
379 ec =
this->validate_incoming_basic_header(
380 m_basic_header, base::m_server, !m_data_msg.msg_ptr
385 m_state = HEADER_EXTENDED;
387 m_bytes_needed = frame::get_header_len(m_basic_header) -
388 frame::BASIC_HEADER_LENGTH;
389 }
else if (m_state == HEADER_EXTENDED) {
390 p +=
this->copy_extended_header_bytes(buf+p,len-p);
392 if (m_bytes_needed > 0) {
396 ec = validate_incoming_extended_header(m_basic_header,m_extended_header);
399 m_state = APPLICATION;
400 m_bytes_needed =
static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
404 frame::opcode::value op = frame::get_opcode(m_basic_header);
408 if (frame::opcode::is_control(op)) {
409 m_control_msg = msg_metadata(
410 m_msg_manager->get_message(op,m_bytes_needed),
411 frame::get_masking_key(m_basic_header,m_extended_header)
414 m_current_msg = &m_control_msg;
416 if (!m_data_msg.msg_ptr) {
417 if (m_bytes_needed > base::m_max_message_size) {
418 ec = make_error_code(error::message_too_big);
422 m_data_msg = msg_metadata(
423 m_msg_manager->get_message(op,m_bytes_needed),
424 frame::get_masking_key(m_basic_header,m_extended_header)
427 if (m_permessage_deflate.is_enabled()) {
428 m_data_msg.msg_ptr->set_compressed(frame::get_rsv1(m_basic_header));
433 std::string & out = m_data_msg.msg_ptr->get_raw_payload();
435 if (out.size() + m_bytes_needed > base::m_max_message_size) {
436 ec = make_error_code(error::message_too_big);
442 m_data_msg.prepared_key = prepare_masking_key(
443 frame::get_masking_key(
449 out.reserve(out.size() + m_bytes_needed);
451 m_current_msg = &m_data_msg;
453 }
else if (m_state == EXTENSION) {
454 m_state = APPLICATION;
455 }
else if (m_state == APPLICATION) {
456 size_t bytes_to_process = (std::min)(m_bytes_needed,len-p);
458 if (bytes_to_process > 0) {
459 p +=
this->process_payload_bytes(buf+p,bytes_to_process,ec);
464 if (m_bytes_needed > 0) {
470 if (frame::get_fin(m_basic_header)) {
471 ec = finalize_message();
476 this->reset_headers();
480 ec = make_error_code(error::general);
497 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
501 if (m_permessage_deflate.is_enabled()
502 && m_current_msg->msg_ptr->get_compressed())
504 uint8_t trailer[4] = {0x00, 0x00, 0xff, 0xff};
508 ec = m_permessage_deflate.decompress(trailer,4,out);
515 if (frame::get_opcode(m_basic_header) == frame::opcode::TEXT) {
516 if (!m_current_msg->validator.complete()) {
517 return make_error_code(error::invalid_utf8);
523 return lib::error_code();
526 void reset_headers() {
527 m_state = HEADER_BASIC;
528 m_bytes_needed = frame::BASIC_HEADER_LENGTH;
530 m_basic_header.b0 = 0x00;
531 m_basic_header.b1 = 0x00;
534 m_extended_header.bytes,
535 frame::MAX_EXTENDED_HEADER_LENGTH,
542 return (m_state == READY);
547 return message_ptr();
549 message_ptr ret = m_current_msg->msg_ptr;
550 m_current_msg->msg_ptr.reset();
552 if (frame::opcode::is_control(ret->get_opcode())) {
553 m_control_msg.msg_ptr.reset();
555 m_data_msg.msg_ptr.reset();
558 this->reset_headers();
565 return m_state == FATAL_ERROR;
569 return m_bytes_needed;
586 return make_error_code(error::invalid_arguments);
589 frame::opcode::value op = in->get_opcode();
592 if (frame::opcode::is_control(op)) {
593 return make_error_code(error::invalid_opcode);
596 std::string& i = in->get_raw_payload();
597 std::string& o = out->get_raw_payload();
600 if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
601 return make_error_code(error::invalid_payload);
604 frame::masking_key_type key;
605 bool masked = !base::m_server;
606 bool compressed = m_permessage_deflate.is_enabled()
607 && in->get_compressed();
608 bool fin = in->get_fin();
620 m_permessage_deflate.compress(i,o);
623 return make_error_code(error::general);
628 o.resize(o.size()-4);
632 this->masked_copy(o,o,key);
642 this->masked_copy(i,o,key);
644 std::copy(i.begin(),i.end(),o.begin());
649 frame::basic_header h(op,o.size(),fin,masked,compressed);
652 frame::extended_header e(o.size(),key.i);
653 out->set_header(frame::prepare_header(h,e));
655 frame::extended_header e(o.size());
656 out->set_header(frame::prepare_header(h,e));
659 out->set_prepared(
true);
662 return lib::error_code();
667 return this->prepare_control(frame::opcode::PING,in,out);
670 lib::error_code prepare_pong(std::string
const & in, message_ptr out)
const {
671 return this->prepare_control(frame::opcode::PONG,in,out);
674 virtual lib::error_code prepare_close(close::status::value code,
675 std::string
const & reason, message_ptr out)
const 677 if (close::status::reserved(code)) {
678 return make_error_code(error::reserved_close_code);
681 if (close::status::invalid(code) && code != close::status::no_status) {
682 return make_error_code(error::invalid_close_code);
685 if (code == close::status::no_status && reason.size() > 0) {
686 return make_error_code(error::reason_requires_code);
689 if (reason.size() > frame:: limits::payload_size_basic-2) {
690 return make_error_code(error::control_too_big);
695 if (code != close::status::no_status) {
696 close::code_converter val;
699 payload.resize(reason.size()+2);
701 payload[0] = val.c[0];
702 payload[1] = val.c[1];
704 std::copy(reason.begin(),reason.end(),payload.begin()+2);
707 return this->prepare_control(frame::opcode::CLOSE,payload,out);
712 key.append(constants::handshake_guid);
714 unsigned char message_digest[20];
715 sha1::calc(key.c_str(),key.length(),message_digest);
716 key = base64_encode(message_digest,20);
718 return lib::error_code();
723 if (len == 0 || m_bytes_needed == 0) {
729 if (m_bytes_needed == 2) {
730 m_basic_header.b0 = buf[0];
731 m_basic_header.b1 = buf[1];
735 m_basic_header.b1 = buf[0];
741 if (m_bytes_needed == 2) {
742 m_basic_header.b0 = buf[0];
746 m_basic_header.b1 = buf[0];
755 size_t bytes_to_read = (std::min)(m_bytes_needed,len);
757 std::copy(buf,buf+bytes_to_read,m_extended_header.bytes+m_cursor);
758 m_cursor += bytes_to_read;
759 m_bytes_needed -= bytes_to_read;
761 return bytes_to_read;
780 if (frame::get_masked(m_basic_header)) {
781 m_current_msg->prepared_key = frame::byte_mask_circ(
782 buf, len, m_current_msg->prepared_key);
786 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
787 size_t offset = out.size();
790 if (m_permessage_deflate.is_enabled()
791 && m_current_msg->msg_ptr->get_compressed())
794 ec = m_permessage_deflate.decompress(buf,len,out);
800 out.append(
reinterpret_cast<
char *>(buf),len);
804 if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
805 if (!m_current_msg->validator.decode(out.begin()+offset,out.end())) {
806 ec = make_error_code(error::invalid_utf8);
811 m_bytes_needed -= len;
829 frame::opcode::value op = frame::get_opcode(h);
832 if (frame::opcode::is_control(op) &&
833 frame::get_basic_size(h) > frame::limits::payload_size_basic)
835 return make_error_code(error::control_too_big);
844 if (frame::get_rsv1(h) && (!m_permessage_deflate.is_enabled()
845 || frame::opcode::is_control(op)))
847 return make_error_code(error::invalid_rsv_bit);
850 if (frame::get_rsv2(h) || frame::get_rsv3(h)) {
851 return make_error_code(error::invalid_rsv_bit);
855 if (frame::opcode::reserved(op)) {
856 return make_error_code(error::invalid_opcode);
861 if (frame::opcode::invalid(op)) {
862 return make_error_code(error::invalid_opcode);
866 if (frame::opcode::is_control(op) && !frame::get_fin(h)) {
867 return make_error_code(error::fragmented_control);
871 if (new_msg && op == frame::opcode::CONTINUATION) {
872 return make_error_code(error::invalid_continuation);
876 if (!new_msg && !frame::opcode::is_control(op) &&
877 op != frame::opcode::CONTINUATION)
879 return make_error_code(error::invalid_continuation);
884 if (is_server && !frame::get_masked(h)) {
885 return make_error_code(error::masking_required);
886 }
else if (!is_server && frame::get_masked(h)) {
887 return make_error_code(error::masking_forbidden);
890 return lib::error_code();
907 uint8_t basic_size = frame::get_basic_size(h);
908 uint64_t payload_size = frame::get_payload_size(h,e);
911 if (basic_size == frame::payload_size_code_16bit &&
912 payload_size <= frame::limits::payload_size_basic)
914 return make_error_code(error::non_minimal_encoding);
917 if (basic_size == frame::payload_size_code_64bit &&
918 payload_size <= frame::limits::payload_size_extended)
920 return make_error_code(error::non_minimal_encoding);
924 if (
sizeof(size_t) == 4 && (payload_size >> 32)) {
925 return make_error_code(error::requires_64bit);
928 return lib::error_code();
940 frame::masking_key_type key)
const 942 frame::byte_mask(i.begin(),i.end(),o.begin(),key);
959 return make_error_code(error::invalid_arguments);
962 if (!frame::opcode::is_control(op)) {
963 return make_error_code(error::invalid_opcode);
966 if (payload.size() > frame::limits::payload_size_basic) {
967 return make_error_code(error::control_too_big);
970 frame::masking_key_type key;
971 bool masked = !base::m_server;
973 frame::basic_header h(op,payload.size(),
true,masked);
975 std::string & o = out->get_raw_payload();
976 o.resize(payload.size());
982 frame::extended_header e(payload.size(),key.i);
983 out->set_header(frame::prepare_header(h,e));
984 this->masked_copy(payload,o,key);
986 frame::extended_header e(payload.size());
987 out->set_header(frame::prepare_header(h,e));
988 std::copy(payload.begin(),payload.end(),o.begin());
992 out->set_prepared(
true);
994 return lib::error_code();
1011 msg_metadata(message_ptr m, size_t p) : msg_ptr(m),prepared_key(p) {}
1012 msg_metadata(message_ptr m, frame::masking_key_type p)
1014 , prepared_key(prepare_masking_key(p)) {}
1016 message_ptr msg_ptr;
1017 size_t prepared_key;
1018 utf8_validator::validator validator;
1022 frame::basic_header m_basic_header;
1025 msg_manager_ptr m_msg_manager;
1028 size_t m_bytes_needed;
1042 frame::extended_header m_extended_header;
1050 permessage_deflate_type m_permessage_deflate;
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
Prepare a user data message for writing.
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.
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
size_t copy_extended_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_extended_header.
int get_version() const
Get the protocol version of this processor.
size_t process_payload_bytes(uint8_t *buf, size_t len, lib::error_code &ec)
Reads bytes from buf into message payload.
lib::error_code finalize_message()
Perform any finalization actions on an incoming message.
uri_ptr get_uri(request_type const &request) const
Extracts client uri from a handshake request.
void masked_copy(std::string const &i, std::string &o, frame::masking_key_type key) const
Copy and mask/unmask in one operation.
std::string get_raw(response_type const &res) const
Given a completed response, get the raw bytes to put on the wire.
err_str_pair negotiate_extensions_helper(header_type const &header)
Extension negotiation helper function.
lib::error_code extract_subprotocols(request_type const &req, std::vector< std::string > &subprotocol_list)
Extracts requested subprotocols from a handshake request.
lib::error_code validate_incoming_extended_header(frame::basic_header h, frame::extended_header e) const
Validate an incoming extended header.
bool get_error() const
Test whether or not the processor is in a fatal error state.
message_ptr get_message()
Retrieves the most recently processed message.
err_str_pair negotiate_extensions(request_type const &request)
Initializes extensions based on the Sec-WebSocket-Extensions header.
bool ready() const
Test whether or not the processor has a message ready.
lib::error_code process_handshake_key(std::string &key) const
Convert a client handshake key into a server response key in place.
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.
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
Processors encapsulate the protocol rules specific to each WebSocket version.
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
lib::error_code prepare_ping(std::string const &in, message_ptr out) const
Get URI.
size_t copy_basic_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_basic_header.
size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)
Process new websocket connection bytes.
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.
lib::error_code validate_incoming_basic_header(frame::basic_header const &h, bool is_server, bool new_msg) const
Validate an incoming basic header.
size_t get_bytes_needed() const
Processor for Hybi version 13 (RFC6455)
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.
err_str_pair negotiate_extensions(response_type const &response)
Initializes extensions based on the Sec-WebSocket-Extensions header.