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>
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)
74 , m_msg_manager(manager)
84 bool has_permessage_deflate()
const {
85 return m_permessage_deflate.is_implemented();
93 if (!config::enable_extensions) {
100 bool error = req.get_header_as_plist(
"Sec-WebSocket-Extensions",p);
112 http::parameter_list::const_iterator it;
114 if (m_permessage_deflate.is_implemented()) {
115 err_str_pair neg_ret;
116 for (it = p.begin(); it != p.end(); ++it) {
118 if (it->first ==
"permessage-deflate") {
119 neg_ret = m_permessage_deflate.negotiate(it->second);
130 ret.second += neg_ret.second;
141 if (r.get_method() !=
"GET") {
145 if (r.get_version() !=
"HTTP/1.1") {
153 if (r.get_header(
"Sec-WebSocket-Key") ==
"") {
157 return lib::error_code();
165 std::string
const & subprotocol, response_type & response)
const
167 std::string server_key = request.get_header(
"Sec-WebSocket-Key");
175 response.replace_header(
"Sec-WebSocket-Accept",server_key);
176 response.append_header(
"Upgrade",constants::upgrade_token);
177 response.append_header(
"Connection",constants::connection_token);
179 if (!subprotocol.empty()) {
180 response.replace_header(
"Sec-WebSocket-Protocol",subprotocol);
183 return lib::error_code();
193 uri, std::vector<std::string>
const & subprotocols)
const
195 req.set_method(
"GET");
196 req.set_uri(uri->get_resource());
197 req.set_version(
"HTTP/1.1");
199 req.append_header(
"Upgrade",
"websocket");
200 req.append_header(
"Connection",
"Upgrade");
201 req.replace_header(
"Sec-WebSocket-Version",
"13");
202 req.replace_header(
"Host",uri->get_host_port());
204 if (!subprotocols.empty()) {
205 std::ostringstream result;
206 std::vector<std::string>::const_iterator it = subprotocols.begin();
208 while (it != subprotocols.end()) {
209 result <<
", " << *it++;
212 req.replace_header(
"Sec-WebSocket-Protocol",result.str());
217 unsigned char raw_key[16];
219 for (
int i = 0; i < 4; i++) {
221 std::copy(conv.c,conv.c+4,&raw_key[i*4]);
224 req.replace_header(
"Sec-WebSocket-Key",
base64_encode(raw_key, 16));
226 return lib::error_code();
236 response_type& res)
const
239 if (res.get_status_code() != http::status_code::switching_protocols) {
244 std::string
const & upgrade_header = res.get_header(
"Upgrade");
246 sizeof(constants::upgrade_token)-1) == upgrade_header.end())
252 std::string
const & con_header = res.get_header(
"Connection");
254 sizeof(constants::connection_token)-1) == con_header.end())
260 std::string key = req.get_header(
"Sec-WebSocket-Key");
263 if (ec || key != res.get_header(
"Sec-WebSocket-Accept")) {
267 return lib::error_code();
270 std::string
get_raw(response_type
const & res)
const {
274 std::string
const &
get_origin(request_type
const & r)
const {
275 return r.get_header(
"Origin");
279 std::vector<std::string> & subprotocol_list)
281 if (!req.get_header(
"Sec-WebSocket-Protocol").empty()) {
284 if (!req.get_header_as_plist(
"Sec-WebSocket-Protocol",p)) {
285 http::parameter_list::const_iterator it;
287 for (it = p.begin(); it != p.end(); ++it) {
288 subprotocol_list.push_back(it->first);
294 return lib::error_code();
328 size_t consume(uint8_t * buf,
size_t len, lib::error_code & ec) {
331 ec = lib::error_code();
337 while (m_state != READY && m_state != FATAL_ERROR &&
338 (p < len || m_bytes_needed == 0))
340 if (m_state == HEADER_BASIC) {
343 if (m_bytes_needed > 0) {
348 m_basic_header, base::m_server, !m_data_msg.msg_ptr
353 m_state = HEADER_EXTENDED;
357 }
else if (m_state == HEADER_EXTENDED) {
360 if (m_bytes_needed > 0) {
367 m_state = APPLICATION;
368 m_bytes_needed =
static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
378 m_msg_manager->get_message(op,m_bytes_needed),
382 m_current_msg = &m_control_msg;
384 if (!m_data_msg.msg_ptr) {
385 if (m_bytes_needed > base::m_max_message_size) {
391 m_msg_manager->get_message(op,m_bytes_needed),
397 std::string & out = m_data_msg.msg_ptr->get_raw_payload();
399 if (out.size() + m_bytes_needed > base::m_max_message_size) {
406 m_data_msg.prepared_key = prepare_masking_key(
413 out.reserve(out.size() + m_bytes_needed);
415 m_current_msg = &m_data_msg;
417 }
else if (m_state == EXTENSION) {
418 m_state = APPLICATION;
419 }
else if (m_state == APPLICATION) {
420 size_t bytes_to_process = (std::min)(m_bytes_needed,len-p);
422 if (bytes_to_process > 0) {
428 if (m_bytes_needed > 0) {
437 if (!m_current_msg->validator.
complete()) {
445 this->reset_headers();
457 void reset_headers() {
458 m_state = HEADER_BASIC;
461 m_basic_header.b0 = 0x00;
462 m_basic_header.b1 = 0x00;
465 m_extended_header.bytes,
473 return (m_state == READY);
478 return message_ptr();
480 message_ptr ret = m_current_msg->msg_ptr;
481 m_current_msg->msg_ptr.reset();
484 m_control_msg.msg_ptr.reset();
486 m_data_msg.msg_ptr.reset();
489 this->reset_headers();
496 return m_state == FATAL_ERROR;
500 return m_bytes_needed;
533 frame::opcode::value op = in->get_opcode();
540 std::string& i = in->get_raw_payload();
541 std::string& o = out->get_raw_payload();
544 if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
549 bool masked = !base::m_server;
550 bool compressed = m_permessage_deflate.is_enabled()
551 && in->get_compressed();
552 bool fin = in->get_fin();
571 m_permessage_deflate.compress(i,o);
587 std::copy(i.begin(),i.end(),o.begin());
591 out->set_prepared(
true);
594 return lib::error_code();
598 lib::error_code
prepare_ping(std::string
const & in, message_ptr out)
const {
602 lib::error_code prepare_pong(std::string
const & in, message_ptr out)
const {
607 std::string
const & reason, message_ptr out)
const
628 close::code_converter val;
631 payload.resize(reason.size()+2);
633 payload[0] = val.c[0];
634 payload[1] = val.c[1];
636 std::copy(reason.begin(),reason.end(),payload.begin()+2);
644 key.append(constants::handshake_guid);
646 unsigned char message_digest[20];
647 sha1::calc(key.c_str(),key.length(),message_digest);
650 return lib::error_code();
655 if (len == 0 || m_bytes_needed == 0) {
661 if (m_bytes_needed == 2) {
662 m_basic_header.b0 = buf[0];
663 m_basic_header.b1 = buf[1];
667 m_basic_header.b1 = buf[0];
673 if (m_bytes_needed == 2) {
674 m_basic_header.b0 = buf[0];
678 m_basic_header.b1 = buf[0];
687 size_t bytes_to_read = (std::min)(m_bytes_needed,len);
689 std::copy(buf,buf+bytes_to_read,m_extended_header.bytes+m_cursor);
690 m_cursor += bytes_to_read;
691 m_bytes_needed -= bytes_to_read;
693 return bytes_to_read;
713 #ifdef WEBSOCKETPP_STRICT_MASKING
717 m_current_msg->prepared_key
723 m_current_msg->prepared_key
728 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
729 size_t offset = out.size();
732 if (m_permessage_deflate.is_enabled()
736 m_permessage_deflate.decompress(buf,len,out);
739 offset = out.size() - offset;
742 out.append(reinterpret_cast<char *>(buf),len);
746 if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
747 if (!m_current_msg->validator.
decode(out.begin()+offset,out.end())) {
753 m_bytes_needed -= len;
769 bool is_server,
bool new_msg)
const
813 if (new_msg && op == frame::opcode::CONTINUATION) {
819 op != frame::opcode::CONTINUATION)
832 return lib::error_code();
853 if (basic_size == frame::payload_size_code_16bit &&
859 if (basic_size == frame::payload_size_code_64bit &&
866 if (
sizeof(
size_t) == 4 && (payload_size >> 32)) {
870 return lib::error_code();
884 #ifdef WEBSOCKETPP_STRICT_MASKING
888 reinterpret_cast<uint8_t *>(const_cast<char *>(i.data())),
889 reinterpret_cast<uint8_t *
>(
const_cast<char *
>(o.data())),
906 std::string
const & payload, message_ptr out)
const
921 bool masked = !base::m_server;
925 std::string & o = out->get_raw_payload();
926 o.resize(payload.size());
938 std::copy(payload.begin(),payload.end(),o.begin());
941 out->set_prepared(
true);
943 return lib::error_code();
960 msg_metadata(message_ptr m,
size_t p) : msg_ptr(m),prepared_key(p) {}
963 , prepared_key(prepare_masking_key(p)) {}
974 msg_manager_ptr m_msg_manager;
977 size_t m_bytes_needed;
999 permessage_deflate_type m_permessage_deflate;
1005 #endif //WEBSOCKETPP_PROCESSOR_HYBI13_HPP
bool is_control(value v)
Check if an opcode is for a control frame.
bool invalid(value v)
Check if an opcode is invalid.
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
Prepare a user data message for writing.
bool get_rsv1(basic_header const &h)
check whether the frame's RSV1 bit is set
uint16_t value
The type of a close code value.
uri_ptr get_uri_from_host(request_type &request, std::string scheme)
Extract a URI ptr from the host header of the request.
bool get_rsv3(basic_header const &h)
check whether the frame's RSV3 bit is set
bool ready() const
Test whether or not the processor has a message ready.
bool decode(iterator_type begin, iterator_type end)
Advance validator state with input from an iterator pair.
Clients may not send unmasked frames.
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
bool get_masked(basic_header const &h)
check whether the frame is masked
void masked_copy(std::string const &i, std::string &o, frame::masking_key_type key) const
Copy and mask/unmask in one operation.
WebSocket protocol processor abstract base class.
size_t copy_extended_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_extended_header.
bool get_rsv2(basic_header const &h)
check whether the frame's RSV2 bit is set
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.
Using a reason requires a close code.
Illegal use of reserved bit.
Provides streaming UTF8 validation functionality.
opcode::value get_opcode(basic_header const &h)
Extract opcode from basic header.
bool reserved(value code)
Test whether a close code is in a reserved range.
size_t process_payload_bytes(uint8_t *buf, size_t len, lib::error_code &ec)
Reads bytes from buf into message payload.
static uint8_t const payload_size_basic
Maximum size of a basic WebSocket payload.
std::vector< std::pair< std::string, attribute_list > > parameter_list
The type of an HTTP parameter list.
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.
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
bool get_error() const
Test whether or not the processor is in a fatal error state.
bool invalid(value code)
Test whether a close code is invalid on the wire.
Four byte conversion union.
Processor encountered invalid payload data.
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.
std::string base64_encode(unsigned char const *input, size_t len)
Encode a char buffer into a base64 string.
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
std::string get_raw(response_type const &res) const
Given a completed response, get the raw bytes to put on the wire.
Continuation without message.
size_t word_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular word aligned mask/unmask.
lib::error_code extract_subprotocols(request_type const &req, std::vector< std::string > &subprotocol_list)
Extracts requested subprotocols from a handshake request.
Not supported on 32 bit systems.
Extension related operation was ignored because extensions are disabled.
message_ptr get_message()
Retrieves the most recently processed message.
void word_mask_exact(uint8_t *input, uint8_t *output, size_t length, masking_key_type const &key)
Exact word aligned mask/unmask.
lib::error_code make_error_code(error::processor_errors e)
Create an error code with the given value and the processor category.
Reserved close code used.
uint8_t get_basic_size(basic_header const &)
Extracts the raw payload length specified in the basic header.
Namespace for the WebSocket++ project.
uint64_t get_payload_size(basic_header const &, extended_header const &)
Extract the full payload size field from a WebSocket header.
static unsigned int const MAX_EXTENDED_HEADER_LENGTH
Maximum length of the variable portion of the WebSocket header.
Error parsing subprotocols.
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_ping(std::string const &in, message_ptr out) const
Get URI.
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
static value const no_status
A dummy value to indicate that no status code was received.
Servers may not send masked frames.
Fragmented control message.
Processor encountered a message that was too large.
Error parsing extensions.
int get_version() const
Get the protocol version of this processor.
size_t copy_basic_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_basic_header.
lib::error_code validate_incoming_extended_header(frame::basic_header h, frame::extended_header e) const
Validate an incoming extended header.
size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)
Process new websocket connection bytes.
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.
std::string prepare_header(const basic_header &h, const extended_header &e)
Generate a properly sized contiguous string that encodes a full frame header.
static uint16_t const payload_size_extended
Maximum size of an extended WebSocket payload (basic payload = 126)
size_t byte_mask_circ(uint8_t *input, uint8_t *output, size_t length, size_t prepared_key)
Circular byte aligned mask/unmask.
Opcode was invalid for requested operation.
lib::error_code validate_incoming_basic_header(frame::basic_header const &h, bool is_server, bool new_msg) const
Validate an incoming basic header.
bool reserved(value v)
Check if an opcode is reserved.
bool get_fin(basic_header const &h)
Check whether the frame's FIN bit is set.
uri_ptr get_uri(request_type const &request) const
Extracts client uri from a handshake request.
size_t get_bytes_needed() const
Processor for Hybi version 13 (RFC6455)
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.
static unsigned int const BASIC_HEADER_LENGTH
Minimum length of a WebSocket frame header.
T::const_iterator ci_find_substr(T const &haystack, T const &needle, std::locale const &loc=std::locale())
Find substring (case insensitive)
The processor method was called with invalid arguments.
Payload length not minimally encoded.
bool complete()
Return whether the input sequence ended on a valid utf8 codepoint.
err_str_pair negotiate_extensions(request_type const &req)
Initializes extensions based on the Sec-WebSocket-Extensions header.