#include <enabled.hpp>

Public Member Functions
	enabled ()

	~enabled ()

lib::error_code	init (bool is_server)
	Initialize zlib state.

bool	is_implemented () const
	Test if this object implements the permessage-deflate specification.

bool	is_enabled () const
	Test if the extension was negotiated for this connection.

void	enable_server_no_context_takeover ()
	Reset server's outgoing LZ77 sliding window for each new message.

void	enable_client_no_context_takeover ()
	Reset client's outgoing LZ77 sliding window for each new message.

lib::error_code	set_server_max_window_bits (uint8_t bits, mode::value mode)
	Limit server LZ77 sliding window size.

lib::error_code	set_client_max_window_bits (uint8_t bits, mode::value mode)
	Limit client LZ77 sliding window size.

std::string	generate_offer () const
	Generate extension offer.

lib::error_code	validate_offer (http::attribute_list const &)
	Validate extension response.

err_str_pair	negotiate (http::attribute_list const &offer)
	Negotiate extension.

lib::error_code	compress (std::string const &in, std::string &out)
	Compress bytes.

lib::error_code	decompress (uint8_t const *buf, size_t len, std::string &out)
	Decompress bytes.

Detailed Description

template<typename config>
class websocketpp::extensions::permessage_deflate::enabled< config >

Definition at line 205 of file enabled.hpp.

Constructor & Destructor Documentation

◆ enabled()

template<typename config >

websocketpp::extensions::permessage_deflate::enabled< config >::enabled ( )

inline

Definition at line 207 of file enabled.hpp.

      : 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()

template<typename config >

websocketpp::extensions::permessage_deflate::enabled< config >::~enabled ( )

inline

Definition at line 229 of file enabled.hpp.

               {
        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;
        }
    }

Member Function Documentation

◆ compress()

template<typename config >

lib::error_code websocketpp::extensions::permessage_deflate::enabled< config >::compress	(	std::string const &	in,
		std::string &	out )

inline

Todo: : avail_in/out is 32 bit, need to fix for cases of >32 bit frames on 64 bit machines.

Parameters

[in]	in	String to compress
[out]	out	String to append compressed bytes to

Returns: Error or status code

Definition at line 506 of file enabled.hpp.

                                                                  {
        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();
    }

Here is the caller graph for this function:

◆ decompress()

template<typename config >

lib::error_code websocketpp::extensions::permessage_deflate::enabled< config >::decompress	(	uint8_t const *	buf,
		size_t	len,
		std::string &	out )

inline

Parameters

buf	Byte buffer to decompress
len	Length of buf
out	String to append decompressed bytes to

Returns: Error or status code

Definition at line 544 of file enabled.hpp.

    {
        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();
    }

Here is the caller graph for this function:

◆ enable_client_no_context_takeover()

template<typename config >

void websocketpp::extensions::permessage_deflate::enabled< config >::enable_client_no_context_takeover ( )

inline

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.

Definition at line 367 of file enabled.hpp.

                                             {
        m_client_no_context_takeover = true;
    }

Here is the caller graph for this function:

◆ enable_server_no_context_takeover()

template<typename config >

void websocketpp::extensions::permessage_deflate::enabled< config >::enable_server_no_context_takeover ( )

inline

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.

Definition at line 348 of file enabled.hpp.

                                             {
        m_server_no_context_takeover = true;
    }

Here is the caller graph for this function:

◆ generate_offer()

template<typename config >

std::string websocketpp::extensions::permessage_deflate::enabled< config >::generate_offer ( ) const

inline

Creates an offer string to include in the Sec-WebSocket-Extensions header of outgoing client requests.

Returns: A WebSocket extension offer string for this extension

Definition at line 441 of file enabled.hpp.

                                     {
        // TODO: this should be dynamically generated based on user settings
        return "permessage-deflate; client_no_context_takeover; client_max_window_bits";
    }

◆ init()

template<typename config >

lib::error_code websocketpp::extensions::permessage_deflate::enabled< config >::init ( bool is_server )

inline

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

Parameters

is_server True to initialize as a server, false for a client.

Returns: A code representing the error that occurred, if any

Definition at line 260 of file enabled.hpp.

                                       {
        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();
    }

Here is the caller graph for this function:

◆ is_enabled()

template<typename config >

bool websocketpp::extensions::permessage_deflate::enabled< config >::is_enabled ( ) const

inline

Retrieves whether or not this extension is in use based on the initial handshake extension negotiations.

Returns: Whether or not the extension is in use

Definition at line 323 of file enabled.hpp.

                            {
        return m_enabled;
    }

Here is the caller graph for this function:

◆ is_implemented()

template<typename config >

bool websocketpp::extensions::permessage_deflate::enabled< config >::is_implemented ( ) const

inline

Because this object does implieent it, it will always return true.

Returns: Whether or not this object implements permessage-deflate

Definition at line 312 of file enabled.hpp.

                                {
        return true;
    }

Here is the caller graph for this function:

◆ negotiate()

template<typename config >

err_str_pair websocketpp::extensions::permessage_deflate::enabled< config >::negotiate ( http::attribute_list const & offer )

inline

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.

Parameters

offer Attribute from client's offer

Returns: Status code and value to return to remote endpoint

Definition at line 467 of file enabled.hpp.

                                                             {
        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;
    }

Here is the caller graph for this function:

◆ set_client_max_window_bits()

template<typename config >

lib::error_code websocketpp::extensions::permessage_deflate::enabled< config >::set_client_max_window_bits	(	uint8_t	bits,
		mode::value	mode )

inline

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.

Parameters

bits	The size to request for the outgoing window size
mode	The mode to use for negotiating this parameter

Returns: A status code

Definition at line 424 of file enabled.hpp.

                                                                           {
        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();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_server_max_window_bits()

template<typename config >

lib::error_code websocketpp::extensions::permessage_deflate::enabled< config >::set_server_max_window_bits	(	uint8_t	bits,
		mode::value	mode )

inline

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.

Parameters

bits	The size to request for the outgoing window size
mode	The mode to use for negotiating this parameter

Returns: A status code

Definition at line 393 of file enabled.hpp.

                                                                           {
        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();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ validate_offer()

template<typename config >

lib::error_code websocketpp::extensions::permessage_deflate::enabled< config >::validate_offer ( http::attribute_list const & )

inline

Confirm that the server has negotiated settings compatible with our original offer and apply those settings to the extension state.

Parameters

response The server response attribute list to validate

Returns: Validation error or 0 on success

Definition at line 454 of file enabled.hpp.

                                                             {
        return lib::error_code();
    }

The documentation for this class was generated from the following file:

libraries/fc/vendor/websocketpp/websocketpp/extensions/permessage_deflate/enabled.hpp

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ enabled()

◆ ~enabled()

Member Function Documentation

◆ compress()

◆ decompress()

◆ enable_client_no_context_takeover()

◆ enable_server_no_context_takeover()

◆ generate_offer()

◆ init()

◆ is_enabled()

◆ is_implemented()

◆ negotiate()

◆ set_client_max_window_bits()

◆ set_server_max_window_bits()

◆ validate_offer()