Functions
bool	readArchiveInfo (ZipEntry *entry)

void	reportZlibError (std::string &text, int err)

std::string	getZlibError (int err)

uint8_t *	readCompressedFile (ZipLocalHeader *header)

uint8_t *	readFile (ZipLocalHeader *header)

void	reportZlibError (const std::string &text, const int err)

uint8_t *	readCompressedFile (const ZipLocalHeader *const header)

const uint8_t *	readFile (const ZipLocalHeader *const header)

Function Documentation

◆ getZlibError()

std::string VirtFs::ZipReader::getZlibError ( int err )

Definition at line 232 of file zipreader.cpp.

     {
         switch (err)
         {
             case Z_OK:
                 return std::string();
             default:
                 return "unknown zlib error";
         }
     }

Referenced by reportZlibError().

◆ readArchiveInfo()

bool VirtFs::ZipReader::readArchiveInfo ( ZipEntry * entry )

Definition at line 75 of file zipreader.cpp.

     {
         if (entry == nullptr)
         {
             reportAlways("Entry is null.")
             return false;
         }
         const std::string archiveName = entry->root;
         STD_VECTOR<ZipLocalHeader*> &restrict headers = entry->mHeaders;
         STD_VECTOR<std::string> &restrict dirs = entry->mDirs;
         FILE *restrict const arcFile = fopen(archiveName.c_str(),
             "rb");
         if (arcFile == nullptr)
         {
             reportAlways("Can't open zip file %s",
                 archiveName.c_str())
             return false;
         }
         uint8_t *const buf = new uint8_t[65535 + 10];
         uint16_t val16 = 0U;
         uint16_t method = 0U;
         ZipLocalHeader *header = nullptr;
  
 #ifdef DEBUG_ZIP
         logger->log("Read archive: %s", archiveName.c_str());
 #endif  // DEBUG_ZIP
  
         // format source https://en.wikipedia.org/wiki/Zip_%28file_format%29
         while (feof(arcFile) == 0)
         {
             size_t cnt = 0U;
             // file header pointer on 0
             // read file header signature
             readVal(buf, 4, "zip file header")  // + 4
             // pointer on 4
  
             if (buf[0] == 0x50 &&
                 buf[1] == 0x4B &&
                 buf[2] == 0x03 &&
                 buf[3] == 0x04)
             {   // local file header
                 header = new ZipLocalHeader;
                 header->zipEntry = entry;
                 // skip useless fields
                 fseek(arcFile, 4, SEEK_CUR);  // + 4
                 // file header pointer on 8
                 readVal(&method, 2, "compression method")  // + 2
                 swapVal16(method)
                 header->compressed = (method != 0);
                 // file header pointer on 10
                 fseek(arcFile, 8, SEEK_CUR);  // + 8
                 // file header pointer on 18
                 readVal(&header->compressSize, 4,
                     "zip compressed size")  // + 4
                 swapVal32(header->compressSize)
                 // file header pointer on 22
                 readVal(&header->uncompressSize, 4,
                     "zip uncompressed size")  // + 4
                 swapVal32(header->uncompressSize)
                 // file header pointer on 26
                 readVal(&val16, 2, "file name length")  // + 2
                 swapVal16(val16)
                 // file header pointer on 28
                 const uint32_t fileNameLen = CAST_U32(val16);
                 if (fileNameLen > 1000)
                 {
                     reportAlways("Error too long file name in file %s",
                         archiveName.c_str())
                     delete header;
                     delete [] buf;
                     fclose(arcFile);
                     return false;
                 }
                 readVal(&val16, 2, "extra field length")  // + 2
                 swapVal16(val16)
                 // file header pointer on 30
                 const uint32_t extraFieldLen = CAST_U32(val16);
                 readVal(buf, fileNameLen, "file name")
                 // file header pointer on 30 + fileNameLen
                 buf[fileNameLen] = 0;
                 header->fileName = std::string(
                     reinterpret_cast<char*>(buf));
                 prepareFsPath(header->fileName);
                 header->dataOffset = CAST_S32(ftell(arcFile) + extraFieldLen);
                 fseek(arcFile, extraFieldLen + header->compressSize, SEEK_CUR);
                 // pointer on 30 + fileNameLen + extraFieldLen + compressSize
                 if (findLast(header->fileName, dirSeparator) == false)
                 {
                     headers.push_back(header);
 #ifdef DEBUG_ZIP
                     logger->log(" file name: %s",
                         header->fileName.c_str());
                     logger->log(" compression method: %u",
                         CAST_U32(method));
                     logger->log(" compressed size: %u",
                         header->compressSize);
                     logger->log(" uncompressed size: %u",
                         header->uncompressSize);
 #endif  // DEBUG_ZIP
                 }
                 else
                 {
 #ifdef DEBUG_ZIP
                     logger->log(" dir name: %s",
                         header->fileName.c_str());
 #endif  // DEBUG_ZIP
                     dirs.push_back(header->fileName);
                     delete2(header)
                 }
             }
             else if (buf[0] == 0x50 &&
                      buf[1] == 0x4B &&
                      buf[2] == 0x01 &&
                      buf[3] == 0x02)
             {   // central directory file header
                 // !!! This is quick way for read zip archives. !!!
                 // !!! It ignore modified files in archive. !!!
                 // ignoring central directory entries
                 break;
             }
             else if (buf[0] == 0x50 &&
                      buf[1] == 0x4B &&
                      buf[2] == 0x05 &&
                      buf[3] == 0x06)
             {   // end of central directory
                 // !!! This is quick way for read zip archives. !!!
                 // !!! It ignore modified files in archive. !!!
                 // ignoring end of central directory
                 break;
             }
             else
             {
                 reportAlways("Error in header signature (0x%02x%02x%02x%02x)"
                     " in file %s",
                     buf[0],
                     buf[1],
                     buf[2],
                     buf[3],
                     archiveName.c_str())
                 delete [] buf;
                 fclose(arcFile);
                 return false;
             }
         }
         delete [] buf;
         fclose(arcFile);
         return true;
     }

References CAST_S32, CAST_U32, VirtFs::ZipLocalHeader::compressed, VirtFs::ZipLocalHeader::compressSize, VirtFs::ZipLocalHeader::dataOffset, delete2, Actions::dirs(), dirSeparator, VirtFs::ZipLocalHeader::fileName, findLast(), Logger::log(), logger, VirtFs::ZipEntry::mDirs, VirtFs::ZipEntry::mHeaders, prepareFsPath(), readVal, reportAlways, restrict, VirtFs::FsEntry::root, swapVal16, swapVal32, VirtFs::ZipLocalHeader::uncompressSize, and VirtFs::ZipLocalHeader::zipEntry.

Referenced by VirtFs::mountZip(), and VirtFs::mountZip2().

◆ readCompressedFile() [1/2]

uint8_t* VirtFs::ZipReader::readCompressedFile ( const ZipLocalHeader *const header )

◆ readCompressedFile() [2/2]

uint8_t* VirtFs::ZipReader::readCompressedFile ( ZipLocalHeader * header )

Definition at line 243 of file zipreader.cpp.

     {
         if (header == nullptr)
         {
             reportAlways("ZipReader::readCompressedFile: header is null")
             return nullptr;
         }
         FILE *restrict const arcFile = fopen(
             header->zipEntry->root.c_str(),
             "rb");
         if (arcFile == nullptr)
         {
             reportAlways("Can't open zip file %s",
                 header->zipEntry->root.c_str())
             return nullptr;
         }
  
         fseek(arcFile, header->dataOffset, SEEK_SET);
         const uint32_t compressSize = header->compressSize;
         uint8_t *const buf = new uint8_t[compressSize];
         if (fread(static_cast<void*>(buf), 1, compressSize, arcFile) !=
             compressSize)
         {
             reportAlways("Read zip compressed file error from archive: %s",
                 header->zipEntry->root.c_str())
             fclose(arcFile);
             delete [] buf;
             return nullptr;
         }
         fclose(arcFile);
         return buf;
     }

References reportAlways, and restrict.

Referenced by readFile().

◆ readFile() [1/2]

const uint8_t* VirtFs::ZipReader::readFile ( const ZipLocalHeader *const header )

◆ readFile() [2/2]

uint8_t* VirtFs::ZipReader::readFile ( ZipLocalHeader * header )

Definition at line 276 of file zipreader.cpp.

     {
         if (header == nullptr)
         {
             reportAlways("Open zip file error. header is null.")
             return nullptr;
         }
         uint8_t *restrict const in = readCompressedFile(header);
         if (in == nullptr)
             return nullptr;
         if (header->compressed == false)
             return in;  //  return as is if data not compressed
         const size_t outSize = header->uncompressSize;
         uint8_t *restrict const out = new uint8_t[outSize];
         if (outSize == 0)
         {
             delete [] in;
             return out;
         }
  
         z_stream strm;
         strm.zalloc = nullptr;
         strm.zfree = nullptr;
         strm.opaque = nullptr;
         strm.next_in = in;
         strm.avail_in = header->compressSize;
         strm.next_out = out;
         strm.avail_out = CAST_U32(outSize);
  
 PRAGMACLANG6GCC(GCC diagnostic push)
 PRAGMACLANG6GCC(GCC diagnostic ignored "-Wold-style-cast")
         int ret = inflateInit2(&strm, -MAX_WBITS);
 PRAGMACLANG6GCC(GCC diagnostic pop)
  
         if (ret != Z_OK)
         {
             reportZlibError(header->zipEntry->root, ret);
             delete [] in;
             delete [] out;
             return nullptr;
         }
         ret = inflate(&strm, Z_FINISH);
 //        ret = inflate(&strm, Z_SYNC_FLUSH);
         if (ret != Z_OK &&
             ret != Z_STREAM_END)
         {
             reportZlibError("file decompression error",
                 ret);
             inflateEnd(&strm);
             delete [] in;
             delete [] out;
             return nullptr;
         }
         inflateEnd(&strm);
         delete [] in;
         return out;
     }

References CAST_U32, PRAGMACLANG6GCC, readCompressedFile(), reportAlways, reportZlibError(), and restrict.

Referenced by VirtFs::FsZip::loadFile(), and VirtFs::FsZip::openRead().

◆ reportZlibError() [1/2]

void VirtFs::ZipReader::reportZlibError	(	const std::string &	text,
		const int	err
	)

◆ reportZlibError() [2/2]

void VirtFs::ZipReader::reportZlibError	(	std::string &	text,
		int	err
	)

Definition at line 224 of file zipreader.cpp.

     {
         reportAlways("Zlib error: '%s' in %s",
             text.c_str(),
             getZlibError(err).c_str())
     }

References getZlibError(), and reportAlways.