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();
101 template <
typename header_type>
107 if (!config::enable_extensions) {
114 bool error = header.get_header_as_plist(
"Sec-WebSocket-Extensions",p);
126 http::parameter_list::const_iterator it;
130 if (m_permessage_deflate.is_implemented()) {
131 err_str_pair neg_ret;
132 for (it = p.begin(); it != p.end(); ++it) {
134 if (it->first !=
"permessage-deflate") {
141 if (m_permessage_deflate.is_enabled()) {
146 neg_ret = m_permessage_deflate.negotiate(it->second);
158 lib::error_code ec = m_permessage_deflate.init(base::m_server);
171 ret.second += neg_ret.second;
186 if (r.get_method() !=
"GET") {
190 if (r.get_version() !=
"HTTP/1.1") {
198 if (r.get_header(
"Sec-WebSocket-Key").empty()) {
202 return lib::error_code();
210 std::string
const & subprotocol, response_type & response)
const 212 std::string server_key = request.get_header(
"Sec-WebSocket-Key");
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);
224 if (!subprotocol.empty()) {
225 response.replace_header(
"Sec-WebSocket-Protocol",subprotocol);
228 return lib::error_code();
238 uri, std::vector<std::string>
const & subprotocols)
const 240 req.set_method(
"GET");
241 req.set_uri(uri->get_resource());
242 req.set_version(
"HTTP/1.1");
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());
249 if (!subprotocols.empty()) {
250 std::ostringstream result;
251 std::vector<std::string>::const_iterator it = subprotocols.begin();
253 while (it != subprotocols.end()) {
254 result <<
", " << *it++;
257 req.replace_header(
"Sec-WebSocket-Protocol",result.str());
262 unsigned char raw_key[16];
264 for (
int i = 0; i < 4; i++) {
266 std::copy(conv.c,conv.c+4,&raw_key[i*4]);
269 req.replace_header(
"Sec-WebSocket-Key",
base64_encode(raw_key, 16));
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);
278 return lib::error_code();
288 response_type& res)
const 291 if (res.get_status_code() != http::status_code::switching_protocols) {
296 std::string
const & upgrade_header = res.get_header(
"Upgrade");
298 sizeof(constants::upgrade_token)-1) == upgrade_header.end())
304 std::string
const & con_header = res.get_header(
"Connection");
306 sizeof(constants::connection_token)-1) == con_header.end())
312 std::string key = req.get_header(
"Sec-WebSocket-Key");
315 if (ec || key != res.get_header(
"Sec-WebSocket-Accept")) {
321 return lib::error_code();
324 std::string
get_raw(response_type
const & res)
const {
328 std::string
const &
get_origin(request_type
const & r)
const {
329 return r.get_header(
"Origin");
333 std::vector<std::string> & subprotocol_list)
335 if (!req.get_header(
"Sec-WebSocket-Protocol").empty()) {
338 if (!req.get_header_as_plist(
"Sec-WebSocket-Protocol",p)) {
339 http::parameter_list::const_iterator it;
341 for (it = p.begin(); it != p.end(); ++it) {
342 subprotocol_list.push_back(it->first);
348 return lib::error_code();
382 size_t consume(uint8_t * buf,
size_t len, lib::error_code & ec) {
385 ec = lib::error_code();
391 while (m_state != READY && m_state != FATAL_ERROR &&
392 (p < len || m_bytes_needed == 0))
394 if (m_state == HEADER_BASIC) {
397 if (m_bytes_needed > 0) {
402 m_basic_header, base::m_server, !m_data_msg.msg_ptr
407 m_state = HEADER_EXTENDED;
411 }
else if (m_state == HEADER_EXTENDED) {
414 if (m_bytes_needed > 0) {
421 m_state = APPLICATION;
422 m_bytes_needed =
static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
432 m_msg_manager->get_message(op,m_bytes_needed),
436 m_current_msg = &m_control_msg;
438 if (!m_data_msg.msg_ptr) {
439 if (m_bytes_needed > base::m_max_message_size) {
445 m_msg_manager->get_message(op,m_bytes_needed),
449 if (m_permessage_deflate.is_enabled()) {
455 std::string & out = m_data_msg.msg_ptr->get_raw_payload();
457 if (out.size() + m_bytes_needed > base::m_max_message_size) {
464 m_data_msg.prepared_key = prepare_masking_key(
471 out.reserve(out.size() + m_bytes_needed);
473 m_current_msg = &m_data_msg;
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);
480 if (bytes_to_process > 0) {
486 if (m_bytes_needed > 0) {
498 this->reset_headers();
519 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
523 if (m_permessage_deflate.is_enabled()
524 && m_current_msg->msg_ptr->get_compressed())
526 uint8_t trailer[4] = {0x00, 0x00, 0xff, 0xff};
530 ec = m_permessage_deflate.decompress(trailer,4,out);
538 if (!m_current_msg->validator.
complete()) {
545 return lib::error_code();
548 void reset_headers() {
549 m_state = HEADER_BASIC;
552 m_basic_header.b0 = 0x00;
553 m_basic_header.b1 = 0x00;
556 m_extended_header.bytes,
564 return (m_state == READY);
569 return message_ptr();
571 message_ptr ret = m_current_msg->msg_ptr;
572 m_current_msg->msg_ptr.reset();
575 m_control_msg.msg_ptr.reset();
577 m_data_msg.msg_ptr.reset();
580 this->reset_headers();
587 return m_state == FATAL_ERROR;
591 return m_bytes_needed;
611 frame::opcode::value op = in->get_opcode();
618 std::string& i = in->get_raw_payload();
619 std::string& o = out->get_raw_payload();
622 if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
627 bool masked = !base::m_server;
628 bool compressed = m_permessage_deflate.is_enabled()
629 && in->get_compressed();
630 bool fin = in->get_fin();
642 m_permessage_deflate.compress(i,o);
650 o.resize(o.size()-4);
666 std::copy(i.begin(),i.end(),o.begin());
681 out->set_prepared(
true);
684 return lib::error_code();
688 lib::error_code
prepare_ping(std::string
const & in, message_ptr out)
const {
692 lib::error_code prepare_pong(std::string
const & in, message_ptr out)
const {
697 std::string
const & reason, message_ptr out)
const 721 payload.resize(reason.size()+2);
723 payload[0] = val.c[0];
724 payload[1] = val.c[1];
726 std::copy(reason.begin(),reason.end(),payload.begin()+2);
734 key.append(constants::handshake_guid);
736 unsigned char message_digest[20];
737 sha1::calc(key.c_str(),key.length(),message_digest);
740 return lib::error_code();
745 if (len == 0 || m_bytes_needed == 0) {
751 if (m_bytes_needed == 2) {
752 m_basic_header.b0 = buf[0];
753 m_basic_header.b1 = buf[1];
757 m_basic_header.b1 = buf[0];
763 if (m_bytes_needed == 2) {
764 m_basic_header.b0 = buf[0];
768 m_basic_header.b1 = buf[0];
777 size_t bytes_to_read = (std::min)(m_bytes_needed,len);
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;
783 return bytes_to_read;
804 buf, len, m_current_msg->prepared_key);
808 std::string & out = m_current_msg->msg_ptr->get_raw_payload();
809 size_t offset = out.size();
812 if (m_permessage_deflate.is_enabled()
813 && m_current_msg->msg_ptr->get_compressed())
816 ec = m_permessage_deflate.decompress(buf,len,out);
822 out.append(reinterpret_cast<char *>(buf),len);
826 if (m_current_msg->msg_ptr->get_opcode() == frame::opcode::TEXT) {
827 if (!m_current_msg->validator.
decode(out.begin()+offset,out.end())) {
833 m_bytes_needed -= len;
849 bool is_server,
bool new_msg)
const 893 if (new_msg && op == frame::opcode::CONTINUATION) {
899 op != frame::opcode::CONTINUATION)
912 return lib::error_code();
933 if (basic_size == frame::payload_size_code_16bit &&
939 if (basic_size == frame::payload_size_code_64bit &&
946 if (
sizeof(
size_t) == 4 && (payload_size >> 32)) {
950 return lib::error_code();
978 std::string
const & payload, message_ptr out)
const 993 bool masked = !base::m_server;
997 std::string & o = out->get_raw_payload();
998 o.resize(payload.size());
1010 std::copy(payload.begin(),payload.end(),o.begin());
1013 out->set_opcode(op);
1014 out->set_prepared(
true);
1016 return lib::error_code();
1021 HEADER_EXTENDED = 1,
1033 msg_metadata(message_ptr m,
size_t p) : msg_ptr(m),prepared_key(p) {}
1036 , prepared_key(prepare_masking_key(p)) {}
1038 message_ptr msg_ptr;
1039 size_t prepared_key;
1047 msg_manager_ptr m_msg_manager;
1050 size_t m_bytes_needed;
1072 permessage_deflate_type m_permessage_deflate;
1078 #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.
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.
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 decode(iterator_type begin, iterator_type end)
Advance validator state with input from an iterator pair.
Clients may not send unmasked frames.
bool get_masked(basic_header const &h)
check whether the frame is masked
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
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
int get_version() const
Get the protocol version of this processor.
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 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.
masking_key_type get_masking_key(basic_header const &, extended_header const &)
Extract the masking key from a frame header.
void masked_copy(std::string const &i, std::string &o, frame::masking_key_type key) const
Copy and mask/unmask in one operation.
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.
size_t get_header_len(basic_header const &)
Calculates the full length of the header based on the first bytes.
Continuation without message.
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.
Not supported on 32 bit systems.
Extension related operation was ignored because extensions are disabled.
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.
lib::error_code make_error_code(error::processor_errors e)
Create an error code with the given value and the processor category.
bool ready() const
Test whether or not the processor has a message ready.
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.
lib::error_code process_handshake_key(std::string &key) const
Convert a client handshake key into a server response key in place.
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 prepare_control(frame::opcode::value op, std::string const &payload, message_ptr out) const
Generic prepare control frame with opcode and payload.
lib::shared_ptr< uri > uri_ptr
Pointer to a URI.
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
static value const no_status
A dummy value to indicate that no status code was received.
Servers may not send masked frames.
lib::error_code prepare_ping(std::string const &in, message_ptr out) const
Get URI.
Fragmented control message.
Processor encountered a message that was too large.
Error parsing extensions.
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.
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.
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.
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.
Type used to convert close statuses between integer and wire representations.
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.
err_str_pair negotiate_extensions(response_type const &response)
Initializes extensions based on the Sec-WebSocket-Extensions header.
bool complete()
Return whether the input sequence ended on a valid utf8 codepoint.