WebSocket++  0.8.3-dev
C++ websocket client/server library
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
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 
49 namespace websocketpp {
50 namespace processor {
51 
52 /// Processor for Hybi version 13 (RFC6455)
53 template <typename config>
54 class hybi13 : public processor<config> {
55 public:
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 
96  /// Extension negotiation helper function
97  /**
98  * This exists mostly because the code for requests and responses is
99  * identical and I can't have virtual template methods.
100  */
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 
112  http::parameter_list p;
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 
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  */
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 
231  /// Fill in a set of request headers for a client connection request
232  /**
233  * @param [out] req Set of headers to fill in
234  * @param [in] uri The uri being connected to
235  * @param [in] subprotocols The list of subprotocols to request
236  */
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
261  frame::uint32_converter conv;
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 
281  /// Validate the server's response to an outgoing handshake request
282  /**
283  * @param req The original request sent
284  * @param res The reponse to generate
285  * @return An error code, 0 on success, non-zero for other errors
286  */
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) {
292  return error::make_error_code(error::invalid_http_status);
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  {
300  return error::make_error_code(error::missing_required_header);
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  {
308  return error::make_error_code(error::missing_required_header);
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")) {
316  return error::make_error_code(error::missing_required_header);
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 
334  {
335  if (!req.get_header("Sec-WebSocket-Protocol").empty()) {
336  http::parameter_list p;
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 {
345  return error::make_error_code(error::subprotocol_parse_error);
346  }
347  }
348  return lib::error_code();
349  }
350 
352  return get_uri_from_host(request,(base::m_secure ? "wss" : "ws"));
353  }
354 
355  /// Process new websocket connection bytes
356  /**
357  *
358  * Hybi 13 data streams represent a series of variable length frames. Each
359  * frame is made up of a series of fixed length fields. The lengths of later
360  * fields are contained in earlier fields. The first field length is fixed
361  * by the spec.
362  *
363  * This processor represents a state machine that keeps track of what field
364  * is presently being read and how many more bytes are needed to complete it
365  *
366  *
367  *
368  *
369  * Read two header bytes
370  * Extract full frame length.
371  * Read extra header bytes
372  * Validate frame header (including extension validate)
373  * Read extension data into extension message state object
374  * Read payload data into payload
375  *
376  * @param buf Input buffer
377  *
378  * @param len Length of input buffer
379  *
380  * @return Number of bytes processed or zero on error
381  */
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 
401  ec = this->validate_incoming_basic_header(
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) -
410  frame::BASIC_HEADER_LENGTH;
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 
430  if (frame::opcode::is_control(op)) {
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(
465  frame::get_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 
510  /// Perform any finalization actions on an incoming message
511  /**
512  * Called after the full message is received. Provides the opportunity for
513  * extensions to complete any data post processing as well as final UTF8
514  * validation checks for text messages.
515  *
516  * @return A code indicating errors, if any
517  */
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,
557  frame::MAX_EXTENDED_HEADER_LENGTH,
558  0x00
559  );
560  }
561 
562  /// Test whether or not the processor has a message ready
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 
585  /// Test whether or not the processor is in a fatal error state.
586  bool get_error() const {
587  return m_state == FATAL_ERROR;
588  }
589 
591  return m_bytes_needed;
592  }
593 
594  /// Prepare a user data message for writing
595  /**
596  * Performs validation, masking, compression, etc. will return an error if
597  * there was an error, otherwise msg will be ready to be written
598  *
599  * TODO: tests
600  *
601  * @param in An unprepared message to prepare
602  * @param out A message to be overwritten with the prepared message
603  * @return error code
604  */
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
614  if (frame::opcode::is_control(op)) {
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 
626  frame::masking_key_type key;
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 
687  /// Get URI
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 
703  if (close::status::invalid(code) && code != close::status::no_status) {
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  }
731 protected:
732  /// Convert a client handshake key into a server response key in place
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 
743  /// Reads bytes from buf into m_basic_header
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 
775  /// Reads bytes from buf into m_extended_header
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 
786  /// Reads bytes from buf into message payload
787  /**
788  * This function performs unmasking and uncompression, validates the
789  * decoded bytes, and writes them to the appropriate message buffer.
790  *
791  * This member function will use the input buffer as stratch space for its
792  * work. The raw input bytes will not be preserved. This applies only to the
793  * bytes actually needed. At most min(m_bytes_needed,len) will be processed.
794  *
795  * @param buf Input/working buffer
796  * @param len Length of buf
797  * @return Number of bytes processed or zero in case of an error
798  */
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 
838  /// Validate an incoming basic header
839  /**
840  * Validates an incoming hybi13 basic header.
841  *
842  * @param h The basic header to validate
843  * @param is_server Whether or not the endpoint that received this frame
844  * is a server.
845  * @param new_msg Whether or not this is the first frame of the message
846  * @return 0 on success or a non-zero error code on failure
847  */
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
854  if (frame::opcode::is_control(op) &&
855  frame::get_basic_size(h) > frame::limits::payload_size_basic)
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()
867  || frame::opcode::is_control(op)))
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
888  if (frame::opcode::is_control(op) && !frame::get_fin(h)) {
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 
915  /// Validate an incoming extended header
916  /**
917  * Validates an incoming hybi13 full header.
918  *
919  * @todo unit test for the >32 bit frames on 32 bit systems case
920  *
921  * @param h The basic header to validate
922  * @param e The extended header to validate
923  * @return An error_code, non-zero values indicate why the validation
924  * failed
925  */
927  frame::extended_header e) const
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 &&
940  payload_size <= frame::limits::payload_size_extended)
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 
953  /// Copy and mask/unmask in one operation
954  /**
955  * Reads input from one string and writes unmasked output to another.
956  *
957  * @param [in] i The input string.
958  * @param [out] o The output string.
959  * @param [in] key The masking key to use for masking/unmasking
960  */
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 
968  /// Generic prepare control frame with opcode and payload.
969  /**
970  * Internal control frame building method. Handles validation, masking, etc
971  *
972  * @param op The control opcode to use
973  * @param payload The payload to use
974  * @param out The message buffer to store the prepared frame in
975  * @return Status code, zero on success, non-zero on error
976  */
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 
992  frame::masking_key_type key;
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 
1028  /// This data structure holds data related to processing a message, such as
1029  /// the buffer it is being written to, its masking key, its UTF8 validation
1030  /// state, and sometimes its compression state.
1031  struct msg_metadata {
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
websocketpp::processor::hybi13::get_message
message_ptr get_message()
Retrieves the most recently processed message.
Definition: hybi13.hpp:567
websocketpp::processor::hybi13::get_uri
uri_ptr get_uri(request_type const &request) const
Extracts client uri from a handshake request.
Definition: hybi13.hpp:351
websocketpp::processor::hybi13::copy_basic_header_bytes
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
websocketpp::processor::hybi13::copy_extended_header_bytes
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
websocketpp::processor::hybi13::validate_incoming_basic_header
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
websocketpp::processor::hybi13::get_version
int get_version() const
Get the protocol version of this processor.
Definition: hybi13.hpp:80
websocketpp::processor::hybi13::masked_copy
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
websocketpp::processor::hybi13::process_handshake_key
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
websocketpp::processor::hybi13::get_bytes_needed
size_t get_bytes_needed() const
Definition: hybi13.hpp:590
websocketpp::processor::hybi13::get_origin
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
Definition: hybi13.hpp:328
websocketpp::processor::hybi13::get_error
bool get_error() const
Test whether or not the processor is in a fatal error state.
Definition: hybi13.hpp:586
websocketpp::processor::hybi13::negotiate_extensions
err_str_pair negotiate_extensions(request_type const &request)
Initializes extensions based on the Sec-WebSocket-Extensions header.
Definition: hybi13.hpp:88
websocketpp::processor::hybi13::extract_subprotocols
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
websocketpp::processor::hybi13::ready
bool ready() const
Test whether or not the processor has a message ready.
Definition: hybi13.hpp:563
websocketpp::versions_supported
static std::vector< int > const versions_supported(helper, helper+4)
Container that stores the list of protocol versions supported.
websocketpp::processor::hybi13::process_payload_bytes
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
websocketpp::processor::hybi13::finalize_message
lib::error_code finalize_message()
Perform any finalization actions on an incoming message.
Definition: hybi13.hpp:518
websocketpp::processor::hybi13::prepare_ping
lib::error_code prepare_ping(std::string const &in, message_ptr out) const
Get URI.
Definition: hybi13.hpp:688
websocketpp::processor::hybi13::prepare_control
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
websocketpp::processor::hybi13::negotiate_extensions
err_str_pair negotiate_extensions(response_type const &response)
Initializes extensions based on the Sec-WebSocket-Extensions header.
Definition: hybi13.hpp:92
websocketpp::processor::hybi13::get_raw
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
websocketpp::processor::hybi13::consume
size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)
Process new websocket connection bytes.
Definition: hybi13.hpp:382
websocketpp::processor
Processors encapsulate the protocol rules specific to each WebSocket version.
Definition: base.hpp:41
websocketpp::processor::hybi13::validate_incoming_extended_header
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
websocketpp::processor::hybi13::msg_metadata
Definition: hybi13.hpp:1031
websocketpp::processor::hybi13::negotiate_extensions_helper
err_str_pair negotiate_extensions_helper(header_type const &header)
Extension negotiation helper function.
Definition: hybi13.hpp:102
websocketpp::processor::hybi13
Processor for Hybi version 13 (RFC6455)
Definition: hybi13.hpp:54
websocketpp::processor::hybi13::validate_server_handshake_response
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
websocketpp::processor::hybi13::validate_handshake
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
Definition: hybi13.hpp:185
websocketpp::processor::hybi13::client_handshake_request
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
websocketpp::processor::hybi13::process_handshake
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
websocketpp::processor::hybi13::prepare_data_frame
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
Prepare a user data message for writing.
Definition: hybi13.hpp:605