zipfile.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 "zipios/zipfile.hpp"
 
#include "zipios/streamentry.hpp"
#include "zipios/zipiosexceptions.hpp"
 
#include "backbuffer.hpp"
#include "zipendofcentraldirectory.hpp"
#include "zipcentraldirectoryentry.hpp"
#include "zipinputstream.hpp"
#include "zipoutputstream.hpp"
 
#include <fstream>
 
 
namespace zipios
{
 
 
ZipFile::pointer_t ZipFile::openEmbeddedZipFile(std::string const & filename)
{
    // open zipfile, read 4 last bytes close file
    uint32_t start_offset;
    {
        std::ifstream ifs(filename, std::ios::in | std::ios::binary);
        ifs.seekg(-4, std::ios::end);
        zipRead(ifs, start_offset);
        // todo: add support for 64 bit (files of more than 4Gb)
    }
 
    // create ZipFile object from embedded data
    return std::make_shared<ZipFile>(filename, start_offset, 4);
}
 
 
ZipFile::ZipFile()
{
}
 
 
ZipFile::ZipFile(std::string const & filename, offset_t s_off, offset_t e_off)
    : FileCollection(filename)
    , m_vs(s_off, e_off)
{
    std::ifstream zipfile(m_filename, std::ios::in | std::ios::binary);
    if(!zipfile)
    {
        throw IOException("Error opening Zip archive file for reading in binary mode.");
    }
 
    init(zipfile);
}
 
 
ZipFile::ZipFile(std::istream & is, offset_t s_off, offset_t e_off)
    : m_vs(s_off, e_off)
{
    init(is);
}
 
 
void ZipFile::init(std::istream & is)
{
    // Find and read the End of Central Directory.
    ZipEndOfCentralDirectory eocd;
    {
        BackBuffer bb(is, m_vs);
        ssize_t read_p(-1);
        for(;;)
        {
            if(read_p < 0)
            {
                if(!bb.readChunk(read_p))
                {
                    throw FileCollectionException("Unable to find zip structure: End-of-central-directory");
                }
            }
            // Note: this is pretty fast since it reads from 'bb' which
            //       caches the buffer the readChunk() function just read.
            //
            if(eocd.read(bb, read_p))
            {
                // found it!
                break;
            }
            --read_p;
        }
    }
 
    // Position read pointer to start of first entry in central dir.
    m_vs.vseekg(is, eocd.getOffset(), std::ios::beg);
 
    // TBD -- is that ", 0" still necessary? (With VC2012 and better)
    // Give the second argument in the next line to keep Visual C++ quiet
    //m_entries.resize(eocd.getCount(), 0);
    m_entries.resize(eocd.getCount());
 
    size_t const max_entry(eocd.getCount());
    for(size_t entry_num(0); entry_num < max_entry; ++entry_num)
    {
        m_entries[entry_num] = std::make_shared<ZipCentralDirectoryEntry>();
        m_entries[entry_num].get()->read(is);
    }
 
    // Consistency check #1:
    // The virtual seeker position is exactly the start offset of the
    // Central Directory plus the Central Directory size
    //
    offset_t const pos(m_vs.vtellg(is));
    if(static_cast<offset_t>(eocd.getOffset() + eocd.getCentralDirectorySize()) != pos)
    {
        throw FileCollectionException("Zip file consistency problem. Zip file data fields are inconsistent with zip file layout.");
    }
 
    // Consistency check #2:
    // Are local headers consistent with CD headers?
    //
    for(auto it = m_entries.begin(); it != m_entries.end(); ++it)
    {
        m_vs.vseekg(is, (*it)->getEntryOffset(), std::ios::beg);
        ZipLocalEntry zlh;
        zlh.read(is);
        if(!is || !zlh.isEqual(**it))
        {
            throw FileCollectionException("Zip file consistency problem. Zip file data fields are inconsistent with zip file layout.");
        }
    }
 
    // we are all good!
    m_valid = true;
}
 
 
FileCollection::pointer_t ZipFile::clone() const
{
    return FileCollection::pointer_t(std::make_shared<ZipFile>(*this));
}
 
 
ZipFile::~ZipFile()
{
    close();
}
 
 
ZipFile::stream_pointer_t ZipFile::getInputStream(std::string const & entry_name, MatchPath matchpath)
{
    mustBeValid();
 
    // TODO: see whether we could make the handling of the StreamEntry
    //       non-special
    //
    FileEntry::pointer_t entry(getEntry(entry_name, matchpath));
    StreamEntry::pointer_t stream(std::dynamic_pointer_cast<StreamEntry>(entry));
    if(stream != nullptr)
    {
        stream_pointer_t zis(std::make_shared<ZipInputStream>(stream->getStream()));
        return zis;
    }
    else if(entry != nullptr)
    {
        stream_pointer_t zis(std::make_shared<ZipInputStream>(m_filename, entry->getEntryOffset() + m_vs.startOffset()));
        return zis;
    }
 
    // no entry with that name (and match) available
    return nullptr;
}
 
 
void ZipFile::saveCollectionToArchive(
      std::ostream & os
    , FileCollection & collection
    , std::string const & zip_comment)
{
    try
    {
        ZipOutputStream output_stream(os);
 
        output_stream.setComment(zip_comment);
 
        FileEntry::vector_t entries(collection.entries());
        for(auto it(entries.begin()); it != entries.end(); ++it)
        {
            output_stream.putNextEntry(*it);
 
            // next we need to include the data of that file in the
            // output buffer if it is not a directory and the file is
            // not an empty file
            //
            if(!(*it)->isDirectory()
            && (*it)->getSize() > 0)
            {
                // get an InputStream
                //
                FileCollection::stream_pointer_t is(collection.getInputStream((*it)->getName()));
                if(is != nullptr
                && is->good())
                {
                    // copy the file content to the output
                    //
                    output_stream << is->rdbuf();
                }
            }
        }
 
        // clean up manually so we can get any exception
        // (so we avoid having exceptions gobbled by the destructor)
        output_stream.closeEntry();
        output_stream.finish();
        output_stream.close();
    }
    catch(...)
    {
        os.setstate(std::ios::failbit);
        throw;
    }
}
 
 
} // zipios namespace
 
// Local Variables:
// mode: cpp
// indent-tabs-mode: nil
// c-basic-offset: 4
// tab-width: 4
// End:
 
// vim: ts=4 sw=4 et