--- /dev/null
+/*
+ * Copyright (c) 2015, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of the WebSocket++ Project nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
+#define WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
+
+
+#include <websocketpp/common/cpp11.hpp>
+#include <websocketpp/common/memory.hpp>
+#include <websocketpp/common/platforms.hpp>
+#include <websocketpp/common/system_error.hpp>
+#include <websocketpp/error.hpp>
+
+#include <websocketpp/extensions/extension.hpp>
+
+#include "zlib.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace websocketpp {
+namespace extensions {
+
+/// Implementation of the draft permessage-deflate WebSocket extension
+/**
+ * ### permessage-deflate interface
+ *
+ * **init**\n
+ * `lib::error_code init(bool is_server)`\n
+ * Performs initialization
+ *
+ * **is_implimented**\n
+ * `bool is_implimented()`\n
+ * Returns whether or not the object impliments the extension or not
+ *
+ * **is_enabled**\n
+ * `bool is_enabled()`\n
+ * Returns whether or not the extension was negotiated for the current
+ * connection
+ *
+ * **generate_offer**\n
+ * `std::string generate_offer() const`\n
+ * Create an extension offer string based on local policy
+ *
+ * **validate_response**\n
+ * `lib::error_code validate_response(http::attribute_list const & response)`\n
+ * Negotiate the parameters of extension use
+ *
+ * **negotiate**\n
+ * `err_str_pair negotiate(http::attribute_list const & attributes)`\n
+ * Negotiate the parameters of extension use
+ *
+ * **compress**\n
+ * `lib::error_code compress(std::string const & in, std::string & out)`\n
+ * Compress the bytes in `in` and append them to `out`
+ *
+ * **decompress**\n
+ * `lib::error_code decompress(uint8_t const * buf, size_t len, std::string &
+ * out)`\n
+ * Decompress `len` bytes from `buf` and append them to string `out`
+ */
+namespace permessage_deflate {
+
+/// Permessage deflate error values
+namespace error {
+enum value {
+ /// Catch all
+ general = 1,
+
+ /// Invalid extension attributes
+ invalid_attributes,
+
+ /// Invalid extension attribute value
+ invalid_attribute_value,
+
+ /// Invalid megotiation mode
+ invalid_mode,
+
+ /// Unsupported extension attributes
+ unsupported_attributes,
+
+ /// Invalid value for max_window_bits
+ invalid_max_window_bits,
+
+ /// ZLib Error
+ zlib_error,
+
+ /// Uninitialized
+ uninitialized,
+};
+
+/// Permessage-deflate error category
+class category : public lib::error_category {
+public:
+ category() {}
+
+ char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
+ return "websocketpp.extension.permessage-deflate";
+ }
+
+ std::string message(int value) const {
+ switch(value) {
+ case general:
+ return "Generic permessage-compress error";
+ case invalid_attributes:
+ return "Invalid extension attributes";
+ case invalid_attribute_value:
+ return "Invalid extension attribute value";
+ case invalid_mode:
+ return "Invalid permessage-deflate negotiation mode";
+ case unsupported_attributes:
+ return "Unsupported extension attributes";
+ case invalid_max_window_bits:
+ return "Invalid value for max_window_bits";
+ case zlib_error:
+ return "A zlib function returned an error";
+ case uninitialized:
+ return "Deflate extension must be initialized before use";
+ default:
+ return "Unknown permessage-compress error";
+ }
+ }
+};
+
+/// Get a reference to a static copy of the permessage-deflate error category
+inline lib::error_category const & get_category() {
+ static category instance;
+ return instance;
+}
+
+/// Create an error code in the permessage-deflate category
+inline lib::error_code make_error_code(error::value e) {
+ return lib::error_code(static_cast<int>(e), get_category());
+}
+
+} // namespace error
+} // namespace permessage_deflate
+} // namespace extensions
+} // namespace websocketpp
+
+_WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
+template<> struct is_error_code_enum
+ <websocketpp::extensions::permessage_deflate::error::value>
+{
+ static bool const value = true;
+};
+_WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
+namespace websocketpp {
+namespace extensions {
+namespace permessage_deflate {
+
+/// Default value for server_max_window_bits as defined by draft 17
+static uint8_t const default_server_max_window_bits = 15;
+/// Minimum value for server_max_window_bits as defined by draft 17
+static uint8_t const min_server_max_window_bits = 8;
+/// Maximum value for server_max_window_bits as defined by draft 17
+static uint8_t const max_server_max_window_bits = 15;
+
+/// Default value for client_max_window_bits as defined by draft 17
+static uint8_t const default_client_max_window_bits = 15;
+/// Minimum value for client_max_window_bits as defined by draft 17
+static uint8_t const min_client_max_window_bits = 8;
+/// Maximum value for client_max_window_bits as defined by draft 17
+static uint8_t const max_client_max_window_bits = 15;
+
+namespace mode {
+enum value {
+ /// Accept any value the remote endpoint offers
+ accept = 1,
+ /// Decline any value the remote endpoint offers. Insist on defaults.
+ decline,
+ /// Use the largest value common to both offers
+ largest,
+ /// Use the smallest value common to both offers
+ smallest
+};
+} // namespace mode
+
+template <typename config>
+class enabled {
+public:
+ enabled()
+ : m_enabled(false)
+ , m_server_no_context_takeover(false)
+ , m_client_no_context_takeover(false)
+ , m_server_max_window_bits(15)
+ , m_client_max_window_bits(15)
+ , m_server_max_window_bits_mode(mode::accept)
+ , m_client_max_window_bits_mode(mode::accept)
+ , m_initialized(false)
+ , m_compress_buffer_size(16384)
+ {
+ m_dstate.zalloc = Z_NULL;
+ m_dstate.zfree = Z_NULL;
+ m_dstate.opaque = Z_NULL;
+
+ m_istate.zalloc = Z_NULL;
+ m_istate.zfree = Z_NULL;
+ m_istate.opaque = Z_NULL;
+ m_istate.avail_in = 0;
+ m_istate.next_in = Z_NULL;
+ }
+
+ ~enabled() {
+ if (!m_initialized) {
+ return;
+ }
+
+ int ret = deflateEnd(&m_dstate);
+
+ if (ret != Z_OK) {
+ //std::cout << "error cleaning up zlib compression state"
+ // << std::endl;
+ }
+
+ ret = inflateEnd(&m_istate);
+
+ if (ret != Z_OK) {
+ //std::cout << "error cleaning up zlib decompression state"
+ // << std::endl;
+ }
+ }
+
+ /// Initialize zlib state
+ /**
+ * Note: this should be called *after* the negotiation methods. It will use
+ * information from the negotiation to determine how to initialize the zlib
+ * data structures.
+ *
+ * @todo memory level, strategy, etc are hardcoded
+ *
+ * @param is_server True to initialize as a server, false for a client.
+ * @return A code representing the error that occurred, if any
+ */
+ lib::error_code init(bool is_server) {
+ uint8_t deflate_bits;
+ uint8_t inflate_bits;
+
+ if (is_server) {
+ deflate_bits = m_server_max_window_bits;
+ inflate_bits = m_client_max_window_bits;
+ } else {
+ deflate_bits = m_client_max_window_bits;
+ inflate_bits = m_server_max_window_bits;
+ }
+
+ int ret = deflateInit2(
+ &m_dstate,
+ Z_DEFAULT_COMPRESSION,
+ Z_DEFLATED,
+ -1*deflate_bits,
+ 4, // memory level 1-9
+ Z_DEFAULT_STRATEGY
+ );
+
+ if (ret != Z_OK) {
+ return make_error_code(error::zlib_error);
+ }
+
+ ret = inflateInit2(
+ &m_istate,
+ -1*inflate_bits
+ );
+
+ if (ret != Z_OK) {
+ return make_error_code(error::zlib_error);
+ }
+
+ m_compress_buffer.reset(new unsigned char[m_compress_buffer_size]);
+ if ((m_server_no_context_takeover && is_server) ||
+ (m_client_no_context_takeover && !is_server))
+ {
+ m_flush = Z_FULL_FLUSH;
+ } else {
+ m_flush = Z_SYNC_FLUSH;
+ }
+ m_initialized = true;
+ return lib::error_code();
+ }
+
+ /// Test if this object implements the permessage-deflate specification
+ /**
+ * Because this object does implieent it, it will always return true.
+ *
+ * @return Whether or not this object implements permessage-deflate
+ */
+ bool is_implemented() const {
+ return true;
+ }
+
+ /// Test if the extension was negotiated for this connection
+ /**
+ * Retrieves whether or not this extension is in use based on the initial
+ * handshake extension negotiations.
+ *
+ * @return Whether or not the extension is in use
+ */
+ bool is_enabled() const {
+ return m_enabled;
+ }
+
+ /// Reset server's outgoing LZ77 sliding window for each new message
+ /**
+ * Enabling this setting will cause the server's compressor to reset the
+ * compression state (the LZ77 sliding window) for every message. This
+ * means that the compressor will not look back to patterns in previous
+ * messages to improve compression. This will reduce the compression
+ * efficiency for large messages somewhat and small messages drastically.
+ *
+ * This option may reduce server compressor memory usage and client
+ * decompressor memory usage.
+ * @todo Document to what extent memory usage will be reduced
+ *
+ * For clients, this option is dependent on server support. Enabling it
+ * via this method does not guarantee that it will be successfully
+ * negotiated, only that it will be requested.
+ *
+ * For servers, no client support is required. Enabling this option on a
+ * server will result in its use. The server will signal to clients that
+ * the option will be in use so they can optimize resource usage if they
+ * are able.
+ */
+ void enable_server_no_context_takeover() {
+ m_server_no_context_takeover = true;
+ }
+
+ /// Reset client's outgoing LZ77 sliding window for each new message
+ /**
+ * Enabling this setting will cause the client's compressor to reset the
+ * compression state (the LZ77 sliding window) for every message. This
+ * means that the compressor will not look back to patterns in previous
+ * messages to improve compression. This will reduce the compression
+ * efficiency for large messages somewhat and small messages drastically.
+ *
+ * This option may reduce client compressor memory usage and server
+ * decompressor memory usage.
+ * @todo Document to what extent memory usage will be reduced
+ *
+ * This option is supported by all compliant clients and servers. Enabling
+ * it via either endpoint should be sufficient to ensure it is used.
+ */
+ void enable_client_no_context_takeover() {
+ m_client_no_context_takeover = true;
+ }
+
+ /// Limit server LZ77 sliding window size
+ /**
+ * The bits setting is the base 2 logarithm of the maximum window size that
+ * the server must use to compress outgoing messages. The permitted range
+ * is 8 to 15 inclusive. 8 represents a 256 byte window and 15 a 32KiB
+ * window. The default setting is 15.
+ *
+ * Mode Options:
+ * - accept: Accept whatever the remote endpoint offers.
+ * - decline: Decline any offers to deviate from the defaults
+ * - largest: Accept largest window size acceptable to both endpoints
+ * - smallest: Accept smallest window size acceptiable to both endpoints
+ *
+ * This setting is dependent on server support. A client requesting this
+ * setting may be rejected by the server or have the exact value used
+ * adjusted by the server. A server may unilaterally set this value without
+ * client support.
+ *
+ * @param bits The size to request for the outgoing window size
+ * @param mode The mode to use for negotiating this parameter
+ * @return A status code
+ */
+ lib::error_code set_server_max_window_bits(uint8_t bits, mode::value mode) {
+ if (bits < min_server_max_window_bits || bits > max_server_max_window_bits) {
+ return error::make_error_code(error::invalid_max_window_bits);
+ }
+ m_server_max_window_bits = bits;
+ m_server_max_window_bits_mode = mode;
+
+ return lib::error_code();
+ }
+
+ /// Limit client LZ77 sliding window size
+ /**
+ * The bits setting is the base 2 logarithm of the window size that the
+ * client must use to compress outgoing messages. The permitted range is 8
+ * to 15 inclusive. 8 represents a 256 byte window and 15 a 32KiB window.
+ * The default setting is 15.
+ *
+ * Mode Options:
+ * - accept: Accept whatever the remote endpoint offers.
+ * - decline: Decline any offers to deviate from the defaults
+ * - largest: Accept largest window size acceptable to both endpoints
+ * - smallest: Accept smallest window size acceptiable to both endpoints
+ *
+ * This setting is dependent on client support. A client may limit its own
+ * outgoing window size unilaterally. A server may only limit the client's
+ * window size if the remote client supports that feature.
+ *
+ * @param bits The size to request for the outgoing window size
+ * @param mode The mode to use for negotiating this parameter
+ * @return A status code
+ */
+ lib::error_code set_client_max_window_bits(uint8_t bits, mode::value mode) {
+ if (bits < min_client_max_window_bits || bits > max_client_max_window_bits) {
+ return error::make_error_code(error::invalid_max_window_bits);
+ }
+ m_client_max_window_bits = bits;
+ m_client_max_window_bits_mode = mode;
+
+ return lib::error_code();
+ }
+
+ /// Generate extension offer
+ /**
+ * Creates an offer string to include in the Sec-WebSocket-Extensions
+ * header of outgoing client requests.
+ *
+ * @return A WebSocket extension offer string for this extension
+ */
+ std::string generate_offer() const {
+ // TODO: this should be dynamically generated based on user settings
+ return "permessage-deflate; client_no_context_takeover; client_max_window_bits";
+ }
+
+ /// Validate extension response
+ /**
+ * Confirm that the server has negotiated settings compatible with our
+ * original offer and apply those settings to the extension state.
+ *
+ * @param response The server response attribute list to validate
+ * @return Validation error or 0 on success
+ */
+ lib::error_code validate_offer(http::attribute_list const &) {
+ return lib::error_code();
+ }
+
+ /// Negotiate extension
+ /**
+ * Confirm that the client's extension negotiation offer has settings
+ * compatible with local policy. If so, generate a reply and apply those
+ * settings to the extension state.
+ *
+ * @param offer Attribute from client's offer
+ * @return Status code and value to return to remote endpoint
+ */
+ err_str_pair negotiate(http::attribute_list const & offer) {
+ err_str_pair ret;
+
+ http::attribute_list::const_iterator it;
+ for (it = offer.begin(); it != offer.end(); ++it) {
+ if (it->first == "server_no_context_takeover") {
+ negotiate_server_no_context_takeover(it->second,ret.first);
+ } else if (it->first == "client_no_context_takeover") {
+ negotiate_client_no_context_takeover(it->second,ret.first);
+ } else if (it->first == "server_max_window_bits") {
+ negotiate_server_max_window_bits(it->second,ret.first);
+ } else if (it->first == "client_max_window_bits") {
+ negotiate_client_max_window_bits(it->second,ret.first);
+ } else {
+ ret.first = make_error_code(error::invalid_attributes);
+ }
+
+ if (ret.first) {
+ break;
+ }
+ }
+
+ if (ret.first == lib::error_code()) {
+ m_enabled = true;
+ ret.second = generate_response();
+ }
+
+ return ret;
+ }
+
+ /// Compress bytes
+ /**
+ * @todo: avail_in/out is 32 bit, need to fix for cases of >32 bit frames
+ * on 64 bit machines.
+ *
+ * @param [in] in String to compress
+ * @param [out] out String to append compressed bytes to
+ * @return Error or status code
+ */
+ lib::error_code compress(std::string const & in, std::string & out) {
+ if (!m_initialized) {
+ return make_error_code(error::uninitialized);
+ }
+
+ size_t output;
+
+ if (in.empty()) {
+ uint8_t buf[6] = {0x02, 0x00, 0x00, 0x00, 0xff, 0xff};
+ out.append((char *)(buf),6);
+ return lib::error_code();
+ }
+
+ m_dstate.avail_in = in.size();
+ m_dstate.next_in = (unsigned char *)(const_cast<char *>(in.data()));
+
+ do {
+ // Output to local buffer
+ m_dstate.avail_out = m_compress_buffer_size;
+ m_dstate.next_out = m_compress_buffer.get();
+
+ deflate(&m_dstate, m_flush);
+
+ output = m_compress_buffer_size - m_dstate.avail_out;
+
+ out.append((char *)(m_compress_buffer.get()),output);
+ } while (m_dstate.avail_out == 0);
+
+ return lib::error_code();
+ }
+
+ /// Decompress bytes
+ /**
+ * @param buf Byte buffer to decompress
+ * @param len Length of buf
+ * @param out String to append decompressed bytes to
+ * @return Error or status code
+ */
+ lib::error_code decompress(uint8_t const * buf, size_t len, std::string &
+ out)
+ {
+ if (!m_initialized) {
+ return make_error_code(error::uninitialized);
+ }
+
+ int ret;
+
+ m_istate.avail_in = len;
+ m_istate.next_in = const_cast<unsigned char *>(buf);
+
+ do {
+ m_istate.avail_out = m_compress_buffer_size;
+ m_istate.next_out = m_compress_buffer.get();
+
+ ret = inflate(&m_istate, Z_SYNC_FLUSH);
+
+ if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
+ return make_error_code(error::zlib_error);
+ }
+
+ out.append(
+ reinterpret_cast<char *>(m_compress_buffer.get()),
+ m_compress_buffer_size - m_istate.avail_out
+ );
+ } while (m_istate.avail_out == 0);
+
+ return lib::error_code();
+ }
+private:
+ /// Generate negotiation response
+ /**
+ * @return Generate extension negotiation reponse string to send to client
+ */
+ std::string generate_response() {
+ std::string ret = "permessage-deflate";
+
+ if (m_server_no_context_takeover) {
+ ret += "; server_no_context_takeover";
+ }
+
+ if (m_client_no_context_takeover) {
+ ret += "; client_no_context_takeover";
+ }
+
+ if (m_server_max_window_bits < default_server_max_window_bits) {
+ std::stringstream s;
+ s << int(m_server_max_window_bits);
+ ret += "; server_max_window_bits="+s.str();
+ }
+
+ if (m_client_max_window_bits < default_client_max_window_bits) {
+ std::stringstream s;
+ s << int(m_client_max_window_bits);
+ ret += "; client_max_window_bits="+s.str();
+ }
+
+ return ret;
+ }
+
+ /// Negotiate server_no_context_takeover attribute
+ /**
+ * @param [in] value The value of the attribute from the offer
+ * @param [out] ec A reference to the error code to return errors via
+ */
+ void negotiate_server_no_context_takeover(std::string const & value,
+ lib::error_code & ec)
+ {
+ if (!value.empty()) {
+ ec = make_error_code(error::invalid_attribute_value);
+ return;
+ }
+
+ m_server_no_context_takeover = true;
+ }
+
+ /// Negotiate client_no_context_takeover attribute
+ /**
+ * @param [in] value The value of the attribute from the offer
+ * @param [out] ec A reference to the error code to return errors via
+ */
+ void negotiate_client_no_context_takeover(std::string const & value,
+ lib::error_code & ec)
+ {
+ if (!value.empty()) {
+ ec = make_error_code(error::invalid_attribute_value);
+ return;
+ }
+
+ m_client_no_context_takeover = true;
+ }
+
+ /// Negotiate server_max_window_bits attribute
+ /**
+ * When this method starts, m_server_max_window_bits will contain the server's
+ * preferred value and m_server_max_window_bits_mode will contain the mode the
+ * server wants to use to for negotiation. `value` contains the value the
+ * client requested that we use.
+ *
+ * options:
+ * - decline (refuse to use the attribute)
+ * - accept (use whatever the client says)
+ * - largest (use largest possible value)
+ * - smallest (use smallest possible value)
+ *
+ * @param [in] value The value of the attribute from the offer
+ * @param [out] ec A reference to the error code to return errors via
+ */
+ void negotiate_server_max_window_bits(std::string const & value,
+ lib::error_code & ec)
+ {
+ uint8_t bits = uint8_t(atoi(value.c_str()));
+
+ if (bits < min_server_max_window_bits || bits > max_server_max_window_bits) {
+ ec = make_error_code(error::invalid_attribute_value);
+ m_server_max_window_bits = default_server_max_window_bits;
+ return;
+ }
+
+ switch (m_server_max_window_bits_mode) {
+ case mode::decline:
+ m_server_max_window_bits = default_server_max_window_bits;
+ break;
+ case mode::accept:
+ m_server_max_window_bits = bits;
+ break;
+ case mode::largest:
+ m_server_max_window_bits = std::min(bits,m_server_max_window_bits);
+ break;
+ case mode::smallest:
+ m_server_max_window_bits = min_server_max_window_bits;
+ break;
+ default:
+ ec = make_error_code(error::invalid_mode);
+ m_server_max_window_bits = default_server_max_window_bits;
+ }
+ }
+
+ /// Negotiate client_max_window_bits attribute
+ /**
+ * When this method starts, m_client_max_window_bits and m_c2s_max_window_mode
+ * will contain the server's preferred values for window size and
+ * negotiation mode.
+ *
+ * options:
+ * - decline (refuse to use the attribute)
+ * - accept (use whatever the client says)
+ * - largest (use largest possible value)
+ * - smallest (use smallest possible value)
+ *
+ * @param [in] value The value of the attribute from the offer
+ * @param [out] ec A reference to the error code to return errors via
+ */
+ void negotiate_client_max_window_bits(std::string const & value,
+ lib::error_code & ec)
+ {
+ uint8_t bits = uint8_t(atoi(value.c_str()));
+
+ if (value.empty()) {
+ bits = default_client_max_window_bits;
+ } else if (bits < min_client_max_window_bits ||
+ bits > max_client_max_window_bits)
+ {
+ ec = make_error_code(error::invalid_attribute_value);
+ m_client_max_window_bits = default_client_max_window_bits;
+ return;
+ }
+
+ switch (m_client_max_window_bits_mode) {
+ case mode::decline:
+ m_client_max_window_bits = default_client_max_window_bits;
+ break;
+ case mode::accept:
+ m_client_max_window_bits = bits;
+ break;
+ case mode::largest:
+ m_client_max_window_bits = std::min(bits,m_client_max_window_bits);
+ break;
+ case mode::smallest:
+ m_client_max_window_bits = min_client_max_window_bits;
+ break;
+ default:
+ ec = make_error_code(error::invalid_mode);
+ m_client_max_window_bits = default_client_max_window_bits;
+ }
+ }
+
+ bool m_enabled;
+ bool m_server_no_context_takeover;
+ bool m_client_no_context_takeover;
+ uint8_t m_server_max_window_bits;
+ uint8_t m_client_max_window_bits;
+ mode::value m_server_max_window_bits_mode;
+ mode::value m_client_max_window_bits_mode;
+
+ bool m_initialized;
+ int m_flush;
+ size_t m_compress_buffer_size;
+ lib::unique_ptr_uchar_array m_compress_buffer;
+ z_stream m_dstate;
+ z_stream m_istate;
+};
+
+} // namespace permessage_deflate
+} // namespace extensions
+} // namespace websocketpp
+
+#endif // WEBSOCKETPP_PROCESSOR_EXTENSION_PERMESSAGEDEFLATE_HPP
projects / c11concurrency-benchmarks.git / blobdiff