deflateoutputstreambuf.cpp

Go to the documentation of this file.

/*
  Zipios -- a small C++ library that provides easy access to .zip files.
 
  Copyright (C) 2000-2007  Thomas Sondergaard
  Copyright (c) 2015-2022  Made to Order Software Corp.  All Rights Reserved
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
 
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
 
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/
 
#include "deflateoutputstreambuf.hpp"
 
#include "zipios/zipiosexceptions.hpp"
 
#include "zipios_common.hpp"
 
 
namespace zipios
{
 
DeflateOutputStreambuf::DeflateOutputStreambuf(std::streambuf * outbuf)
    : FilterOutputStreambuf(outbuf)
    , m_invec(getBufferSize())
    , m_outvec(getBufferSize())
{
    // NOTICE: It is important that this constructor and the methods it
    //         calls do not do anything with the output streambuf m_outbuf.
    //         The reason is that this class can be sub-classed, and the
    //         sub-class should get a chance to write to the buffer first.
}
 
 
DeflateOutputStreambuf::~DeflateOutputStreambuf()
{
    closeStream();
}
 
 
bool DeflateOutputStreambuf::init(FileEntry::CompressionLevel compression_level)
{
    if(m_zs_initialized)
    {
        // This is excluded from the coverage since if we reach this
        // line there is an internal error that needs to be fixed.
        throw std::logic_error("DeflateOutputStreambuf::init(): initialization function called when the class is already initialized. This is not supported."); // LCOV_EXCL_LINE
    }
    m_zs_initialized = true;
 
    int const default_mem_level(8);
 
    int zlevel(Z_NO_COMPRESSION);
    switch(compression_level)
    {
    case FileEntry::COMPRESSION_LEVEL_DEFAULT:
        zlevel = Z_DEFAULT_COMPRESSION;
        break;
 
    case FileEntry::COMPRESSION_LEVEL_SMALLEST:
        zlevel = Z_BEST_COMPRESSION;
        break;
 
    case FileEntry::COMPRESSION_LEVEL_FASTEST:
        zlevel = Z_BEST_SPEED;
        break;
 
    case FileEntry::COMPRESSION_LEVEL_NONE:
        throw std::logic_error("the compression level NONE is not supported in DeflateOutputStreambuf::init()"); // LCOV_EXCL_LINE
 
    default:
        if(compression_level < FileEntry::COMPRESSION_LEVEL_MINIMUM
        || compression_level > FileEntry::COMPRESSION_LEVEL_MAXIMUM)
        {
            // This is excluded from the coverage since if we reach this
            // line there is an internal error that needs to be fixed.
            throw std::logic_error("the compression level must be defined between -3 and 100, see the zipios/fileentry.hpp for a list of valid levels."); // LCOV_EXCL_LINE
        }
        // The zlevel is calculated linearly from the user specified value
        // of 1 to 100
        //
        // The calculation goes as follow:
        //
        //    x = user specified value - 1    (0 to 99)
        //    x = x * 8                       (0 to 792)
        //    x = x + 11 / 2                  (5 to 797, i.e. +5 with integers)
        //    x = x / 99                      (0 to 8)
        //    x = x + 1                       (1 to 9)
        //
        zlevel = ((compression_level - 1) * 8 + 11 / 2) / 99 + 1;
        break;
 
    }
 
    // m_zs.next_in and avail_in must be set according to
    // zlib.h (inline doc).
    m_zs.next_in  = reinterpret_cast<unsigned char *>(&m_invec[0]);
    m_zs.avail_in = 0;
 
    m_zs.next_out  = reinterpret_cast<unsigned char *>(&m_outvec[0]);
    m_zs.avail_out = getBufferSize();
 
    //
    // windowBits is passed -MAX_WBITS to tell that no zlib
    // header should be written.
    //
    int const err = deflateInit2(&m_zs, zlevel, Z_DEFLATED, -MAX_WBITS, default_mem_level, Z_DEFAULT_STRATEGY);
    if(err != Z_OK)
    {
        // Not too sure how we could generate an error here, the deflateInit2()
        // would fail if (1) there is not enough memory and (2) if a parameter
        // is out of wack which neither can be generated from the outside
        // (well... not easily)
        std::ostringstream msgs; // LCOV_EXCL_LINE
        msgs << "DeflateOutputStreambuf::init(): error while initializing zlib, " << zError(err) << std::endl; // LCOV_EXCL_LINE
        throw IOException(msgs.str()); // LCOV_EXCL_LINE
    }
 
    // streambuf init:
    setp(&m_invec[0], &m_invec[0] + getBufferSize());
 
    m_crc32 = crc32(0, Z_NULL, 0);
 
    return err == Z_OK;
}
 
 
void DeflateOutputStreambuf::closeStream()
{
    if(m_zs_initialized)
    {
        m_zs_initialized = false;
 
        // flush any remaining data
        endDeflation();
 
        int const err(deflateEnd(&m_zs));
        if(err != Z_OK) // when we close a directory, we get the Z_DATA_ERROR!
        {
            // There are not too many cases which break the deflateEnd()
            // function call...
            std::ostringstream msgs; // LCOV_EXCL_LINE
            msgs << "DeflateOutputStreambuf::closeStream(): deflateEnd failed: " << zError(err) << std::endl; // LCOV_EXCL_LINE
            throw IOException(msgs.str()); // LCOV_EXCL_LINE
        }
    }
}
 
 
uint32_t DeflateOutputStreambuf::getCrc32() const
{
    return m_crc32;
}
 
 
size_t DeflateOutputStreambuf::getSize() const
{
    return m_overflown_bytes;
}
 
 
int DeflateOutputStreambuf::overflow(int c)
{
    int err(Z_OK);
 
    m_zs.avail_in = pptr() - pbase();
    m_zs.next_in = reinterpret_cast<unsigned char *>(&m_invec[0]);
 
    if(m_zs.avail_in > 0)
    {
        m_crc32 = crc32(m_crc32, m_zs.next_in, m_zs.avail_in); // update crc32
 
        m_zs.next_out = reinterpret_cast<unsigned char *>(&m_outvec[0]);
        m_zs.avail_out = getBufferSize();
 
        // Deflate until m_invec is empty.
        while((m_zs.avail_in > 0 || m_zs.avail_out == 0) && err == Z_OK)
        {
            if(m_zs.avail_out == 0)
            {
                flushOutvec();
            }
 
            err = deflate(&m_zs, Z_NO_FLUSH);
        }
    }
 
    // somehow we need this flush here or it fails
    flushOutvec();
 
    // Update 'put' pointers
    setp(&m_invec[0], &m_invec[0] + getBufferSize());
 
    if(err != Z_OK && err != Z_STREAM_END)
    {
        // Throw an exception to make istream set badbit
        //
        // This is marked as not cover-able by tests because the calls
        // that access this function only happen in an internal loop and
        // even if we were to write a direct test, I do not see how
        // we could end up with an error here
        OutputStringStream msgs; // LCOV_EXCL_LINE
        msgs << "Deflation failed:" << zError(err); // LCOV_EXCL_LINE
        throw IOException(msgs.str()); // LCOV_EXCL_LINE
    }
 
    if(c != EOF)
    {
        *pptr() = c;
        pbump(1);
    }
 
    return 0;
}
 
 
int DeflateOutputStreambuf::sync() // LCOV_EXCL_LINE
{
    return -1; // LCOV_EXCL_LINE
}
 
 
void DeflateOutputStreambuf::flushOutvec()
{
    std::size_t const deflated_bytes(getBufferSize() - m_zs.avail_out);
    if(deflated_bytes > 0)
    {
        std::size_t const bc(m_outbuf->sputn(&m_outvec[0], deflated_bytes));
        if(deflated_bytes != bc)
        {
            // Without implementing our own stream in our test, this
            // cannot really be reached because it is all happening
            // inside the same loop in ZipFile::saveCollectionToArchive()
            throw IOException("DeflateOutputStreambuf::flushOutvec(): write to buffer failed."); // LCOV_EXCL_LINE
        }
    }
 
    m_zs.next_out = reinterpret_cast<unsigned char *>(&m_outvec[0]);
    m_zs.avail_out = getBufferSize();
}
 
 
void DeflateOutputStreambuf::endDeflation()
{
    overflow();
 
    m_zs.next_out = reinterpret_cast<unsigned char *>(&m_outvec[0]);
    m_zs.avail_out = getBufferSize();
 
    // Deflate until _invec is empty.
    int err(Z_OK);
 
    // make sure to NOT call deflate() if nothing was written to the
    // deflate output stream, otherwise we get a "spurious" (as far
    // Zip archives are concerned) 0x03 0x00 marker from the zlib
    // library
    //
    if(m_overflown_bytes > 0)
    {
        while(err == Z_OK)
        {
            if(m_zs.avail_out == 0)
            {
                flushOutvec();
            }
 
            err = deflate(&m_zs, Z_FINISH);
        }
    }
    else
    {
        // this is not expected to happen, but it can
        err = Z_STREAM_END; // LCOV_EXCL_LINE
    }
 
    flushOutvec();
 
    if(err != Z_STREAM_END)
    {
        // This is marked as not cover-able because the calls that
        // access this function only happen in an internal loop and
        // even if we were to write a direct test, I do not see how
        // we could end up with an error here
        std::ostringstream msgs; // LCOV_EXCL_LINE
        msgs << "DeflateOutputStreambuf::endDeflation(): deflate() failed: " // LCOV_EXCL_LINE
             << zError(err) << std::endl; // LCOV_EXCL_LINE
        throw IOException(msgs.str()); // LCOV_EXCL_LINE
    }
}
 
 
} // namespace
 
// Local Variables:
// mode: cpp
// indent-tabs-mode: nil
// c-basic-offset: 4
// tab-width: 4
// End:
 
// vim: ts=4 sw=4 et