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-2019  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.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/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& name)
{
    // open zipfile, read 4 last bytes close file
    // create ZipFile object.
    uint32_t start_offset;
    {
        std::ifstream ifs(name, 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)
    }
    return ZipFile::pointer_t(new ZipFile(name, start_offset, 4));
}


ZipFile::ZipFile()
    //: m_vs(...) -- auto-init
{
}


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.");
    }

    // Find and read the End of Central Directory.
    ZipEndOfCentralDirectory eocd;
    {
        BackBuffer bb(zipfile, 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(zipfile, 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.totalCount(), 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] = FileEntry::pointer_t(new ZipCentralDirectoryEntry);
        m_entries[entry_num].get()->read(zipfile);
    }

    // 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(zipfile));
    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(zipfile, (*it)->getEntryOffset(), std::ios::beg);
        ZipLocalEntry zlh;
        zlh.read(zipfile);
        if(!zipfile || !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(new ZipFile(*this));
}


ZipFile::~ZipFile()
{
    close();
}


ZipFile::stream_pointer_t ZipFile::getInputStream(std::string const& entry_name, MatchPath matchpath)
{
    mustBeValid();

    FileEntry::pointer_t entry(getEntry(entry_name, matchpath));
    if(entry)
    {
        stream_pointer_t zis(new 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);
            // get an InputStream if available (i.e. directories do not have an input stream)
            if(!(*it)->isDirectory())
            {
                FileCollection::stream_pointer_t is(collection.getInputStream((*it)->getName()));
                if(is)
                {
                    output_stream << is->rdbuf();
                }
            }
        }

        // clean up mantually 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