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

#include "zipios/zipiosexceptions.hpp"
#include "zipios/dosdatetime.hpp"

#include "zipios_common.hpp"


namespace zipios
{


namespace
{

uint32_t const      g_signature = 0x04034b50;


uint16_t const      g_trailing_data_descriptor = 1 << 3;


struct ZipLocalEntryHeader
{
    uint32_t            m_signature;
    uint16_t            m_extract_version;
    uint16_t            m_general_purpose_bitfield;
    uint16_t            m_compress_method;
    uint32_t            m_dosdatetime;
    uint32_t            m_crc_32;
    uint32_t            m_compressed_size;
    uint32_t            m_uncompressed_size;
    uint16_t            m_filename_len;
    uint16_t            m_extra_field_len;
    //uint8_t             m_filename[m_filename_len];
    //uint8_t             m_extra_field[m_extra_field_len];
};


} // no name namespace



ZipLocalEntry::ZipLocalEntry()
    : FileEntry(FilePath(""))
    //, m_extract_version(g_zip_format_version) -- auto-init
    //, m_general_purpose_bitfield(0) -- auto-init
    //, m_is_directory(false)
    //, m_compressed_size(0) -- auto-init
{
}


ZipLocalEntry::ZipLocalEntry(FileEntry const & src)
    : FileEntry(src)
    //, m_extract_version(g_zip_format_version) -- auto-init
    //, m_general_purpose_bitfield(0) -- auto-init
    , m_is_directory(src.isDirectory())
    //, m_compressed_size(0) -- auto-init
{
}


FileEntry::pointer_t ZipLocalEntry::clone() const // LCOV_EXCL_LINE
{
    // It makes sense to keep the clone() function for this class
    // but since it is internal and never allocated as is (we use
    // the ZipCentralDirectoryEntry instead) it is marked as none
    // reachable by the coverage tests
    return FileEntry::pointer_t(new ZipLocalEntry(*this)); // LCOV_EXCL_LINE
}


ZipLocalEntry::~ZipLocalEntry()
{
}


bool ZipLocalEntry::isDirectory() const
{
    return m_is_directory;
}


bool ZipLocalEntry::isEqual(FileEntry const & file_entry) const
{
    ZipLocalEntry const * const ze(dynamic_cast<ZipLocalEntry const * const>(&file_entry));
    if(ze == nullptr)
    {
        return false;
    }
    return FileEntry::isEqual(file_entry)
        && m_extract_version          == ze->m_extract_version
        && m_general_purpose_bitfield == ze->m_general_purpose_bitfield
        && m_is_directory             == ze->m_is_directory;
        //&& m_compressed_size          == ze->m_compressed_size -- ignore in comparison
}


size_t ZipLocalEntry::getCompressedSize() const
{
    return m_compressed_size;
}


size_t ZipLocalEntry::getHeaderSize() const
{
    // Note that the structure is 32 bytes because of an alignment
    // and attempting to use options to avoid the alignment would
    // not be portable so we use a hard coded value (yuck!)
    return 30 /* sizeof(ZipLocalEntryHeader) */
         + m_filename.length() + (m_is_directory ? 1 : 0)
         + m_extra_field.size();
}


void ZipLocalEntry::setCompressedSize(size_t size)
{
    m_compressed_size = size;
}


void ZipLocalEntry::setCrc(uint32_t crc)
{
    m_crc_32 = crc;
    m_has_crc_32 = true;
}


bool ZipLocalEntry::hasTrailingDataDescriptor() const
{
    return (m_general_purpose_bitfield & g_trailing_data_descriptor) != 0;
}


void ZipLocalEntry::read(std::istream& is)
{
    m_valid = false; // set to true upon successful completion.

    //    // Before reading anything we record the position in the stream
    //    // This is a field in the central directory entry, but not
    //    // in the local entry. After all, we know where we are, anyway.
    //    zlh.rel_offset_loc_head  = is.tellg() ;

    uint32_t signature;
    zipRead(is, signature);                             // 32
    if(g_signature != signature)
    {
        // put stream in error state and return
        is.setstate(std::ios::failbit);
        throw IOException("ZipLocalEntry::read() expected a signature but got some other data");
    }

    uint16_t compress_method(0);
    uint32_t dosdatetime(0);
    uint32_t compressed_size(0);
    uint32_t uncompressed_size(0);
    uint16_t filename_len(0);
    uint16_t extra_field_len(0);
    std::string filename;

    // See the ZipLocalEntryHeader for more details
    zipRead(is, m_extract_version);                 // 16
    zipRead(is, m_general_purpose_bitfield);        // 16
    zipRead(is, compress_method);                   // 16
    zipRead(is, dosdatetime);                       // 32
    zipRead(is, m_crc_32);                          // 32
    zipRead(is, compressed_size);                   // 32
    zipRead(is, uncompressed_size);                 // 32
    zipRead(is, filename_len);                      // 16
    zipRead(is, extra_field_len);                   // 16
    zipRead(is, filename, filename_len);            // string
    zipRead(is, m_extra_field, extra_field_len);    // buffer
    // the FilePath() will remove the trailing slash so make sure
    // to defined the m_is_directory ahead of time!
    m_is_directory = !filename.empty() && filename.back() == g_separator;

    m_compress_method = static_cast<StorageMethod>(compress_method);
    DOSDateTime t;
    t.setDOSDateTime(dosdatetime);
    m_unix_time = t.getUnixTimestamp();
    m_compressed_size = compressed_size;
    m_uncompressed_size = uncompressed_size;
    m_filename = FilePath(filename);

    m_valid = true;
}


void ZipLocalEntry::write(std::ostream& os)
{
    if(m_filename.length()  > 0x10000
    || m_extra_field.size() > 0x10000)
    {
        throw InvalidStateException("ZipLocalEntry::write(): file name or extra field too large to save in a Zip file.");
    }

// Solaris defines _ILP32 for 32 bit platforms
#if !defined(_ILP32)
    if(m_compressed_size   >= 0x100000000UL
    || m_uncompressed_size >= 0x100000000UL)
    {
        // these are really big files, we do not currently test such so ignore in coverage
        //
        // Note: The compressed size is known at the end, we seek back to
        //       this header and resave it with the info; thus the error
        //       is caught then if it was not out of bounds earlier.
        throw InvalidStateException("The size of this file is too large to fit in a zip archive."); // LCOV_EXCL_LINE
    }
#endif

    std::string filename(m_filename);
    if(m_is_directory)
    {
        filename += g_separator;
    }

    uint16_t compress_method(static_cast<uint8_t>(m_compress_method));
    if(m_compression_level == COMPRESSION_LEVEL_NONE)
    {
        compress_method = static_cast<uint8_t>(StorageMethod::STORED);
    }

    DOSDateTime t;
    t.setUnixTimestamp(m_unix_time);
    uint32_t dosdatetime(t.getDOSDateTime());       // type could use DOSDateTime::dosdatetime_t
    uint32_t compressed_size(m_compressed_size);
    uint32_t uncompressed_size(m_uncompressed_size);
    uint16_t filename_len(filename.length());
    uint16_t extra_field_len(m_extra_field.size());

    // See the ZipLocalEntryHeader for more details
    zipWrite(os, g_signature);                  // 32
    zipWrite(os, m_extract_version);            // 16
    zipWrite(os, m_general_purpose_bitfield);   // 16
    zipWrite(os, compress_method);              // 16
    zipWrite(os, dosdatetime);                  // 32
    zipWrite(os, m_crc_32);                     // 32
    zipWrite(os, compressed_size);              // 32
    zipWrite(os, uncompressed_size);            // 32
    zipWrite(os, filename_len);                 // 16
    zipWrite(os, extra_field_len);              // 16
    zipWrite(os, filename);                     // string
    zipWrite(os, m_extra_field);                // buffer
}


} // zipios namespace

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

// vim: ts=4 sw=4 et