28 #ifndef WEBSOCKETPP_PROCESSOR_HYBI13_HPP
29 #define WEBSOCKETPP_PROCESSOR_HYBI13_HPP
33 #include <websocketpp/frame.hpp>
34 #include <websocketpp/utf8_validator.hpp>
35 #include <websocketpp/common/network.hpp>
36 #include <websocketpp/common/platforms.hpp>
37 #include <websocketpp/http/constants.hpp>
39 #include <websocketpp/processors/processor.hpp>
41 #include <websocketpp/sha1/sha1.hpp>
42 #include <websocketpp/base64/base64.hpp>
52 template <
typename config>
57 typedef typename config::request_type request_type;
58 typedef typename config::response_type response_type;
60 typedef typename config::message_type message_type;
61 typedef typename message_type::ptr message_ptr;
63 typedef typename config::con_msg_manager_type msg_manager_type;
64 typedef typename msg_manager_type::ptr msg_manager_ptr;
65 typedef typename config::rng_type rng_type;
67 typedef typename config::permessage_deflate_type permessage_deflate_type;
69 typedef std::pair<lib::error_code,std::string> err_str_pair;
71 explicit hybi13(
bool secure,
bool p_is_server, msg_manager_ptr manager, rng_type& rng)
73 , m_msg_manager(manager)
83 bool has_permessage_deflate()
const {
84 return m_permessage_deflate.is_implemented();
92 if (!config::enable_extensions) {
99 bool error = req.get_header_as_plist(
"Sec-WebSocket-Extensions",p);
111 http::parameter_list::const_iterator it;
113 if (m_permessage_deflate.is_implemented()) {
114 err_str_pair neg_ret;
115 for (it = p.begin(); it != p.end(); ++it) {
117 if (it->first ==
"permessage-deflate") {
118 neg_ret = m_permessage_deflate.negotiate(it->second);
129 ret.second += neg_ret.second;
140 if (r.get_method() !=
"GET") {
144 if (r.get_version() !=
"HTTP/1.1") {
152 if (r.get_header(
"Sec-WebSocket-Key") ==
"") {
156 return lib::error_code();
164 std::string & subprotocol, response_type& response)
const
166 std::string server_key = request.get_header(
"Sec-WebSocket-Key");
174 response.replace_header(
"Sec-WebSocket-Accept",server_key);
175 response.append_header(
"Upgrade",constants::upgrade_token);
176 response.append_header(
"Connection",constants::connection_token);
178 if (!subprotocol.empty()) {
179 response.replace_header(
"Sec-WebSocket-Protocol",subprotocol);
182 return lib::error_code();
192 uri, std::vector<std::string>
const & subprotocols)
const
194 req.set_method(
"GET");
195 req.set_uri(uri->get_resource());
196 req.set_version(
"HTTP/1.1");
198 req.append_header(
"Upgrade",
"websocket");
199 req.append_header(
"Connection",
"Upgrade");
200 req.replace_header(
"Sec-WebSocket-Version",
"13");
201 req.replace_header(
"Host",uri->get_host_port());
203 if (!subprotocols.empty()) {
204 std::ostringstream result;
205 std::vector<std::string>::const_iterator it = subprotocols.begin();
207 while (it != subprotocols.end()) {
208 result <<
", " << *it++;
211 req.replace_header(
"Sec-WebSocket-Protocol",result.str());
216 unsigned char raw_key[16];
218 for (
int i = 0; i < 4; i++) {
220 std::copy(conv.c,conv.c+4,&raw_key[i*4]);
223 req.replace_header(
"Sec-WebSocket-Key",
base64_encode(raw_key, 16));
225 return lib::error_code();
235 response_type& res)
const
238 if (res.get_status_code() != http::status_code::switching_protocols) {
243 std::string
const & upgrade_header = res.get_header(
"Upgrade");
245 sizeof(constants::upgrade_token)-1) == upgrade_header.end())
251 std::string
const & con_header = res.get_header(
"Connection");
253 sizeof(constants::connection_token)-1) == con_header.end())
259 std::string key = req.get_header(
"Sec-WebSocket-Key");
262 if (ec || key != res.get_header(
"Sec-WebSocket-Accept")) {
266 return lib::error_code();
269 std::string
get_raw(response_type
const & res)
const {
273 std::string
const &
get_origin(request_type
const & r)
const {
274 return r.get_header(
"Origin");
278 std::vector<std::string> & subprotocol_list)
280 if (!req.get_header(
"Sec-WebSocket-Protocol").empty()) {
283 if (!req.get_header_as_plist(
"Sec-WebSocket-Protocol",p)) {
284 http::parameter_list::const_iterator it;
286 for (it = p.begin(); it != p.end(); ++it) {
287 subprotocol_list.push_back(it->first);
293 return lib::error_code();
327 size_t consume(uint8_t * buf,
size_t len, lib::error_code & ec) {
330 ec = lib::error_code();
336 while (m_state != READY && m_state != FATAL_ERROR &&
337 (p < len || m_bytes_needed == 0))
339 if (m_state == HEADER_BASIC) {
342 if (m_bytes_needed > 0) {
347 m_basic_header, base::m_server, !m_data_msg.msg_ptr
352 m_state = HEADER_EXTENDED;
356 }
else if (m_state == HEADER_EXTENDED) {
359 if (m_bytes_needed > 0) {
366 m_state = APPLICATION;
367 m_bytes_needed =
static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
377 m_msg_manager->get_message(op,m_bytes_needed),
381 m_current_msg = &m_control_msg;
383 if (!m_data_msg.msg_ptr) {
384 if (m_bytes_needed > base::m_max_message_size) {
390 m_msg_manager->get_message(op,m_bytes_needed),
396 std::string & out = m_data_msg.msg_ptr->get_raw_payload();
398 if (out.size() + m_bytes_needed > base::m_max_message_size) {
405 m_data_msg.prepared_key = prepare_masking_key(
412 out.reserve(out.size() + m_bytes_needed);
414 m_current_msg = &m_data_msg;
416 }
else if (m_state == EXTENSION) {
417 m_state = APPLICATION;
418 }
else if (m_state == APPLICATION) {
419 size_t bytes_to_process = (std::min)(m_bytes_needed,len-p);
421 if (bytes_to_process > 0) {
427 if (m_bytes_needed > 0) {
436 if (!m_current_msg->validator.
complete()) {
444 this->reset_headers();
456 void reset_headers() {
457 m_state = HEADER_BASIC;
460 m_basic_header.b0 = 0x00;
461 m_basic_header.b1 = 0x00;
464 m_extended_header.bytes,
472 return (m_state == READY);
477 return message_ptr();
479 message_ptr ret = m_current_msg->msg_ptr;
480 m_current_msg->msg_ptr.reset();
483 m_control_msg.msg_ptr.reset();
485 m_data_msg.msg_ptr.reset();
488 this->reset_headers();
495 return m_state == FATAL_ERROR;
499 return m_bytes_needed;
532 frame::opcode::value op = in->get_opcode();
539 std::string& i = in->get_raw_payload();
540 std::string& o = out->get_raw_payload();
543 if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
548 bool masked = !base::m_server;
549 bool compressed = m_permessage_deflate.is_enabled()
550 && in->get_compressed();
551 bool fin = in->get_fin();
570 m_permessage_deflate.compress(i,o);
586 std::copy(i.begin(),i.end(),o.begin());
590 out->set_prepared(
true);
592 return lib::error_code();
596 lib::error_code
prepare_ping(std::string
const & in, message_ptr out)
const {
600 lib::error_code prepare_pong(std::string
const & in, message_ptr out)
const {
605 std::string
const & reason, message_ptr out)
const
626 close::code_converter val;
629 payload.resize(reason.size()+2);
631 payload[0] = val.c[0];
632 payload[1] = val.c[1];
634 std::copy(reason.begin(),reason.end(),payload.begin()+2);
642 key.append(constants::handshake_guid);
644 unsigned char message_digest[20];
645 sha1::calc(key.c_str(),key.length(),message_digest);
648 return lib::error_code();
653 if (len == 0 || m_bytes_needed == 0) {
659 if (m_bytes_needed == 2) {
660 m_basic_header.b0 = buf[0];
661 m_basic_header.b1 = buf[1];
665 m_basic_header.b1 = buf[0];
671 if (m_bytes_needed == 2) {
672 m_basic_header.b0 = buf[0];
676 m_basic_header.b1 = buf[0];
685 size_t bytes_to_read = (std::min)(m_bytes_needed,len);
687 std::copy(buf,buf+bytes_to_read,m_extended_header.bytes+m_cursor);
688 m_cursor += bytes_to_read;
689 m_bytes_needed -= bytes_to_read;
691 return bytes_to_read;
711 #ifdef WEBSOCKETPP_STRICT_MASKING
715 m_current_msg->prepared_key
721 m_current_msg->prepared_key
726 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
727 size_t offset = out.size();
730 if (m_permessage_deflate.is_enabled()
734 m_permessage_deflate.decompress(buf,len,out);
737 offset = out.size() - offset;
740 out.append(reinterpret_cast<char *>(buf),len);
744 if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
745 if (!m_current_msg->validator.
decode(out.begin()+offset,out.end())) {
751 m_bytes_needed -= len;
767 bool is_server,
bool new_msg)
const
811 if (new_msg && op == frame::opcode::CONTINUATION) {
817 op != frame::opcode::CONTINUATION)
830 return lib::error_code();
851 if (basic_size == frame::payload_size_code_16bit &&
857 if (basic_size == frame::payload_size_code_64bit &&
864 if (
sizeof(
size_t) == 4 && (payload_size >> 32)) {
868 return lib::error_code();
882 #ifdef WEBSOCKETPP_STRICT_MASKING
886 reinterpret_cast<uint8_t *>(const_cast<char *>(i.data())),
887 reinterpret_cast<uint8_t *
>(
const_cast<char *
>(o.data())),
904 std::string
const & payload, message_ptr out)
const
919 bool masked = !base::m_server;
923 std::string & o = out->get_raw_payload();
924 o.resize(payload.size());
936 std::copy(payload.begin(),payload.end(),o.begin());
939 out->set_prepared(
true);
941 return lib::error_code();
958 msg_metadata(message_ptr m,
size_t p) : msg_ptr(m),prepared_key(p) {}
961 , prepared_key(prepare_masking_key(p)) {}
972 msg_manager_ptr m_msg_manager;
975 size_t m_bytes_needed;
997 permessage_deflate_type m_permessage_deflate;
1003 #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
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.
lib::error_code process_handshake(request_type const &request, const std::string &subprotocol, response_type &response) const
Calculate the appropriate response for this websocket request.
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.