zlib.hpp

Go to the documentation of this file.

/*
    restinio
*/

 
#pragma once
 
#include <restinio/impl/include_fmtlib.hpp>
 
#include <restinio/impl/string_caseless_compare.hpp>
 
#include <restinio/exception.hpp>
#include <restinio/string_view.hpp>
#include <restinio/message_builders.hpp>
#include <restinio/request_handler.hpp>
 
#include <zlib.h>
 
#include <string>
#include <cstring>
 
namespace restinio
{
 
namespace transforms
{
 
namespace zlib
{

constexpr std::size_t default_output_reserve_buffer_size = 256 * 1024;

constexpr int default_window_bits = MAX_WBITS;
constexpr int default_mem_level = MAX_MEM_LEVEL;
constexpr int default_strategy = Z_DEFAULT_STRATEGY;
 
//
// params_t
//

/*
    @since v.0.4.4
 
    \note There is a special case for compression format: format_t::identity.
    If this format is set that zlib transformator is transparently copies
    input to output and so all other params are ignored.
*/
class params_t
{
    public:
        enum class operation_t
        {
            compress,
            decompress
        };

        enum class format_t
        {
            deflate,
            gzip,
            /*
                Means that no compression will be used and no header/trailer will be applied.
            */
            identity
        };


        params_t(
            operation_t op,
            format_t f,
            int l = -1 )
            :   m_operation{ op }
            ,   m_format{ f }
        {
            level( l );
        }

        params_t()
            :   m_operation{ operation_t::compress }
            ,   m_format{ format_t::identity }
        {
            level( -1 );
        }

        operation_t operation() const { return m_operation; }

        format_t format() const { return m_format; }


        int level() const { return m_level; }


        params_t &
        level( int level_value ) &
        {
            if( level_value < -1 || level_value > 9 )
            {
                throw exception_t{
                    fmt::format(
                        RESTINIO_FMT_FORMAT_STRING(
                            "invalid compression level: {}, must be "
                            "an integer value in the range of -1 to 9" ),
                        level_value ) };
            }
 
            m_level = level_value;
 
            return reference_to_self();
        }

        params_t &&
        level( int level_value ) &&
        {
            return std::move( this->level( level_value ) );
        }

        int window_bits() const { return m_window_bits; }


        params_t &
        window_bits( int window_bits_value ) &
        {
            // From https://zlib.net/manual.html:
            // For the current implementation of deflate(),
            // a windowBits value of 8 (a window size of 256 bytes)
            // is not supported. As a result, a request for 8 will result in 9
            // (a 512-byte window). In that case, providing 8 to inflateInit2()
            // will result in an error when the zlib header with 9 is
            // checked against the initialization of inflate().
            // The remedy is to not use 8 with deflateInit2()
            // with this initialization, or at least in that case use 9
            // with inflateInit2().
            // ...
            // windowBits can also be zero to request that inflate
            // use the window size in the zlib header of the compressed
            // stream.
 
            if( ( window_bits_value < 8 || window_bits_value > MAX_WBITS ) &&
                ( 0 != window_bits_value || operation_t::decompress != operation() ) )
            {
                throw exception_t{
                    fmt::format(
                        RESTINIO_FMT_FORMAT_STRING(
                            "invalid window_bits: {}, must be "
                            "an integer value in the range of 8 to {} or "
                            "0 for decompress operation" ),
                        window_bits_value,
                        MAX_WBITS ) };
            }
 
            if( 8 == window_bits_value )
                window_bits_value = 9;
 
            m_window_bits = window_bits_value;
 
            return reference_to_self();
        }

        params_t &&
        window_bits( int window_bits_value ) &&
        {
            return std::move( this->window_bits( window_bits_value ) );
        }


        int mem_level() const { return m_mem_level; }


        params_t &
        mem_level( int mem_level_value ) &
        {
            if( mem_level_value < 1 || mem_level_value > MAX_MEM_LEVEL )
            {
                throw exception_t{
                    fmt::format(
                        RESTINIO_FMT_FORMAT_STRING(
                            "invalid compression mem_level: {}, must be "
                            "an integer value in the range of 1 to {}" ),
                        mem_level_value,
                        MAX_MEM_LEVEL ) };
            }
 
            m_mem_level = mem_level_value;
 
            return reference_to_self();
        }

        params_t &&
        mem_level( int mem_level_value ) &&
        {
            return std::move( this->mem_level( mem_level_value ) );
        }


        int strategy() const { return m_strategy; }


        params_t &
        strategy( int strategy_value ) &
        {
            if( Z_DEFAULT_STRATEGY != strategy_value &&
                Z_FILTERED != strategy_value &&
                Z_HUFFMAN_ONLY != strategy_value &&
                Z_RLE != strategy_value )
            {
                throw exception_t{
                    fmt::format(
                        RESTINIO_FMT_FORMAT_STRING(
                            "invalid compression strategy: {}, must be "
                            "one of: "
                            "Z_DEFAULT_STRATEGY({}), "
                            "Z_FILTERED({}), "
                            "Z_HUFFMAN_ONLY({}), "
                            "Z_RLE({})" ),
                        strategy_value,
                        Z_DEFAULT_STRATEGY,
                        Z_FILTERED,
                        Z_HUFFMAN_ONLY,
                        Z_RLE ) };
            }
 
            m_strategy = strategy_value;
 
            return reference_to_self();
        }

        params_t &&
        strategy( int strategy_value ) &&
        {
            return std::move( this->strategy( strategy_value ) );
        }


        std::size_t reserve_buffer_size() const { return m_reserve_buffer_size; }

        params_t &
        reserve_buffer_size( std::size_t size ) &
        {
            if( size < 10UL )
            {
                throw exception_t{ "too small reserve buffer size" };
            }
 
            m_reserve_buffer_size = size;
 
            return reference_to_self();
        }

        params_t &&
        reserve_buffer_size( std::size_t size ) &&
        {
            return std::move( this->reserve_buffer_size( size ) );
        }
 
    private:
        params_t & reference_to_self() { return *this; }

        operation_t m_operation;

        format_t m_format;


        int m_level;
 
        int m_window_bits{ default_window_bits };
        int m_mem_level{ default_mem_level };
        int m_strategy{ default_strategy };

        std::size_t m_reserve_buffer_size{ default_output_reserve_buffer_size };
};

inline params_t
make_deflate_compress_params( int compression_level = -1 )
{
    return params_t{
            params_t::operation_t::compress,
            params_t::format_t::deflate,
            compression_level };
}
 
inline params_t
make_deflate_decompress_params()
{
    return params_t{
            params_t::operation_t::decompress,
            params_t::format_t::deflate };
}
 
inline params_t
make_gzip_compress_params( int compression_level = -1 )
{
    return params_t{
            params_t::operation_t::compress,
            params_t::format_t::gzip,
            compression_level };
}
 
inline params_t
make_gzip_decompress_params()
{
    return params_t{
            params_t::operation_t::decompress,
            params_t::format_t::gzip };
}
 
inline params_t
make_identity_params()
{
    return params_t{};
}

 
//
// zlib_t
//


class zlib_t
{
    public:
        zlib_t( const params_t & transformation_params )
            :   m_params{ transformation_params }
        {
            if( !is_identity() )
            {
                // Setting allocator stuff before initializing
                // TODO: allocation can be done with user defined allocator.
                m_zlib_stream.zalloc = Z_NULL;
                m_zlib_stream.zfree = Z_NULL;
                m_zlib_stream.opaque = Z_NULL;
 
                // Track initialization result.
                int init_result;
 
                // Compression.
                auto current_window_bits = m_params.window_bits();
 
                if( params_t::format_t::gzip == m_params.format() )
                {
                    current_window_bits += 16;
                }
 
                if( params_t::operation_t::compress == m_params.operation() )
                {
                    // zlib format.
                    init_result =
                        deflateInit2(
                            &m_zlib_stream,
                            m_params.level(),
                            Z_DEFLATED,
                            current_window_bits,
                            m_params.mem_level(),
                            m_params.strategy() );
                }
                else
                {
                    init_result =
                        inflateInit2(
                            &m_zlib_stream,
                            current_window_bits );
                }
 
                if( Z_OK != init_result )
                {
                    throw exception_t{
                        fmt::format(
                            RESTINIO_FMT_FORMAT_STRING(
                                "Failed to initialize zlib stream: {}, {}" ),
                            init_result,
                            get_error_msg() ) };
                }
 
                m_zlib_stream_initialized = true;
 
                // Reserve initial buffer.
                inc_buffer();
            }
            // else => Nothing to initialize and to reserve.
        }
 
        zlib_t( const zlib_t & ) = delete;
        zlib_t( zlib_t && ) = delete;
        zlib_t & operator = ( const zlib_t & ) = delete;
        zlib_t & operator = ( zlib_t && ) = delete;
 
        ~zlib_t()
        {
            if( m_zlib_stream_initialized )
            {
                if( params_t::operation_t::compress == m_params.operation() )
                {
                    deflateEnd( &m_zlib_stream );
                }
                else
                {
                    inflateEnd( &m_zlib_stream );
                }
            }
        }

        const params_t & params() const { return m_params; }


        void
        write( string_view_t input )
        {
            ensure_operation_in_not_completed();
 
            if( is_identity() )
            {
                m_out_buffer.append( input.data(), input.size() );
                m_write_pos = m_out_buffer.size();
            }
            else
            {
                if( std::numeric_limits< decltype( m_zlib_stream.avail_in ) >::max() < input.size() )
                {
                    throw exception_t{
                        fmt::format(
                            RESTINIO_FMT_FORMAT_STRING(
                                "input data is too large: {} (max possible: {}), "
                                "try to break large data into pieces" ),
                            input.size(),
                            std::numeric_limits< decltype( m_zlib_stream.avail_in ) >::max() ) };
                }
 
                if( 0 < input.size() )
                {
                    m_zlib_stream.next_in =
                        reinterpret_cast< Bytef* >( const_cast< char* >( input.data() ) );
 
                    m_zlib_stream.avail_in = static_cast< uInt >( input.size() );
 
                    if( params_t::operation_t::compress == m_params.operation() )
                    {
                        write_compress_impl( Z_NO_FLUSH );
                    }
                    else
                    {
                        write_decompress_impl( Z_NO_FLUSH );
                    }
                }
            }
        }


        void
        flush()
        {
            ensure_operation_in_not_completed();
 
            if( !is_identity() )
            {
                m_zlib_stream.next_in = nullptr;
                m_zlib_stream.avail_in = static_cast< uInt >( 0 );
 
                if( params_t::operation_t::compress == m_params.operation() )
                {
                    write_compress_impl( Z_SYNC_FLUSH );
                }
                else
                {
                    write_decompress_impl( Z_SYNC_FLUSH );
                }
            }
        }

        void
        complete()
        {
            ensure_operation_in_not_completed();
 
            if( !is_identity() )
            {
                m_zlib_stream.next_in = nullptr;
                m_zlib_stream.avail_in = static_cast< uInt >( 0 );
 
                if( params_t::operation_t::compress == m_params.operation() )
                {
                    write_compress_impl( Z_FINISH );
                }
                else
                {
                    write_decompress_impl( Z_FINISH );
                }
            }
 
            m_operation_is_complete = true;
        }


        std::string
        giveaway_output()
        {
            std::string result;
            const auto data_size = m_write_pos;
            std::swap( result, m_out_buffer );
            m_write_pos = 0;
            result.resize( data_size ); // Shrink output data.
            return result;
        }

        auto output_size() const { return m_write_pos; }

        bool is_completed() const { return m_operation_is_complete; }
 
    private:
        bool is_identity() const
        {
            return params_t::format_t::identity == m_params.format();
        }

        const char *
        get_error_msg() const
        {
            const char * err_msg = "<no zlib error description>";
            if( m_zlib_stream.msg )
                err_msg = m_zlib_stream.msg;
 
            return err_msg;
        }

        void
        ensure_operation_in_not_completed() const
        {
            if( is_completed() )
                throw exception_t{ "zlib operation is already completed" };
        }

        void
        inc_buffer()
        {
            m_out_buffer.resize(
                m_out_buffer.size() + m_params.reserve_buffer_size() );
        }

        auto
        prepare_out_buffer()
        {
            m_zlib_stream.next_out =
                reinterpret_cast< Bytef* >(
                    const_cast< char* >( m_out_buffer.data() + m_write_pos ) );
 
            const auto provided_out_buffer_size =
                m_out_buffer.size() - m_write_pos;
            m_zlib_stream.avail_out =
                static_cast<uInt>( provided_out_buffer_size );
 
            return provided_out_buffer_size;
        }

        /*
            Data and its size must be already in
            `m_zlib_stream.next_in`, `m_zlib_stream.avail_in`.
        */
        void
        write_compress_impl( int flush )
        {
            while( true )
            {
                const auto provided_out_buffer_size = prepare_out_buffer();
 
                int operation_result = deflate( &m_zlib_stream, flush );
 
                if( !( Z_OK == operation_result ||
                        Z_BUF_ERROR == operation_result ||
                        ( Z_STREAM_END == operation_result && Z_FINISH == flush ) ) )
                {
                    const char * err_msg = "<no error desc>";
                    if( m_zlib_stream.msg )
                        err_msg = m_zlib_stream.msg;
 
                    throw exception_t{
                        fmt::format(
                            RESTINIO_FMT_FORMAT_STRING(
                                "unexpected result of deflate() (zlib): {}, {}" ),
                            operation_result,
                            err_msg ) };
                }
 
                m_write_pos += provided_out_buffer_size - m_zlib_stream.avail_out;
 
                if( 0 == m_zlib_stream.avail_out && Z_STREAM_END != operation_result )
                {
                    // Looks like not all the output was obtained.
                    // There is a minor chance that it just happened to
                    // occupy exactly the same space that was available,
                    // in that case it would go for a one redundant call to deflate.
                    inc_buffer();
                    continue;
                }
 
                if( 0 == m_zlib_stream.avail_in )
                {
                    // All the input was consumed.
                    break;
                }
            }
        }

        /*
            Data and its size must be already in
            `m_zlib_stream.next_in`, `m_zlib_stream.avail_in`.
        */
        void
        write_decompress_impl( int flush )
        {
            while( true )
            {
                const auto provided_out_buffer_size = prepare_out_buffer();
 
                int operation_result = inflate( &m_zlib_stream, flush );
                if( !( Z_OK == operation_result ||
                        Z_BUF_ERROR == operation_result ||
                        Z_STREAM_END == operation_result ) )
                {
                    throw exception_t{
                        fmt::format(
                            RESTINIO_FMT_FORMAT_STRING(
                                "unexpected result of inflate() (zlib): {}, {}" ),
                            operation_result,
                            get_error_msg() ) };
                }
 
                m_write_pos += provided_out_buffer_size - m_zlib_stream.avail_out;
 
                if( 0 == m_zlib_stream.avail_out && Z_STREAM_END != operation_result )
                {
                    // Looks like not all the output was obtained.
                    // There is a minor chance that it just happened to
                    // occupy exactly the same space that was available,
                    // in that case it would go for a one redundant call to deflate.
                    inc_buffer();
                    continue;
                }
 
                if( Z_STREAM_END == operation_result )
                {
                    // All data was processed. There is no sense to continue
                    // even if m_zlib_stream.avail_in isn't zero.
                    break;
                }
 
                if( 0 == m_zlib_stream.avail_in )
                {
                    // All the input was consumed.
                    break;
                }
            }
        }

        const params_t m_params;


        bool m_zlib_stream_initialized{ false };

        z_stream m_zlib_stream;

        std::string m_out_buffer;
        std::size_t m_write_pos{ 0 };
 
        bool m_operation_is_complete{ false };
};


inline std::string
transform( string_view_t input, const params_t & params )
{
    zlib_t z{ params };
    z.write( input );
    z.complete();
 
    return z.giveaway_output();
}
 
inline std::string
deflate_compress( string_view_t input, int compression_level = -1 )
{
    return transform( input, make_deflate_compress_params( compression_level ) );
}
 
inline std::string
deflate_decompress( string_view_t input )
{
    return transform( input, make_deflate_decompress_params() );
}
 
inline std::string
gzip_compress( string_view_t input, int compression_level = -1 )
{
    return transform( input, make_gzip_compress_params( compression_level ) );
}
 
inline std::string
gzip_decompress( string_view_t input )
{
    return transform( input, make_gzip_decompress_params() );
}

 
//
// body_appender_t
//
 
template < typename Response_Output_Strategy >
class body_appender_t
{
    body_appender_t() = delete;
};
 
namespace impl
{

inline void ensure_is_compression_operation( params_t::operation_t op )
{
    if( params_t::operation_t::compress != op )
    {
        throw exception_t{ "operation is not copress" };
    }
}

inline void ensure_valid_transforator( zlib_t * ztransformator )
{
    if( nullptr == ztransformator )
    {
        throw exception_t{ "invalid body appender" };
    }
}

inline std::string content_encoding_token( params_t::format_t f )
{
    std::string result{ "identity" };
 
    if( params_t::format_t::deflate == f )
    {
        result.assign( "deflate" );
    }
    if( params_t::format_t::gzip == f )
    {
        result.assign( "gzip" );
    }
 
    return result;
}
 
} /* namespace impl */
 
//
// body_appender_base_t
//

template < typename Response_Output_Strategy, typename Descendant >
class body_appender_base_t
{
    public:
        using resp_t = response_builder_t< Response_Output_Strategy >;
 
        body_appender_base_t( const params_t & params, resp_t & resp )
            :   m_ztransformator{ std::make_unique< zlib_t >( params ) }
            ,   m_resp{ resp }
        {
            impl::ensure_is_compression_operation(
                m_ztransformator->params().operation() );
 
            m_resp.append_header(
                restinio::http_field::content_encoding,
                impl::content_encoding_token(
                    m_ztransformator->params().format() ) );
        }
 
        body_appender_base_t( const body_appender_base_t & ) = delete;
        body_appender_base_t & operator = ( const body_appender_base_t & ) = delete;
        body_appender_base_t & operator = ( body_appender_base_t && ) = delete;
 
        body_appender_base_t( body_appender_base_t && ba ) noexcept
            :   m_ztransformator{ std::move( ba.m_ztransformator ) }
            ,   m_resp{ ba.m_resp }
        {}
 
        virtual ~body_appender_base_t() {}
 
    protected:
        std::unique_ptr< zlib_t > m_ztransformator;
        resp_t & m_resp;
};

template < typename X_Controlled_Output, typename Descendant >
class x_controlled_output_body_appender_base_t
    :   public body_appender_base_t< X_Controlled_Output, Descendant >
{
    public:
        using base_type_t = body_appender_base_t< X_Controlled_Output, Descendant >;
 
        using base_type_t::base_type_t;

        Descendant &
        append( string_view_t input )
        {
            impl::ensure_valid_transforator( this->m_ztransformator.get() );
            this->m_ztransformator->write( input );
            return static_cast< Descendant & >( *this );
        }

        void
        complete()
        {
            impl::ensure_valid_transforator( this->m_ztransformator.get() );
 
            this->m_ztransformator->complete();
 
            this->m_resp.append_body( this->m_ztransformator->giveaway_output() );
        }
};

template <>
class body_appender_t< restinio_controlled_output_t >
    :   public x_controlled_output_body_appender_base_t<
                    restinio_controlled_output_t,
                    body_appender_t< restinio_controlled_output_t > >
{
    public:
        using base_type_t =
            x_controlled_output_body_appender_base_t<
                restinio_controlled_output_t,
                body_appender_t< restinio_controlled_output_t > >;

        auto
        size() const
        {
            impl::ensure_valid_transforator( m_ztransformator.get() );
 
            return m_ztransformator->output_size();
        }
 
        using base_type_t::base_type_t;
};

template <>
class body_appender_t< user_controlled_output_t > final
    :   public x_controlled_output_body_appender_base_t<
                    user_controlled_output_t,
                    body_appender_t< user_controlled_output_t > >
{
    public:
        using base_type_t =
            x_controlled_output_body_appender_base_t<
                user_controlled_output_t,
                body_appender_t< user_controlled_output_t > >;
 
        using base_type_t::base_type_t;
 
        auto &
        flush()
        {
            impl::ensure_valid_transforator( m_ztransformator.get() );
            m_ztransformator->flush();
            m_resp
                .append_body( m_ztransformator->giveaway_output() )
                .flush();
 
            return *this;
        }
};
 

template <>
class body_appender_t< chunked_output_t > final
    :   public body_appender_base_t<
                    chunked_output_t,
                    body_appender_t< chunked_output_t > >
{
    public:
        using base_type_t =
            body_appender_base_t<
                chunked_output_t,
                body_appender_t< chunked_output_t > >;
 
        using base_type_t::base_type_t;


        auto &
        append( string_view_t input )
        {
            impl::ensure_valid_transforator( m_ztransformator.get() );
 
            m_ztransformator->write( input );
            return *this;
        }


        auto &
        make_chunk( string_view_t input = string_view_t{} )
        {
            append( input ); // m_ztransformator is checked here.
 
            m_ztransformator->flush(); // Flush already compressed data.
 
            // Create a chunk with current output.
            m_resp.append_chunk( m_ztransformator->giveaway_output() );
 
            return *this;
        }

        void
        flush()
        {
            impl::ensure_valid_transforator( m_ztransformator.get() );
 
            if( !m_ztransformator->is_completed() )
            {
                m_ztransformator->flush();
                m_resp.append_chunk( m_ztransformator->giveaway_output() );
            }
 
            m_resp.flush();
        }

        void
        complete()
        {
            impl::ensure_valid_transforator( m_ztransformator.get() );
            m_ztransformator->complete();
            m_resp.append_chunk( m_ztransformator->giveaway_output() );
        }
};

template < typename Response_Output_Strategy >
body_appender_t< Response_Output_Strategy >
body_appender(
    response_builder_t< Response_Output_Strategy > & resp,
    const params_t & params )
{
    return body_appender_t< Response_Output_Strategy >{ params, resp };
}

template < typename Response_Output_Strategy >
body_appender_t< Response_Output_Strategy >
deflate_body_appender(
    response_builder_t< Response_Output_Strategy > & resp,
    int compression_level = -1 )
{
    return body_appender( resp, make_deflate_compress_params( compression_level ) );
}

template < typename Response_Output_Strategy >
inline body_appender_t< Response_Output_Strategy >
gzip_body_appender(
    response_builder_t< Response_Output_Strategy > & resp,
    int compression_level = -1 )
{
    return body_appender( resp, make_gzip_compress_params( compression_level ) );
}

template < typename Response_Output_Strategy >
inline body_appender_t< Response_Output_Strategy >
identity_body_appender(
    response_builder_t< Response_Output_Strategy > & resp,
    int = -1 )
{
    return body_appender( resp, make_identity_params() );
}


template < typename Extra_Data, typename Handler >
decltype(auto)
handle_body(
    const generic_request_t<Extra_Data> & req,
    Handler && handler )
{
    using restinio::impl::is_equal_caseless;
 
    const auto content_encoding =
        req.header().get_field_or( restinio::http_field::content_encoding, "identity" );
 
    if( is_equal_caseless( content_encoding, "deflate" ) )
    {
        return handler( deflate_decompress( req.body() ) );
    }
    else if( is_equal_caseless( content_encoding, "gzip" ) )
    {
        return handler( gzip_decompress( req.body() ) );
    }
    else if( !is_equal_caseless( content_encoding, "identity" ) )
    {
        throw exception_t{
            fmt::format(
                    RESTINIO_FMT_FORMAT_STRING( "content-encoding '{}' not supported" ),
                    content_encoding )
        };
    }
 
    return handler( req.body() );
}
 
} /* namespace zlib */
 
} /* namespace transforms */
 
} /* namespace restinio */