enabled.hpp

Go to the documentation of this file.

/*
 * 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 {
 
 
namespace permessage_deflate {
 
namespace error {
enum value {
    general = 1,
 
    invalid_attributes,
 
    invalid_attribute_value,
 
    invalid_mode,
 
    unsupported_attributes,
 
    invalid_max_window_bits,
 
    zlib_error,
 
    uninitialized,
};
 
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";
        }
    }
};
 
inline lib::error_category const & get_category() {
    static category instance;
    return instance;
}
 
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 {
 
static uint8_t const default_server_max_window_bits = 15;
static uint8_t const min_server_max_window_bits = 8;
static uint8_t const max_server_max_window_bits = 15;
 
static uint8_t const default_client_max_window_bits = 15;
static uint8_t const min_client_max_window_bits = 8;
static uint8_t const max_client_max_window_bits = 15;
 
namespace mode {
enum value {
    accept = 1,
    decline,
    largest,
    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;
        }
    }
 
 
    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();
    }
 
 
    bool is_implemented() const {
        return true;
    }
 
 
    bool is_enabled() const {
        return m_enabled;
    }
 
 
    void enable_server_no_context_takeover() {
        m_server_no_context_takeover = true;
    }
 
 
    void enable_client_no_context_takeover() {
        m_client_no_context_takeover = true;
    }
 
 
    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();
    }
 
 
    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();
    }
 
 
    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";
    }
 
 
    lib::error_code validate_offer(http::attribute_list const &) {
        return lib::error_code();
    }
 
 
    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;
    }
 
 
    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();
    }
 
 
    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:
 
    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;
    }
 
 
    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;
    }
 
 
    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;
    }
 
 
    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;
        }
    }
 
 
    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