Method Index

src/ResourceProvider.cpp:299–370

};

void ZipResourceProvider::Internal::Index() {
  const unsigned char* data = archive->data;
  const size_t size = archive->size;
  if (size < 22) {
    throw InvalidFormat("Invalid zip archive: " + archive->fileName);
  }

  const size_t maxCommentSize = 65535;
  const size_t searchStart =
      size > maxCommentSize + 22 ? size - maxCommentSize - 22 : 0;
  size_t eocdOffset = std::string::npos;
  for (size_t pos = size - 22;; pos--) {
    if (data[pos] == 0x50 && data[pos + 1] == 0x4b && data[pos + 2] == 0x05 &&
        data[pos + 3] == 0x06) {
      eocdOffset = pos;
      break;
    }
    if (pos == searchStart) {
      break;
    }
  }
  if (eocdOffset == std::string::npos) {
    throw InvalidFormat("Invalid zip archive: " + archive->fileName);
  }

  const uint16_t entryCount = ReadLe16(&data[eocdOffset + 10]);
  const uint32_t centralDirectorySize = ReadLe32(&data[eocdOffset + 12]);
  const uint32_t centralDirectoryOffset = ReadLe32(&data[eocdOffset + 16]);
  if (centralDirectoryOffset > size ||
      centralDirectorySize > size - centralDirectoryOffset) {
    throw InvalidFormat("Invalid zip central directory: " + archive->fileName);
  }

  size_t pos = centralDirectoryOffset;
  for (uint16_t i = 0; i < entryCount; i++) {
    if (pos + 46 > size || ReadLe32(&data[pos]) != 0x02014b50) {
      throw InvalidFormat("Invalid zip central directory: " + archive->fileName);
    }
    const uint16_t method = ReadLe16(&data[pos + 10]);
    const uint32_t compressedSize = ReadLe32(&data[pos + 20]);
    const uint32_t uncompressedSize = ReadLe32(&data[pos + 24]);
    const uint16_t fileNameLength = ReadLe16(&data[pos + 28]);
    const uint16_t extraLength = ReadLe16(&data[pos + 30]);
    const uint16_t commentLength = ReadLe16(&data[pos + 32]);
    const uint32_t localHeaderOffset = ReadLe32(&data[pos + 42]);
    const size_t next = pos + 46 + fileNameLength + extraLength + commentLength;
    if (next > size) {
      throw InvalidFormat("Invalid zip central directory: " + archive->fileName);
    }
    const std::string name(
        reinterpret_cast<const char*>(&data[pos + 46]), fileNameLength);
    const std::string normalized = NormalizeResourceName(name);
    if (!IsAbsolutePath(name) && !normalized.empty() &&
        normalized.back() != '/' && IsSafeZipResourceName(normalized)) {
      if (localHeaderOffset + 30 > size ||
          ReadLe32(&data[localHeaderOffset]) != 0x04034b50) {
        throw InvalidFormat("Invalid zip local header: " + archive->fileName);
      }