Decompress throw error when the size of origin data is less that 10

[zixincheng]

I am working on some compress and decompress actions, I implement something like the following code to compress data into fixed chunk size 1024.

` std::unique_ptr< web::http::compression::compress_provider > compressor;
compressor = web::http::compression::builtin::make_compressor(
web::http::compression::builtin::algorithm::GZIP );

std::vector< uint8_t > cmp_buffer;
web::http::compression::operation_result r;
const size_t chunk_size = 1024;
size_t csize;
size_t i;

if ( data == nullptr || data_size == 0 )
{
    return cmp_buffer;
}

// compress in chunks
csize = 0;
cmp_buffer.resize( data_size );
for ( i = 0; i < data_size; i += chunk_size )
{
    r = compressor
            ->compress( data + i, std::min( chunk_size, data_size - i ),
                        cmp_buffer.data( ) + csize, std::min( chunk_size, data_size - csize ),
                        web::http::compression::operation_hint::has_more )
            .get( );
    csize += r.output_bytes_produced;
}
if ( i >= data_size )
{
    size_t cmpsize = data_size;
    do
    {
        if ( csize == cmpsize )
        {
            // extend the output buffer if there may be more compressed bytes to retrieve
            cmpsize += std::min( chunk_size, (size_t)200 );
            cmp_buffer.resize( cmpsize );
        }
        r = compressor
                ->compress( NULL, 0, cmp_buffer.data( ) + csize,
                            std::min( chunk_size, cmpsize - csize ),
                            web::http::compression::operation_hint::is_last )
                .get( );
        csize += r.output_bytes_produced;
    } while ( csize == cmpsize );
}

cmp_buffer.resize( csize );

return cmp_buffer;`

and following is the decompressed code:
`std::unique_ptr< web::http::compression::decompress_provider > decompressor
= web::http::compression::builtin::make_decompressor(
web::http::compression::builtin::algorithm::GZIP );

size_t buffer_size = data.size( ) * 3;
const size_t chunk_size = 1024;
std::vector< uint8_t > dcmp_buffer;
web::http::compression::operation_result r;
std::vector< size_t > chunk_sizes;
size_t dsize;
size_t nn;
nn = 0;
dsize = 0;
dcmp_buffer.resize( buffer_size );

do
{
    size_t n = std::min( chunk_size, data.size( ) - nn );
    do
    {
        if ( buffer_size <= dsize )
        {
            buffer_size += 1024;
            dcmp_buffer.resize( buffer_size );
        }
        r = decompressor
                ->decompress( data.data( ) + nn, n, dcmp_buffer.data( ) + dsize,
                              std::min( chunk_size, buffer_size - dsize ),
                              web::http::compression::operation_hint::has_more )
                .get( );
        dsize += r.output_bytes_produced;
        nn += r.input_bytes_processed;
        n -= r.input_bytes_processed;
    } while ( n );
} while ( nn < data.size( ) || !r.done );

dcmp_buffer.resize( dsize );

return dcmp_buffer;`

If the data_size is equal or larger than 10, say if I compress and decompress a string "1234567890", everything works fine.
If the data_size is less than 10, say "123", compress progress works fine but decompress will throw an error with code -3.
I wonder if i did something wrong or there is a bug in the compress function.

FYI, previous version works fine.

Thanks

[BillyONeal]

@epistor Can you take a look?

[epistor]

This is actually a bug in @zixincheng's code -- and in my own similar test code in compression_tests:compress_and_decompress, for which I've included a fix (and explicit small-input test) in #973. In the 3-byte case, the gzip compressor consumes 0 input bytes but produces 3 output bytes on the first pass. This is a legitimate result, and extending the output buffer and calling compress again allows progress to be made. Note that we already explicitly (and successfully) test 3-byte compression/decompression in compression_tests:compress_client_server, so we know that the processing in http_client_winhttp handles this situation fine.

@zixincheng, which "previous version" are you referring to?

[zixincheng]

The "previous version" I meant the version without this change:
cdc2948
aka the compression function still in http_helpers class.