inflateinputstreambuf.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 "inflateinputstreambuf.hpp"

#include "zipios++/zipiosexceptions.hpp"

#include "zipios_common.hpp"


namespace zipios
{

InflateInputStreambuf::InflateInputStreambuf(std::streambuf *inbuf, offset_t start_pos)
    : FilterInputStreambuf(inbuf)
    , m_outvec(getBufferSize())
    , m_invec(getBufferSize())
    //, m_zs() -- auto-init
    //, m_zs_initialized(false) -- auto-init
{
    // NOTICE: It is important that this constructor and the methods it
    // calls doesn't do anything with the input streambuf inbuf, other
    // than repositioning it to the specified position. The reason is
    // that this class can be subclassed, and the subclass should get a
    // chance to read from the buffer first)

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

    reset(start_pos);
    // We are not checking the return value of reset() and throwing
    // an exception in case of an error, because we cannot catch the exception
    // in the constructors of subclasses with all compilers.
}


InflateInputStreambuf::~InflateInputStreambuf()
{
    // Dealloc z_stream stuff
    int const err(inflateEnd(&m_zs));
    if(err != Z_OK)
    {
        // in a destructor we cannot throw...
        OutputStringStream msgs; // LCOV_EXCL_LINE
        msgs << "InflateInputStreambuf::~InflateInputStreambuf(): inflateEnd() failed" // LCOV_EXCL_LINE
             << ": " << zError(err); // LCOV_EXCL_LINE
        std::cerr << msgs.str() << std::endl; // LCOV_EXCL_LINE
    }
}


std::streambuf::int_type InflateInputStreambuf::underflow()
{
    // If not really underflow do not fill buffer
    // (is that really possible?!)
    if(gptr() < egptr())
    {
        return traits_type::to_int_type(*gptr()); // LCOV_EXCL_LINE
    }

    // Prepare _outvec and get array pointers
    m_zs.avail_out = getBufferSize();
    m_zs.next_out = reinterpret_cast<unsigned char *>(&m_outvec[0]);

    // Inflate until _outvec is full
    // eof (or I/O prob) on _inbuf will break out of loop too.
    int err(Z_OK);
    while(m_zs.avail_out > 0 && err == Z_OK)
    {
        if(m_zs.avail_in == 0)
        {
            // fill m_invec
            std::streamsize const bc(m_inbuf->sgetn(&m_invec[0], getBufferSize()));
            m_zs.next_in = reinterpret_cast<unsigned char *>(&m_invec[0]);
            m_zs.avail_in = bc;
            // If we could not read any new data (bc == 0) and inflate is not
            // done it will return Z_BUF_ERROR and thus breaks out of the
            // loop. This means we do not have to respond to the situation
            // where we cannot read more bytes here.
        }

        err = inflate(&m_zs, Z_NO_FLUSH);
    }

    // Normally the number of inflated bytes will be the
    // full length of the output buffer, but if we can't read
    // more input from the _inbuf streambuf, we end up with
    // less.
    offset_t const inflated_bytes = getBufferSize() - m_zs.avail_out;
    setg(&m_outvec[0], &m_outvec[0], &m_outvec[0] + inflated_bytes);

    if(err != Z_OK && err != Z_STREAM_END)
    {
        OutputStringStream msgs;
        msgs << "InflateInputStreambuf::underflow(): inflate failed"
             << ": " << zError(err);
        // Throw an exception to immediately exit to the read() or similar
        // function and make istream set badbit
        throw IOException(msgs.str());
    }

    if(inflated_bytes > 0)
    {
        return traits_type::to_int_type(*gptr());
    }

    return traits_type::eof();
}



bool InflateInputStreambuf::reset(offset_t stream_position)
{
    if(stream_position >= 0)
    {
        // reposition m_inbuf
        m_inbuf->pubseekpos(stream_position);
    }

    // m_zs.next_in and avail_in must be set according to
    // zlib.h (inline doc).
    m_zs.next_in = reinterpret_cast<Bytef *>(&m_invec[0]);
    m_zs.avail_in = 0;

    int err(Z_OK);
    if(m_zs_initialized)
    {
        // just reset it
        err = inflateReset(&m_zs);
    }
    else
    {
        // initialize it
        err = inflateInit2(&m_zs, -MAX_WBITS);
        /* windowBits is passed < 0 to tell that there is no zlib header.
           Note that in this case inflate *requires* an extra "dummy" byte
           after the compressed stream in order to complete decompression
           and return Z_STREAM_END.  We always have an extra "dummy" byte,
           because there is always some trailing data after the compressed
           data (either the next entry or the central directory.  */
        m_zs_initialized = true;
    }

    // streambuf init:
    // The important thing here, is that
    // - the pointers are not NULL (which would mean unbuffered)
    // - and that gptr() is not less than egptr() (so we trigger underflow
    //   the first time data is read).
    setg(&m_outvec[0], &m_outvec[0] + getBufferSize(), &m_outvec[0] + getBufferSize());

    return err == Z_OK;
}


} // zipios namespace

// Local Variables:
// mode: cpp
// indent-tabs-mode: nil
// c-basic-offset: 4
// tab-width: 4
// End:

// vim: ts=4 sw=4 et