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-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 "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(""))
{
}
 
 
ZipLocalEntry::ZipLocalEntry(FileEntry const & src)
    : FileEntry(src)
    , m_is_directory(src.isDirectory())
{
}
 
 
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
    // non-reachable by the coverage tests
    return std::make_shared<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(0);
    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.");
    }
 
#if INTPTR_MAX != INT32_MAX
    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 re-save 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 32 bit zip archive."); // LCOV_EXCL_LINE
    }
#endif
 
    std::string filename(m_filename);
    if(m_is_directory)
    {
        filename += g_separator;
    }
 
    std::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);
    std::uint32_t dosdatetime(t.getDOSDateTime());       // type could use DOSDateTime::dosdatetime_t
    std::uint32_t compressed_size(m_compressed_size);
    std::uint32_t uncompressed_size(m_uncompressed_size);
    std::uint16_t filename_len(filename.length());
    std::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