WebSocket++  0.8.0-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  if (m_permessage_deflate.is_implemented()) {
129  err_str_pair neg_ret;
130  for (it = p.begin(); it != p.end(); ++it) {
131  // look through each extension, if the key is permessage-deflate
132  if (it->first == "permessage-deflate") {
133  // if we have already successfully negotiated this extension
134  // then skip any other requests to negotiate the same one
135  // with different parameters
136  if (m_permessage_deflate.is_enabled()) {
137  continue;
138  }
139 
140 
141  neg_ret = m_permessage_deflate.negotiate(it->second);
142 
143  if (neg_ret.first) {
144  // Figure out if this is an error that should halt all
145  // extension negotiations or simply cause negotiation of
146  // this specific extension to fail.
147  //std::cout << "permessage-compress negotiation failed: "
148  // << neg_ret.first.message() << std::endl;
149  } else {
150  // Note: this list will need commas if WebSocket++ ever
151  // supports more than one extension
152  ret.second += neg_ret.second;
153  m_permessage_deflate.init(base::m_server);
154  continue;
155  }
156  }
157  }
158  }
159 
160  return ret;
161  }
162 
164  if (r.get_method() != "GET") {
165  return make_error_code(error::invalid_http_method);
166  }
167 
168  if (r.get_version() != "HTTP/1.1") {
169  return make_error_code(error::invalid_http_version);
170  }
171 
172  // required headers
173  // Host is required by HTTP/1.1
174  // Connection is required by is_websocket_handshake
175  // Upgrade is required by is_websocket_handshake
176  if (r.get_header("Sec-WebSocket-Key").empty()) {
177  return make_error_code(error::missing_required_header);
178  }
179 
180  return lib::error_code();
181  }
182 
183  /* TODO: the 'subprotocol' parameter may need to be expanded into a more
184  * generic struct if other user input parameters to the processed handshake
185  * are found.
186  */
188  std::string const & subprotocol, response_type & response) const
189  {
190  std::string server_key = request.get_header("Sec-WebSocket-Key");
191 
192  lib::error_code ec = process_handshake_key(server_key);
193 
194  if (ec) {
195  return ec;
196  }
197 
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);
201 
202  if (!subprotocol.empty()) {
203  response.replace_header("Sec-WebSocket-Protocol",subprotocol);
204  }
205 
206  return lib::error_code();
207  }
208 
209  /// Fill in a set of request headers for a client connection request
210  /**
211  * @param [out] req Set of headers to fill in
212  * @param [in] uri The uri being connected to
213  * @param [in] subprotocols The list of subprotocols to request
214  */
216  uri, std::vector<std::string> const & subprotocols) const
217  {
218  req.set_method("GET");
219  req.set_uri(uri->get_resource());
220  req.set_version("HTTP/1.1");
221 
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());
226 
227  if (!subprotocols.empty()) {
228  std::ostringstream result;
229  std::vector<std::string>::const_iterator it = subprotocols.begin();
230  result << *it++;
231  while (it != subprotocols.end()) {
232  result << ", " << *it++;
233  }
234 
235  req.replace_header("Sec-WebSocket-Protocol",result.str());
236  }
237 
238  // Generate handshake key
239  frame::uint32_converter conv;
240  unsigned char raw_key[16];
241 
242  for (int i = 0; i < 4; i++) {
243  conv.i = m_rng();
244  std::copy(conv.c,conv.c+4,&raw_key[i*4]);
245  }
246 
247  req.replace_header("Sec-WebSocket-Key",base64_encode(raw_key, 16));
248 
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);
253  }
254  }
255 
256  return lib::error_code();
257  }
258 
259  /// Validate the server's response to an outgoing handshake request
260  /**
261  * @param req The original request sent
262  * @param res The reponse to generate
263  * @return An error code, 0 on success, non-zero for other errors
264  */
266  response_type& res) const
267  {
268  // A valid response has an HTTP 101 switching protocols code
269  if (res.get_status_code() != http::status_code::switching_protocols) {
270  return error::make_error_code(error::invalid_http_status);
271  }
272 
273  // And the upgrade token in an upgrade header
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())
277  {
278  return error::make_error_code(error::missing_required_header);
279  }
280 
281  // And the websocket token in the connection 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())
285  {
286  return error::make_error_code(error::missing_required_header);
287  }
288 
289  // And has a valid Sec-WebSocket-Accept value
290  std::string key = req.get_header("Sec-WebSocket-Key");
291  lib::error_code ec = process_handshake_key(key);
292 
293  if (ec || key != res.get_header("Sec-WebSocket-Accept")) {
294  return error::make_error_code(error::missing_required_header);
295  }
296 
297  // check extensions
298 
299  return lib::error_code();
300  }
301 
302  std::string get_raw(response_type const & res) const {
303  return res.raw();
304  }
305 
306  std::string const & get_origin(request_type const & r) const {
307  return r.get_header("Origin");
308  }
309 
312  {
313  if (!req.get_header("Sec-WebSocket-Protocol").empty()) {
314  http::parameter_list p;
315 
316  if (!req.get_header_as_plist("Sec-WebSocket-Protocol",p)) {
317  http::parameter_list::const_iterator it;
318 
319  for (it = p.begin(); it != p.end(); ++it) {
320  subprotocol_list.push_back(it->first);
321  }
322  } else {
323  return error::make_error_code(error::subprotocol_parse_error);
324  }
325  }
326  return lib::error_code();
327  }
328 
330  return get_uri_from_host(request,(base::m_secure ? "wss" : "ws"));
331  }
332 
333  /// Process new websocket connection bytes
334  /**
335  *
336  * Hybi 13 data streams represent a series of variable length frames. Each
337  * frame is made up of a series of fixed length fields. The lengths of later
338  * fields are contained in earlier fields. The first field length is fixed
339  * by the spec.
340  *
341  * This processor represents a state machine that keeps track of what field
342  * is presently being read and how many more bytes are needed to complete it
343  *
344  *
345  *
346  *
347  * Read two header bytes
348  * Extract full frame length.
349  * Read extra header bytes
350  * Validate frame header (including extension validate)
351  * Read extension data into extension message state object
352  * Read payload data into payload
353  *
354  * @param buf Input buffer
355  *
356  * @param len Length of input buffer
357  *
358  * @return Number of bytes processed or zero on error
359  */
360  size_t consume(uint8_t * buf, size_t len, lib::error_code & ec) {
361  size_t p = 0;
362 
363  ec = lib::error_code();
364 
365  //std::cout << "consume: " << utility::to_hex(buf,len) << std::endl;
366 
367  // Loop while we don't have a message ready and we still have bytes
368  // left to process.
369  while (m_state != READY && m_state != FATAL_ERROR &&
370  (p < len || m_bytes_needed == 0))
371  {
372  if (m_state == HEADER_BASIC) {
373  p += this->copy_basic_header_bytes(buf+p,len-p);
374 
375  if (m_bytes_needed > 0) {
376  continue;
377  }
378 
379  ec = this->validate_incoming_basic_header(
380  m_basic_header, base::m_server, !m_data_msg.msg_ptr
381  );
382  if (ec) {break;}
383 
384  // extract full header size and adjust consume state accordingly
385  m_state = HEADER_EXTENDED;
386  m_cursor = 0;
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);
391 
392  if (m_bytes_needed > 0) {
393  continue;
394  }
395 
396  ec = validate_incoming_extended_header(m_basic_header,m_extended_header);
397  if (ec){break;}
398 
399  m_state = APPLICATION;
400  m_bytes_needed = static_cast<size_t>(get_payload_size(m_basic_header,m_extended_header));
401 
402  // check if this frame is the start of a new message and set up
403  // the appropriate message metadata.
404  frame::opcode::value op = frame::get_opcode(m_basic_header);
405 
406  // TODO: get_message failure conditions
407 
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)
412  );
413 
414  m_current_msg = &m_control_msg;
415  } else {
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);
419  break;
420  }
421 
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)
425  );
426 
427  if (m_permessage_deflate.is_enabled()) {
428  m_data_msg.msg_ptr->set_compressed(frame::get_rsv1(m_basic_header));
429  }
430  } else {
431  // Fetch the underlying payload buffer from the data message we
432  // are writing into.
433  std::string & out = m_data_msg.msg_ptr->get_raw_payload();
434 
435  if (out.size() + m_bytes_needed > base::m_max_message_size) {
436  ec = make_error_code(error::message_too_big);
437  break;
438  }
439 
440  // Each frame starts a new masking key. All other state
441  // remains between frames.
442  m_data_msg.prepared_key = prepare_masking_key(
443  frame::get_masking_key(
444  m_basic_header,
445  m_extended_header
446  )
447  );
448 
449  out.reserve(out.size() + m_bytes_needed);
450  }
451  m_current_msg = &m_data_msg;
452  }
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);
457 
458  if (bytes_to_process > 0) {
459  p += this->process_payload_bytes(buf+p,bytes_to_process,ec);
460 
461  if (ec) {break;}
462  }
463 
464  if (m_bytes_needed > 0) {
465  continue;
466  }
467 
468  // If this was the last frame in the message set the ready flag.
469  // Otherwise, reset processor state to read additional frames.
470  if (frame::get_fin(m_basic_header)) {
471  ec = finalize_message();
472  if (ec) {
473  break;
474  }
475  } else {
476  this->reset_headers();
477  }
478  } else {
479  // shouldn't be here
480  ec = make_error_code(error::general);
481  return 0;
482  }
483  }
484 
485  return p;
486  }
487 
488  /// Perform any finalization actions on an incoming message
489  /**
490  * Called after the full message is received. Provides the opportunity for
491  * extensions to complete any data post processing as well as final UTF8
492  * validation checks for text messages.
493  *
494  * @return A code indicating errors, if any
495  */
497  std::string & out = m_current_msg->msg_ptr->get_raw_payload();
498 
499  // if the frame is compressed, append the compression
500  // trailer and flush the compression buffer.
501  if (m_permessage_deflate.is_enabled()
502  && m_current_msg->msg_ptr->get_compressed())
503  {
504  uint8_t trailer[4] = {0x00, 0x00, 0xff, 0xff};
505 
506  // Decompress current buffer into the message buffer
507  lib::error_code ec;
508  ec = m_permessage_deflate.decompress(trailer,4,out);
509  if (ec) {
510  return ec;
511  }
512  }
513 
514  // ensure that text messages end on a valid UTF8 code point
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);
518  }
519  }
520 
521  m_state = READY;
522 
523  return lib::error_code();
524  }
525 
526  void reset_headers() {
527  m_state = HEADER_BASIC;
528  m_bytes_needed = frame::BASIC_HEADER_LENGTH;
529 
530  m_basic_header.b0 = 0x00;
531  m_basic_header.b1 = 0x00;
532 
533  std::fill_n(
534  m_extended_header.bytes,
535  frame::MAX_EXTENDED_HEADER_LENGTH,
536  0x00
537  );
538  }
539 
540  /// Test whether or not the processor has a message ready
541  bool ready() const {
542  return (m_state == READY);
543  }
544 
545  message_ptr get_message() {
546  if (!ready()) {
547  return message_ptr();
548  }
549  message_ptr ret = m_current_msg->msg_ptr;
550  m_current_msg->msg_ptr.reset();
551 
552  if (frame::opcode::is_control(ret->get_opcode())) {
553  m_control_msg.msg_ptr.reset();
554  } else {
555  m_data_msg.msg_ptr.reset();
556  }
557 
558  this->reset_headers();
559 
560  return ret;
561  }
562 
563  /// Test whether or not the processor is in a fatal error state.
564  bool get_error() const {
565  return m_state == FATAL_ERROR;
566  }
567 
568  size_t get_bytes_needed() const {
569  return m_bytes_needed;
570  }
571 
572  /// Prepare a user data message for writing
573  /**
574  * Performs validation, masking, compression, etc. will return an error if
575  * there was an error, otherwise msg will be ready to be written
576  *
577  * TODO: tests
578  *
579  * @param in An unprepared message to prepare
580  * @param out A message to be overwritten with the prepared message
581  * @return error code
582  */
584  {
585  if (!in || !out) {
586  return make_error_code(error::invalid_arguments);
587  }
588 
589  frame::opcode::value op = in->get_opcode();
590 
591  // validate opcode: only regular data frames
592  if (frame::opcode::is_control(op)) {
593  return make_error_code(error::invalid_opcode);
594  }
595 
596  std::string& i = in->get_raw_payload();
597  std::string& o = out->get_raw_payload();
598 
599  // validate payload utf8
600  if (op == frame::opcode::TEXT && !utf8_validator::validate(i)) {
601  return make_error_code(error::invalid_payload);
602  }
603 
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();
609 
610  if (masked) {
611  // Generate masking key.
612  key.i = m_rng();
613  } else {
614  key.i = 0;
615  }
616 
617  // prepare payload
618  if (compressed) {
619  // compress and store in o after header.
620  m_permessage_deflate.compress(i,o);
621 
622  if (o.size() < 4) {
623  return make_error_code(error::general);
624  }
625 
626  // Strip trailing 4 0x00 0x00 0xff 0xff bytes before writing to the
627  // wire
628  o.resize(o.size()-4);
629 
630  // mask in place if necessary
631  if (masked) {
632  this->masked_copy(o,o,key);
633  }
634  } else {
635  // no compression, just copy data into the output buffer
636  o.resize(i.size());
637 
638  // if we are masked, have the masking function write to the output
639  // buffer directly to avoid another copy. If not masked, copy
640  // directly without masking.
641  if (masked) {
642  this->masked_copy(i,o,key);
643  } else {
644  std::copy(i.begin(),i.end(),o.begin());
645  }
646  }
647 
648  // generate header
649  frame::basic_header h(op,o.size(),fin,masked,compressed);
650 
651  if (masked) {
652  frame::extended_header e(o.size(),key.i);
653  out->set_header(frame::prepare_header(h,e));
654  } else {
655  frame::extended_header e(o.size());
656  out->set_header(frame::prepare_header(h,e));
657  }
658 
659  out->set_prepared(true);
660  out->set_opcode(op);
661 
662  return lib::error_code();
663  }
664 
665  /// Get URI
667  return this->prepare_control(frame::opcode::PING,in,out);
668  }
669 
670  lib::error_code prepare_pong(std::string const & in, message_ptr out) const {
671  return this->prepare_control(frame::opcode::PONG,in,out);
672  }
673 
674  virtual lib::error_code prepare_close(close::status::value code,
675  std::string const & reason, message_ptr out) const
676  {
677  if (close::status::reserved(code)) {
678  return make_error_code(error::reserved_close_code);
679  }
680 
681  if (close::status::invalid(code) && code != close::status::no_status) {
682  return make_error_code(error::invalid_close_code);
683  }
684 
685  if (code == close::status::no_status && reason.size() > 0) {
686  return make_error_code(error::reason_requires_code);
687  }
688 
689  if (reason.size() > frame:: limits::payload_size_basic-2) {
690  return make_error_code(error::control_too_big);
691  }
692 
693  std::string payload;
694 
695  if (code != close::status::no_status) {
696  close::code_converter val;
697  val.i = htons(code);
698 
699  payload.resize(reason.size()+2);
700 
701  payload[0] = val.c[0];
702  payload[1] = val.c[1];
703 
704  std::copy(reason.begin(),reason.end(),payload.begin()+2);
705  }
706 
707  return this->prepare_control(frame::opcode::CLOSE,payload,out);
708  }
709 protected:
710  /// Convert a client handshake key into a server response key in place
712  key.append(constants::handshake_guid);
713 
714  unsigned char message_digest[20];
715  sha1::calc(key.c_str(),key.length(),message_digest);
716  key = base64_encode(message_digest,20);
717 
718  return lib::error_code();
719  }
720 
721  /// Reads bytes from buf into m_basic_header
722  size_t copy_basic_header_bytes(uint8_t const * buf, size_t len) {
723  if (len == 0 || m_bytes_needed == 0) {
724  return 0;
725  }
726 
727  if (len > 1) {
728  // have at least two bytes
729  if (m_bytes_needed == 2) {
730  m_basic_header.b0 = buf[0];
731  m_basic_header.b1 = buf[1];
732  m_bytes_needed -= 2;
733  return 2;
734  } else {
735  m_basic_header.b1 = buf[0];
736  m_bytes_needed--;
737  return 1;
738  }
739  } else {
740  // have exactly one byte
741  if (m_bytes_needed == 2) {
742  m_basic_header.b0 = buf[0];
743  m_bytes_needed--;
744  return 1;
745  } else {
746  m_basic_header.b1 = buf[0];
747  m_bytes_needed--;
748  return 1;
749  }
750  }
751  }
752 
753  /// Reads bytes from buf into m_extended_header
754  size_t copy_extended_header_bytes(uint8_t const * buf, size_t len) {
755  size_t bytes_to_read = (std::min)(m_bytes_needed,len);
756 
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;
760 
761  return bytes_to_read;
762  }
763 
764  /// Reads bytes from buf into message payload
765  /**
766  * This function performs unmasking and uncompression, validates the
767  * decoded bytes, and writes them to the appropriate message buffer.
768  *
769  * This member function will use the input buffer as stratch space for its
770  * work. The raw input bytes will not be preserved. This applies only to the
771  * bytes actually needed. At most min(m_bytes_needed,len) will be processed.
772  *
773  * @param buf Input/working buffer
774  * @param len Length of buf
775  * @return Number of bytes processed or zero in case of an error
776  */
777  size_t process_payload_bytes(uint8_t * buf, size_t len, lib::error_code& ec)
778  {
779  // unmask if masked
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);
783  // TODO: SIMD masking
784  }
785 
786  std::string & out = m_current_msg->msg_ptr->get_raw_payload();
787  size_t offset = out.size();
788 
789  // decompress message if needed.
790  if (m_permessage_deflate.is_enabled()
791  && m_current_msg->msg_ptr->get_compressed())
792  {
793  // Decompress current buffer into the message buffer
794  ec = m_permessage_deflate.decompress(buf,len,out);
795  if (ec) {
796  return 0;
797  }
798  } else {
799  // No compression, straight copy
800  out.append(reinterpret_cast<char *>(buf),len);
801  }
802 
803  // validate unmasked, decompressed values
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);
807  return 0;
808  }
809  }
810 
811  m_bytes_needed -= len;
812 
813  return len;
814  }
815 
816  /// Validate an incoming basic header
817  /**
818  * Validates an incoming hybi13 basic header.
819  *
820  * @param h The basic header to validate
821  * @param is_server Whether or not the endpoint that received this frame
822  * is a server.
823  * @param new_msg Whether or not this is the first frame of the message
824  * @return 0 on success or a non-zero error code on failure
825  */
827  bool is_server, bool new_msg) const
828  {
829  frame::opcode::value op = frame::get_opcode(h);
830 
831  // Check control frame size limit
832  if (frame::opcode::is_control(op) &&
833  frame::get_basic_size(h) > frame::limits::payload_size_basic)
834  {
835  return make_error_code(error::control_too_big);
836  }
837 
838  // Check that RSV bits are clear
839  // The only RSV bits allowed are rsv1 if the permessage_compress
840  // extension is enabled for this connection and the message is not
841  // a control message.
842  //
843  // TODO: unit tests for this
844  if (frame::get_rsv1(h) && (!m_permessage_deflate.is_enabled()
845  || frame::opcode::is_control(op)))
846  {
847  return make_error_code(error::invalid_rsv_bit);
848  }
849 
850  if (frame::get_rsv2(h) || frame::get_rsv3(h)) {
851  return make_error_code(error::invalid_rsv_bit);
852  }
853 
854  // Check for reserved opcodes
855  if (frame::opcode::reserved(op)) {
856  return make_error_code(error::invalid_opcode);
857  }
858 
859  // Check for invalid opcodes
860  // TODO: unit tests for this?
861  if (frame::opcode::invalid(op)) {
862  return make_error_code(error::invalid_opcode);
863  }
864 
865  // Check for fragmented control message
866  if (frame::opcode::is_control(op) && !frame::get_fin(h)) {
867  return make_error_code(error::fragmented_control);
868  }
869 
870  // Check for continuation without an active message
871  if (new_msg && op == frame::opcode::CONTINUATION) {
872  return make_error_code(error::invalid_continuation);
873  }
874 
875  // Check for new data frame when expecting continuation
876  if (!new_msg && !frame::opcode::is_control(op) &&
877  op != frame::opcode::CONTINUATION)
878  {
879  return make_error_code(error::invalid_continuation);
880  }
881 
882  // Servers should reject any unmasked frames from clients.
883  // Clients should reject any masked frames from servers.
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);
888  }
889 
890  return lib::error_code();
891  }
892 
893  /// Validate an incoming extended header
894  /**
895  * Validates an incoming hybi13 full header.
896  *
897  * @todo unit test for the >32 bit frames on 32 bit systems case
898  *
899  * @param h The basic header to validate
900  * @param e The extended header to validate
901  * @return An error_code, non-zero values indicate why the validation
902  * failed
903  */
905  frame::extended_header e) const
906  {
907  uint8_t basic_size = frame::get_basic_size(h);
908  uint64_t payload_size = frame::get_payload_size(h,e);
909 
910  // Check for non-minimally encoded payloads
911  if (basic_size == frame::payload_size_code_16bit &&
912  payload_size <= frame::limits::payload_size_basic)
913  {
914  return make_error_code(error::non_minimal_encoding);
915  }
916 
917  if (basic_size == frame::payload_size_code_64bit &&
918  payload_size <= frame::limits::payload_size_extended)
919  {
920  return make_error_code(error::non_minimal_encoding);
921  }
922 
923  // Check for >32bit frames on 32 bit systems
924  if (sizeof(size_t) == 4 && (payload_size >> 32)) {
925  return make_error_code(error::requires_64bit);
926  }
927 
928  return lib::error_code();
929  }
930 
931  /// Copy and mask/unmask in one operation
932  /**
933  * Reads input from one string and writes unmasked output to another.
934  *
935  * @param [in] i The input string.
936  * @param [out] o The output string.
937  * @param [in] key The masking key to use for masking/unmasking
938  */
939  void masked_copy (std::string const & i, std::string & o,
940  frame::masking_key_type key) const
941  {
942  frame::byte_mask(i.begin(),i.end(),o.begin(),key);
943  // TODO: SIMD masking
944  }
945 
946  /// Generic prepare control frame with opcode and payload.
947  /**
948  * Internal control frame building method. Handles validation, masking, etc
949  *
950  * @param op The control opcode to use
951  * @param payload The payload to use
952  * @param out The message buffer to store the prepared frame in
953  * @return Status code, zero on success, non-zero on error
954  */
956  std::string const & payload, message_ptr out) const
957  {
958  if (!out) {
959  return make_error_code(error::invalid_arguments);
960  }
961 
962  if (!frame::opcode::is_control(op)) {
963  return make_error_code(error::invalid_opcode);
964  }
965 
966  if (payload.size() > frame::limits::payload_size_basic) {
967  return make_error_code(error::control_too_big);
968  }
969 
970  frame::masking_key_type key;
971  bool masked = !base::m_server;
972 
973  frame::basic_header h(op,payload.size(),true,masked);
974 
975  std::string & o = out->get_raw_payload();
976  o.resize(payload.size());
977 
978  if (masked) {
979  // Generate masking key.
980  key.i = m_rng();
981 
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);
985  } else {
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());
989  }
990 
991  out->set_opcode(op);
992  out->set_prepared(true);
993 
994  return lib::error_code();
995  }
996 
997  enum state {
998  HEADER_BASIC = 0,
999  HEADER_EXTENDED = 1,
1000  EXTENSION = 2,
1001  APPLICATION = 3,
1002  READY = 4,
1003  FATAL_ERROR = 5
1004  };
1005 
1006  /// This data structure holds data related to processing a message, such as
1007  /// the buffer it is being written to, its masking key, its UTF8 validation
1008  /// state, and sometimes its compression state.
1009  struct msg_metadata {
1010  msg_metadata() {}
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)
1013  : msg_ptr(m)
1014  , prepared_key(prepare_masking_key(p)) {}
1015 
1016  message_ptr msg_ptr; // pointer to the message data buffer
1017  size_t prepared_key; // prepared masking key
1018  utf8_validator::validator validator; // utf8 validation state
1019  };
1020 
1021  // Basic header of the frame being read
1022  frame::basic_header m_basic_header;
1023 
1024  // Pointer to a manager that can create message buffers for us.
1025  msg_manager_ptr m_msg_manager;
1026 
1027  // Number of bytes needed to complete the current operation
1028  size_t m_bytes_needed;
1029 
1030  // Number of extended header bytes read
1031  size_t m_cursor;
1032 
1033  // Metadata for the current data msg
1034  msg_metadata m_data_msg;
1035  // Metadata for the current control msg
1036  msg_metadata m_control_msg;
1037 
1038  // Pointer to the metadata associated with the frame being read
1039  msg_metadata * m_current_msg;
1040 
1041  // Extended header of current frame
1042  frame::extended_header m_extended_header;
1043 
1044  rng_type & m_rng;
1045 
1046  // Overall state of the processor
1047  state m_state;
1048 
1049  // Extensions
1050  permessage_deflate_type m_permessage_deflate;
1051 };
1052 
1053 } // namespace processor
1054 } // namespace websocketpp
1055 
1056 #endif //WEBSOCKETPP_PROCESSOR_HYBI13_HPP
virtual lib::error_code prepare_data_frame(message_ptr in, message_ptr out)
Prepare a user data message for writing.
Definition: hybi13.hpp:583
bool ready() const
Test whether or not the processor has a message ready.
Definition: hybi13.hpp:541
lib::error_code validate_handshake(request_type const &r) const
validate a WebSocket handshake request for this version
Definition: hybi13.hpp:163
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:939
size_t copy_extended_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_extended_header.
Definition: hybi13.hpp:754
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:187
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:777
lib::error_code finalize_message()
Perform any finalization actions on an incoming message.
Definition: hybi13.hpp:496
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:955
bool get_error() const
Test whether or not the processor is in a fatal error state.
Definition: hybi13.hpp:564
std::string const & get_origin(request_type const &r) const
Return the value of the header containing the CORS origin.
Definition: hybi13.hpp:306
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:302
err_str_pair negotiate_extensions_helper(header_type const &header)
Extension negotiation helper function.
Definition: hybi13.hpp:102
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:310
message_ptr get_message()
Retrieves the most recently processed message.
Definition: hybi13.hpp:545
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
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:711
Processors encapsulate the protocol rules specific to each WebSocket version.
Definition: base.hpp:41
lib::error_code prepare_ping(std::string const &in, message_ptr out) const
Get URI.
Definition: hybi13.hpp:666
int get_version() const
Get the protocol version of this processor.
Definition: hybi13.hpp:80
size_t copy_basic_header_bytes(uint8_t const *buf, size_t len)
Reads bytes from buf into m_basic_header.
Definition: hybi13.hpp:722
lib::error_code validate_incoming_extended_header(frame::basic_header h, frame::extended_header e) const
Validate an incoming extended header.
Definition: hybi13.hpp:904
size_t consume(uint8_t *buf, size_t len, lib::error_code &ec)
Process new websocket connection bytes.
Definition: hybi13.hpp:360
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:215
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:826
uri_ptr get_uri(request_type const &request) const
Extracts client uri from a handshake request.
Definition: hybi13.hpp:329
size_t get_bytes_needed() const
Definition: hybi13.hpp:568
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:265
err_str_pair negotiate_extensions(response_type const &response)
Initializes extensions based on the Sec-WebSocket-Extensions header.
Definition: hybi13.hpp:92