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  Made to Order Software Corporation

  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 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/

#include "deflateoutputstreambuf.hpp"

#include "zipios++/zipiosexceptions.hpp"

#include "zipios_common.hpp"


namespace zipios
{

DeflateOutputStreambuf::DeflateOutputStreambuf(std::streambuf *outbuf)
    : FilterOutputStreambuf(outbuf)
    //, m_overflown_bytes(0) -- auto-init
    , m_invec(getBufferSize())
    //, m_zs() -- auto-init
    //, m_zs_initialized(false) -- auto-init
    , m_outvec(getBufferSize())
    //, m_crc32(0) -- auto-init
{
    // NOTICE: It is important that this constructor and the methods it
    //         calls does not do anything with the output streambuf m_outbuf.
    //         The reason is that this class can be subclassed, and the
    //         subclass should get a chance to write to the buffer first.

    // zlib init:
    m_zs.zalloc = Z_NULL;
    m_zs.zfree  = Z_NULL;
    m_zs.opaque = Z_NULL;
}


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 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()
{
    size_t deflated_bytes(getBufferSize() - m_zs.avail_out);
    if(deflated_bytes > 0)
    {
        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