WebSocket++  0.8.0-dev
C++ websocket client/server library
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Pages
enabled.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_EXTENSION_PERMESSAGEDEFLATE_HPP
29 #define WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
30 
31 
32 #include <websocketpp/common/cpp11.hpp>
33 #include <websocketpp/common/memory.hpp>
34 #include <websocketpp/common/platforms.hpp>
35 #include <websocketpp/common/system_error.hpp>
36 #include <websocketpp/error.hpp>
37 
38 #include <websocketpp/extensions/extension.hpp>
39 
40 #include "zlib.h"
41 
42 #include <algorithm>
43 #include <string>
44 #include <vector>
45 
46 namespace websocketpp {
47 namespace extensions {
48 
49 /// Implementation of the draft permessage-deflate WebSocket extension
50 /**
51  * ### permessage-deflate interface
52  *
53  * **init**\n
54  * `lib::error_code init(bool is_server)`\n
55  * Performs initialization
56  *
57  * **is_implimented**\n
58  * `bool is_implimented()`\n
59  * Returns whether or not the object impliments the extension or not
60  *
61  * **is_enabled**\n
62  * `bool is_enabled()`\n
63  * Returns whether or not the extension was negotiated for the current
64  * connection
65  *
66  * **generate_offer**\n
67  * `std::string generate_offer() const`\n
68  * Create an extension offer string based on local policy
69  *
70  * **validate_response**\n
71  * `lib::error_code validate_response(http::attribute_list const & response)`\n
72  * Negotiate the parameters of extension use
73  *
74  * **negotiate**\n
75  * `err_str_pair negotiate(http::attribute_list const & attributes)`\n
76  * Negotiate the parameters of extension use
77  *
78  * **compress**\n
79  * `lib::error_code compress(std::string const & in, std::string & out)`\n
80  * Compress the bytes in `in` and append them to `out`
81  *
82  * **decompress**\n
83  * `lib::error_code decompress(uint8_t const * buf, size_t len, std::string &
84  * out)`\n
85  * Decompress `len` bytes from `buf` and append them to string `out`
86  */
87 namespace permessage_deflate {
88 
89 /// Permessage deflate error values
90 namespace error {
91 enum value {
92  /// Catch all
93  general = 1,
94 
95  /// Invalid extension attributes
97 
98  /// Invalid extension attribute value
100 
101  /// Invalid megotiation mode
103 
104  /// Unsupported extension attributes
106 
107  /// Invalid value for max_window_bits
109 
110  /// ZLib Error
112 
113  /// Uninitialized
115 };
116 
117 /// Permessage-deflate error category
118 class category : public lib::error_category {
119 public:
120  category() {}
121 
122  char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
123  return "websocketpp.extension.permessage-deflate";
124  }
125 
126  std::string message(int value) const {
127  switch(value) {
128  case general:
129  return "Generic permessage-compress error";
130  case invalid_attributes:
131  return "Invalid extension attributes";
132  case invalid_attribute_value:
133  return "Invalid extension attribute value";
134  case invalid_mode:
135  return "Invalid permessage-deflate negotiation mode";
136  case unsupported_attributes:
137  return "Unsupported extension attributes";
138  case invalid_max_window_bits:
139  return "Invalid value for max_window_bits";
140  case zlib_error:
141  return "A zlib function returned an error";
142  case uninitialized:
143  return "Deflate extension must be initialized before use";
144  default:
145  return "Unknown permessage-compress error";
146  }
147  }
148 };
149 
150 /// Get a reference to a static copy of the permessage-deflate error category
151 inline lib::error_category const & get_category() {
152  static category instance;
153  return instance;
154 }
155 
156 /// Create an error code in the permessage-deflate category
158  return lib::error_code(static_cast<int>(e), get_category());
159 }
160 
161 } // namespace error
162 } // namespace permessage_deflate
163 } // namespace extensions
164 } // namespace websocketpp
165 
166 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
167 template<> struct is_error_code_enum
168  <websocketpp::extensions::permessage_deflate::error::value>
169 {
170  static bool const value = true;
171 };
172 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
173 namespace websocketpp {
174 namespace extensions {
175 namespace permessage_deflate {
176 
177 /// Default value for server_max_window_bits as defined by draft 17
178 static uint8_t const default_server_max_window_bits = 15;
179 /// Minimum value for server_max_window_bits as defined by draft 17
180 static uint8_t const min_server_max_window_bits = 8;
181 /// Maximum value for server_max_window_bits as defined by draft 17
182 static uint8_t const max_server_max_window_bits = 15;
183 
184 /// Default value for client_max_window_bits as defined by draft 17
185 static uint8_t const default_client_max_window_bits = 15;
186 /// Minimum value for client_max_window_bits as defined by draft 17
187 static uint8_t const min_client_max_window_bits = 8;
188 /// Maximum value for client_max_window_bits as defined by draft 17
189 static uint8_t const max_client_max_window_bits = 15;
190 
191 namespace mode {
192 enum value {
193  /// Accept any value the remote endpoint offers
194  accept = 1,
195  /// Decline any value the remote endpoint offers. Insist on defaults.
196  decline,
197  /// Use the largest value common to both offers
198  largest,
199  /// Use the smallest value common to both offers
200  smallest
201 };
202 } // namespace mode
203 
204 template <typename config>
205 class enabled {
206 public:
207  enabled()
208  : m_enabled(false)
209  , m_server_no_context_takeover(false)
210  , m_client_no_context_takeover(false)
211  , m_server_max_window_bits(15)
212  , m_client_max_window_bits(15)
213  , m_server_max_window_bits_mode(mode::accept)
214  , m_client_max_window_bits_mode(mode::accept)
215  , m_initialized(false)
216  , m_compress_buffer_size(16384)
217  {
218  m_dstate.zalloc = Z_NULL;
219  m_dstate.zfree = Z_NULL;
220  m_dstate.opaque = Z_NULL;
221 
222  m_istate.zalloc = Z_NULL;
223  m_istate.zfree = Z_NULL;
224  m_istate.opaque = Z_NULL;
225  m_istate.avail_in = 0;
226  m_istate.next_in = Z_NULL;
227  }
228 
229  ~enabled() {
230  if (!m_initialized) {
231  return;
232  }
233 
234  int ret = deflateEnd(&m_dstate);
235 
236  if (ret != Z_OK) {
237  //std::cout << "error cleaning up zlib compression state"
238  // << std::endl;
239  }
240 
241  ret = inflateEnd(&m_istate);
242 
243  if (ret != Z_OK) {
244  //std::cout << "error cleaning up zlib decompression state"
245  // << std::endl;
246  }
247  }
248 
249  /// Initialize zlib state
250  /**
251  * Note: this should be called *after* the negotiation methods. It will use
252  * information from the negotiation to determine how to initialize the zlib
253  * data structures.
254  *
255  * @todo memory level, strategy, etc are hardcoded
256  *
257  * @param is_server True to initialize as a server, false for a client.
258  * @return A code representing the error that occurred, if any
259  */
261  uint8_t deflate_bits;
262  uint8_t inflate_bits;
263 
264  if (is_server) {
265  deflate_bits = m_server_max_window_bits;
266  inflate_bits = m_client_max_window_bits;
267  } else {
268  deflate_bits = m_client_max_window_bits;
269  inflate_bits = m_server_max_window_bits;
270  }
271 
272  int ret = deflateInit2(
273  &m_dstate,
274  Z_DEFAULT_COMPRESSION,
275  Z_DEFLATED,
276  -1*deflate_bits,
277  4, // memory level 1-9
278  Z_DEFAULT_STRATEGY
279  );
280 
281  if (ret != Z_OK) {
283  }
284 
285  ret = inflateInit2(
286  &m_istate,
287  -1*inflate_bits
288  );
289 
290  if (ret != Z_OK) {
292  }
293 
294  m_compress_buffer.reset(new unsigned char[m_compress_buffer_size]);
295  if ((m_server_no_context_takeover && is_server) ||
296  (m_client_no_context_takeover && !is_server))
297  {
298  m_flush = Z_FULL_FLUSH;
299  } else {
300  m_flush = Z_SYNC_FLUSH;
301  }
302  m_initialized = true;
303  return lib::error_code();
304  }
305 
306  /// Test if this object implements the permessage-deflate specification
307  /**
308  * Because this object does implieent it, it will always return true.
309  *
310  * @return Whether or not this object implements permessage-deflate
311  */
312  bool is_implemented() const {
313  return true;
314  }
315 
316  /// Test if the extension was negotiated for this connection
317  /**
318  * Retrieves whether or not this extension is in use based on the initial
319  * handshake extension negotiations.
320  *
321  * @return Whether or not the extension is in use
322  */
323  bool is_enabled() const {
324  return m_enabled;
325  }
326 
327  /// Reset server's outgoing LZ77 sliding window for each new message
328  /**
329  * Enabling this setting will cause the server's compressor to reset the
330  * compression state (the LZ77 sliding window) for every message. This
331  * means that the compressor will not look back to patterns in previous
332  * messages to improve compression. This will reduce the compression
333  * efficiency for large messages somewhat and small messages drastically.
334  *
335  * This option may reduce server compressor memory usage and client
336  * decompressor memory usage.
337  * @todo Document to what extent memory usage will be reduced
338  *
339  * For clients, this option is dependent on server support. Enabling it
340  * via this method does not guarantee that it will be successfully
341  * negotiated, only that it will be requested.
342  *
343  * For servers, no client support is required. Enabling this option on a
344  * server will result in its use. The server will signal to clients that
345  * the option will be in use so they can optimize resource usage if they
346  * are able.
347  */
349  m_server_no_context_takeover = true;
350  }
351 
352  /// Reset client's outgoing LZ77 sliding window for each new message
353  /**
354  * Enabling this setting will cause the client's compressor to reset the
355  * compression state (the LZ77 sliding window) for every message. This
356  * means that the compressor will not look back to patterns in previous
357  * messages to improve compression. This will reduce the compression
358  * efficiency for large messages somewhat and small messages drastically.
359  *
360  * This option may reduce client compressor memory usage and server
361  * decompressor memory usage.
362  * @todo Document to what extent memory usage will be reduced
363  *
364  * This option is supported by all compliant clients and servers. Enabling
365  * it via either endpoint should be sufficient to ensure it is used.
366  */
368  m_client_no_context_takeover = true;
369  }
370 
371  /// Limit server LZ77 sliding window size
372  /**
373  * The bits setting is the base 2 logarithm of the maximum window size that
374  * the server must use to compress outgoing messages. The permitted range
375  * is 8 to 15 inclusive. 8 represents a 256 byte window and 15 a 32KiB
376  * window. The default setting is 15.
377  *
378  * Mode Options:
379  * - accept: Accept whatever the remote endpoint offers.
380  * - decline: Decline any offers to deviate from the defaults
381  * - largest: Accept largest window size acceptable to both endpoints
382  * - smallest: Accept smallest window size acceptiable to both endpoints
383  *
384  * This setting is dependent on server support. A client requesting this
385  * setting may be rejected by the server or have the exact value used
386  * adjusted by the server. A server may unilaterally set this value without
387  * client support.
388  *
389  * @param bits The size to request for the outgoing window size
390  * @param mode The mode to use for negotiating this parameter
391  * @return A status code
392  */
395  return error::make_error_code(error::invalid_max_window_bits);
396  }
397  m_server_max_window_bits = bits;
398  m_server_max_window_bits_mode = mode;
399 
400  return lib::error_code();
401  }
402 
403  /// Limit client LZ77 sliding window size
404  /**
405  * The bits setting is the base 2 logarithm of the window size that the
406  * client must use to compress outgoing messages. The permitted range is 8
407  * to 15 inclusive. 8 represents a 256 byte window and 15 a 32KiB window.
408  * The default setting is 15.
409  *
410  * Mode Options:
411  * - accept: Accept whatever the remote endpoint offers.
412  * - decline: Decline any offers to deviate from the defaults
413  * - largest: Accept largest window size acceptable to both endpoints
414  * - smallest: Accept smallest window size acceptiable to both endpoints
415  *
416  * This setting is dependent on client support. A client may limit its own
417  * outgoing window size unilaterally. A server may only limit the client's
418  * window size if the remote client supports that feature.
419  *
420  * @param bits The size to request for the outgoing window size
421  * @param mode The mode to use for negotiating this parameter
422  * @return A status code
423  */
426  return error::make_error_code(error::invalid_max_window_bits);
427  }
428  m_client_max_window_bits = bits;
429  m_client_max_window_bits_mode = mode;
430 
431  return lib::error_code();
432  }
433 
434  /// Generate extension offer
435  /**
436  * Creates an offer string to include in the Sec-WebSocket-Extensions
437  * header of outgoing client requests.
438  *
439  * @return A WebSocket extension offer string for this extension
440  */
441  std::string generate_offer() const {
442  // TODO: this should be dynamically generated based on user settings
443  return "permessage-deflate; client_no_context_takeover; client_max_window_bits";
444  }
445 
446  /// Validate extension response
447  /**
448  * Confirm that the server has negotiated settings compatible with our
449  * original offer and apply those settings to the extension state.
450  *
451  * @param response The server response attribute list to validate
452  * @return Validation error or 0 on success
453  */
455  return lib::error_code();
456  }
457 
458  /// Negotiate extension
459  /**
460  * Confirm that the client's extension negotiation offer has settings
461  * compatible with local policy. If so, generate a reply and apply those
462  * settings to the extension state.
463  *
464  * @param offer Attribute from client's offer
465  * @return Status code and value to return to remote endpoint
466  */
468  err_str_pair ret;
469 
470  http::attribute_list::const_iterator it;
471  for (it = offer.begin(); it != offer.end(); ++it) {
472  if (it->first == "server_no_context_takeover") {
473  negotiate_server_no_context_takeover(it->second,ret.first);
474  } else if (it->first == "client_no_context_takeover") {
475  negotiate_client_no_context_takeover(it->second,ret.first);
476  } else if (it->first == "server_max_window_bits") {
477  negotiate_server_max_window_bits(it->second,ret.first);
478  } else if (it->first == "client_max_window_bits") {
479  negotiate_client_max_window_bits(it->second,ret.first);
480  } else {
481  ret.first = make_error_code(error::invalid_attributes);
482  }
483 
484  if (ret.first) {
485  break;
486  }
487  }
488 
489  if (ret.first == lib::error_code()) {
490  m_enabled = true;
491  ret.second = generate_response();
492  }
493 
494  return ret;
495  }
496 
497  /// Compress bytes
498  /**
499  * @todo: avail_in/out is 32 bit, need to fix for cases of >32 bit frames
500  * on 64 bit machines.
501  *
502  * @param [in] in String to compress
503  * @param [out] out String to append compressed bytes to
504  * @return Error or status code
505  */
507  if (!m_initialized) {
509  }
510 
511  size_t output;
512 
513  if (in.empty()) {
514  uint8_t buf[6] = {0x02, 0x00, 0x00, 0x00, 0xff, 0xff};
515  out.append((char *)(buf),6);
516  return lib::error_code();
517  }
518 
519  m_dstate.avail_in = in.size();
520  m_dstate.next_in = (unsigned char *)(const_cast<char *>(in.data()));
521 
522  do {
523  // Output to local buffer
524  m_dstate.avail_out = m_compress_buffer_size;
525  m_dstate.next_out = m_compress_buffer.get();
526 
527  deflate(&m_dstate, m_flush);
528 
529  output = m_compress_buffer_size - m_dstate.avail_out;
530 
531  out.append((char *)(m_compress_buffer.get()),output);
532  } while (m_dstate.avail_out == 0);
533 
534  return lib::error_code();
535  }
536 
537  /// Decompress bytes
538  /**
539  * @param buf Byte buffer to decompress
540  * @param len Length of buf
541  * @param out String to append decompressed bytes to
542  * @return Error or status code
543  */
545  out)
546  {
547  if (!m_initialized) {
549  }
550 
551  int ret;
552 
553  m_istate.avail_in = len;
554  m_istate.next_in = const_cast<unsigned char *>(buf);
555 
556  do {
557  m_istate.avail_out = m_compress_buffer_size;
558  m_istate.next_out = m_compress_buffer.get();
559 
560  ret = inflate(&m_istate, Z_SYNC_FLUSH);
561 
562  if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
564  }
565 
566  out.append(
567  reinterpret_cast<char *>(m_compress_buffer.get()),
568  m_compress_buffer_size - m_istate.avail_out
569  );
570  } while (m_istate.avail_out == 0);
571 
572  return lib::error_code();
573  }
574 private:
575  /// Generate negotiation response
576  /**
577  * @return Generate extension negotiation reponse string to send to client
578  */
579  std::string generate_response() {
580  std::string ret = "permessage-deflate";
581 
582  if (m_server_no_context_takeover) {
583  ret += "; server_no_context_takeover";
584  }
585 
586  if (m_client_no_context_takeover) {
587  ret += "; client_no_context_takeover";
588  }
589 
590  if (m_server_max_window_bits < default_server_max_window_bits) {
591  std::stringstream s;
592  s << int(m_server_max_window_bits);
593  ret += "; server_max_window_bits="+s.str();
594  }
595 
596  if (m_client_max_window_bits < default_client_max_window_bits) {
597  std::stringstream s;
598  s << int(m_client_max_window_bits);
599  ret += "; client_max_window_bits="+s.str();
600  }
601 
602  return ret;
603  }
604 
605  /// Negotiate server_no_context_takeover attribute
606  /**
607  * @param [in] value The value of the attribute from the offer
608  * @param [out] ec A reference to the error code to return errors via
609  */
610  void negotiate_server_no_context_takeover(std::string const & value,
611  lib::error_code & ec)
612  {
613  if (!value.empty()) {
614  ec = make_error_code(error::invalid_attribute_value);
615  return;
616  }
617 
618  m_server_no_context_takeover = true;
619  }
620 
621  /// Negotiate client_no_context_takeover attribute
622  /**
623  * @param [in] value The value of the attribute from the offer
624  * @param [out] ec A reference to the error code to return errors via
625  */
626  void negotiate_client_no_context_takeover(std::string const & value,
627  lib::error_code & ec)
628  {
629  if (!value.empty()) {
630  ec = make_error_code(error::invalid_attribute_value);
631  return;
632  }
633 
634  m_client_no_context_takeover = true;
635  }
636 
637  /// Negotiate server_max_window_bits attribute
638  /**
639  * When this method starts, m_server_max_window_bits will contain the server's
640  * preferred value and m_server_max_window_bits_mode will contain the mode the
641  * server wants to use to for negotiation. `value` contains the value the
642  * client requested that we use.
643  *
644  * options:
645  * - decline (refuse to use the attribute)
646  * - accept (use whatever the client says)
647  * - largest (use largest possible value)
648  * - smallest (use smallest possible value)
649  *
650  * @param [in] value The value of the attribute from the offer
651  * @param [out] ec A reference to the error code to return errors via
652  */
653  void negotiate_server_max_window_bits(std::string const & value,
654  lib::error_code & ec)
655  {
656  uint8_t bits = uint8_t(atoi(value.c_str()));
657 
659  ec = make_error_code(error::invalid_attribute_value);
660  m_server_max_window_bits = default_server_max_window_bits;
661  return;
662  }
663 
664  switch (m_server_max_window_bits_mode) {
665  case mode::decline:
666  m_server_max_window_bits = default_server_max_window_bits;
667  break;
668  case mode::accept:
669  m_server_max_window_bits = bits;
670  break;
671  case mode::largest:
672  m_server_max_window_bits = std::min(bits,m_server_max_window_bits);
673  break;
674  case mode::smallest:
675  m_server_max_window_bits = min_server_max_window_bits;
676  break;
677  default:
678  ec = make_error_code(error::invalid_mode);
679  m_server_max_window_bits = default_server_max_window_bits;
680  }
681  }
682 
683  /// Negotiate client_max_window_bits attribute
684  /**
685  * When this method starts, m_client_max_window_bits and m_c2s_max_window_mode
686  * will contain the server's preferred values for window size and
687  * negotiation mode.
688  *
689  * options:
690  * - decline (refuse to use the attribute)
691  * - accept (use whatever the client says)
692  * - largest (use largest possible value)
693  * - smallest (use smallest possible value)
694  *
695  * @param [in] value The value of the attribute from the offer
696  * @param [out] ec A reference to the error code to return errors via
697  */
698  void negotiate_client_max_window_bits(std::string const & value,
699  lib::error_code & ec)
700  {
701  uint8_t bits = uint8_t(atoi(value.c_str()));
702 
703  if (value.empty()) {
705  } else if (bits < min_client_max_window_bits ||
707  {
708  ec = make_error_code(error::invalid_attribute_value);
709  m_client_max_window_bits = default_client_max_window_bits;
710  return;
711  }
712 
713  switch (m_client_max_window_bits_mode) {
714  case mode::decline:
715  m_client_max_window_bits = default_client_max_window_bits;
716  break;
717  case mode::accept:
718  m_client_max_window_bits = bits;
719  break;
720  case mode::largest:
721  m_client_max_window_bits = std::min(bits,m_client_max_window_bits);
722  break;
723  case mode::smallest:
724  m_client_max_window_bits = min_client_max_window_bits;
725  break;
726  default:
727  ec = make_error_code(error::invalid_mode);
728  m_client_max_window_bits = default_client_max_window_bits;
729  }
730  }
731 
732  bool m_enabled;
733  bool m_server_no_context_takeover;
734  bool m_client_no_context_takeover;
735  uint8_t m_server_max_window_bits;
736  uint8_t m_client_max_window_bits;
737  mode::value m_server_max_window_bits_mode;
738  mode::value m_client_max_window_bits_mode;
739 
740  bool m_initialized;
741  int m_flush;
742  size_t m_compress_buffer_size;
743  lib::unique_ptr_uchar_array m_compress_buffer;
744  z_stream m_dstate;
745  z_stream m_istate;
746 };
747 
748 } // namespace permessage_deflate
749 } // namespace extensions
750 } // namespace websocketpp
751 
752 #endif // WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
lib::error_code set_server_max_window_bits(uint8_t bits, mode::value mode)
Limit server LZ77 sliding window size.
Definition: enabled.hpp:393
void enable_client_no_context_takeover()
Reset client's outgoing LZ77 sliding window for each new message.
Definition: enabled.hpp:367
static uint8_t const default_server_max_window_bits
Default value for server_max_window_bits as defined by draft 17.
Definition: enabled.hpp:178
lib::error_category const & get_category()
Get a reference to a static copy of the permessage-deflate error category.
Definition: enabled.hpp:151
lib::error_code init(bool is_server)
Initialize zlib state.
Definition: enabled.hpp:260
lib::error_code set_client_max_window_bits(uint8_t bits, mode::value mode)
Limit client LZ77 sliding window size.
Definition: enabled.hpp:424
lib::error_code validate_offer(http::attribute_list const &)
Validate extension response.
Definition: enabled.hpp:454
lib::error_code decompress(uint8_t const *buf, size_t len, std::string &out)
Decompress bytes.
Definition: enabled.hpp:544
lib::error_code make_error_code(error::value e)
Create an error code in the permessage-deflate category.
Definition: enabled.hpp:157
static uint8_t const min_client_max_window_bits
Minimum value for client_max_window_bits as defined by draft 17.
Definition: enabled.hpp:187
Implementation of the draft permessage-deflate WebSocket extension.
Definition: disabled.hpp:43
static uint8_t const max_server_max_window_bits
Maximum value for server_max_window_bits as defined by draft 17.
Definition: enabled.hpp:182
err_str_pair negotiate(http::attribute_list const &offer)
Negotiate extension.
Definition: enabled.hpp:467
void handle_accept(connection_ptr con, lib::error_code const &ec)
Handler callback for start_accept.
bool is_implemented() const
Test if this object implements the permessage-deflate specification.
Definition: enabled.hpp:312
bool is_enabled() const
Test if the extension was negotiated for this connection.
Definition: enabled.hpp:323
void enable_server_no_context_takeover()
Reset server's outgoing LZ77 sliding window for each new message.
Definition: enabled.hpp:348
static uint8_t const min_server_max_window_bits
Minimum value for server_max_window_bits as defined by draft 17.
Definition: enabled.hpp:180
lib::error_code compress(std::string const &in, std::string &out)
Compress bytes.
Definition: enabled.hpp:506
static uint8_t const max_client_max_window_bits
Maximum value for client_max_window_bits as defined by draft 17.
Definition: enabled.hpp:189
static uint8_t const default_client_max_window_bits
Default value for client_max_window_bits as defined by draft 17.
Definition: enabled.hpp:185
std::string generate_offer() const
Generate extension offer.
Definition: enabled.hpp:441