openscad-cpp-evaluator 1.49.1__tar.gz → 1.49.2__tar.gz

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.1
+Version: 1.49.2
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.49.1"
+version = "1.49.2"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.2}/src/zip_stored.cpp

@@ -52,6 +52,7 @@ uint16_t readU16(const uint8_t* p) { return static_cast<uint16_t>(p[0] | (p[1] <
 uint32_t readU32(const uint8_t* p) {
     return static_cast<uint32_t>(p[0] | (p[1] << 8) | (p[2] << 16) | (static_cast<uint32_t>(p[3]) << 24));
 }
+uint64_t readU64(const uint8_t* p) { return readU32(p) | (static_cast<uint64_t>(readU32(p + 4)) << 32); }
 
 // A fixed, valid DOS date/time (2020-01-01 00:00:00) -- the exact instant
 // doesn't matter for a generated 3MF, just that it's a well-formed DOS
@@ -156,9 +157,9 @@ void writeZipEntries(const std::string& path, const std::vector<PlacedEntry>& en
 struct CentralDirEntry {
     std::string name;
     uint16_t method;
-    uint32_t compressedSize;
-    uint32_t uncompressedSize;
-    uint32_t localHeaderOffset;
+    uint64_t compressedSize;
+    uint64_t uncompressedSize;
+    uint64_t localHeaderOffset;
 };
 
 std::vector<uint8_t> readWholeFile(const std::string& path) {
@@ -189,25 +190,57 @@ std::vector<CentralDirEntry> parseCentralDirectory(const std::vector<uint8_t>& f
     }
     if (eocd == std::string::npos) throw std::runtime_error("'" + path + "' is not a valid ZIP archive (no EOCD)");
 
-    const uint16_t entryCount = readU16(&file[eocd + 10]);
-    const uint32_t cdOffset = readU32(&file[eocd + 16]);
+    uint64_t entryCount = readU16(&file[eocd + 10]);
+    uint64_t cdOffset = readU32(&file[eocd + 16]);
+    // ZIP64: a field too big for the classic record is all ones, and the
+    // real value is in the ZIP64 end record the locator just before it
+    // points to. lib3mf -- behind OpenSCAD's and most slicers' 3MF export --
+    // writes one even for a tiny file, so without this nearly every 3MF
+    // read as "corrupt central directory offset" (BelfrySCAD #800).
+    if ((entryCount == 0xFFFFu || cdOffset == 0xFFFFFFFFu) && eocd >= 20 &&
+        readU32(&file[eocd - 20]) == 0x07064b50u) {
+        const uint64_t z64 = readU64(&file[eocd - 20 + 8]);
+        if (z64 + 56 > file.size() || readU32(&file[z64]) != 0x06064b50u) {
+            throw std::runtime_error("'" + path + "': corrupt ZIP64 end of central directory");
+        }
+        entryCount = readU64(&file[z64 + 32]);
+        cdOffset = readU64(&file[z64 + 48]);
+    }
     if (cdOffset >= file.size()) throw std::runtime_error("'" + path + "': corrupt central directory offset");
 
     std::vector<CentralDirEntry> entries;
     size_t p = cdOffset;
-    for (uint16_t i = 0; i < entryCount; ++i) {
+    for (uint64_t i = 0; i < entryCount; ++i) {
         if (p + 46 > file.size() || readU32(&file[p]) != 0x02014b50u) {
             throw std::runtime_error("'" + path + "': corrupt central directory entry");
         }
         const uint16_t method = readU16(&file[p + 10]);
-        const uint32_t compressedSize = readU32(&file[p + 20]);
-        const uint32_t uncompressedSize = readU32(&file[p + 24]);
+        uint64_t compressedSize = readU32(&file[p + 20]);
+        uint64_t uncompressedSize = readU32(&file[p + 24]);
         const uint16_t nameLen = readU16(&file[p + 28]);
         const uint16_t extraLen = readU16(&file[p + 30]);
         const uint16_t commentLen = readU16(&file[p + 32]);
-        const uint32_t localHeaderOffset = readU32(&file[p + 42]);
-        if (p + 46 + nameLen > file.size()) throw std::runtime_error("'" + path + "': corrupt central directory entry name");
+        uint64_t localHeaderOffset = readU32(&file[p + 42]);
+        if (p + 46 + nameLen + extraLen > file.size()) throw std::runtime_error("'" + path + "': corrupt central directory entry name");
         std::string name(reinterpret_cast<const char*>(&file[p + 46]), nameLen);
+        // A ZIP64 extra field (id 1) holds, in this order, only the values
+        // whose 32-bit field above is all ones.
+        for (size_t x = p + 46 + nameLen, xEnd = x + extraLen; x + 4 <= xEnd;) {
+            const uint16_t id = readU16(&file[x]);
+            const uint16_t len = readU16(&file[x + 2]);
+            size_t q = x + 4;
+            const size_t qEnd = std::min<size_t>(q + len, xEnd);
+            if (id == 0x0001u) {
+                for (uint64_t* v : {&uncompressedSize, &compressedSize, &localHeaderOffset}) {
+                    if (*v != 0xFFFFFFFFu) continue;
+                    if (q + 8 > qEnd) throw std::runtime_error("'" + path + "': corrupt ZIP64 extra field");
+                    *v = readU64(&file[q]);
+                    q += 8;
+                }
+                break;
+            }
+            x = q + len;
+        }
         entries.push_back(CentralDirEntry{std::move(name), method, compressedSize, uncompressedSize, localHeaderOffset});
         p += 46 + nameLen + extraLen + commentLen;
     }

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.2}/tests/test_zip_stored.cpp

@@ -253,3 +253,90 @@ TEST(ZipStored, StoredZipWritesMethod0) {
     EXPECT_EQ(centralDirMethodBySuffix(path.string(), "3dmodel.model"), 0);
     std::filesystem::remove(path);
 }
+
+TEST(ZipStored, ReadsZip64Archive) {
+    // The shape lib3mf writes (BelfrySCAD #800): every size and offset in the
+    // central directory and classic end record all ones, the real values in a
+    // ZIP64 extra field and a ZIP64 end record found through its locator.
+    const std::string name = "3D/3dmodel.model";
+    const std::string content = "zip64 payload";
+    std::vector<uint8_t> out;
+
+    putLE<uint32_t>(out, 0x04034b50u);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, static_cast<uint32_t>(content.size()));
+    putLE<uint32_t>(out, static_cast<uint32_t>(content.size()));
+    putLE<uint16_t>(out, static_cast<uint16_t>(name.size()));
+    putLE<uint16_t>(out, 0);
+    out.insert(out.end(), name.begin(), name.end());
+    out.insert(out.end(), content.begin(), content.end());
+
+    const uint64_t cdStart = out.size();
+    putLE<uint32_t>(out, 0x02014b50u);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint16_t>(out, static_cast<uint16_t>(name.size()));
+    putLE<uint16_t>(out, 4 + 24 + 4 + 4); // an unrelated field first, then ZIP64
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    out.insert(out.end(), name.begin(), name.end());
+    putLE<uint16_t>(out, 0x5455);
+    putLE<uint16_t>(out, 4);
+    putLE<uint32_t>(out, 0);
+    putLE<uint16_t>(out, 0x0001);
+    putLE<uint16_t>(out, 24);
+    putLE<uint64_t>(out, content.size());
+    putLE<uint64_t>(out, content.size());
+    putLE<uint64_t>(out, 0);
+    const uint64_t cdSize = out.size() - cdStart;
+
+    const uint64_t z64 = out.size();
+    putLE<uint32_t>(out, 0x06064b50u);
+    putLE<uint64_t>(out, 44);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 45);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint64_t>(out, 1);
+    putLE<uint64_t>(out, 1);
+    putLE<uint64_t>(out, cdSize);
+    putLE<uint64_t>(out, cdStart);
+
+    putLE<uint32_t>(out, 0x07064b50u);
+    putLE<uint32_t>(out, 0);
+    putLE<uint64_t>(out, z64);
+    putLE<uint32_t>(out, 1);
+
+    putLE<uint32_t>(out, 0x06054b50u);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0xFFFF);
+    putLE<uint16_t>(out, 0xFFFF);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint16_t>(out, 0);
+
+    const auto path = tempPath("zip64.zip");
+    {
+        std::ofstream f(path, std::ios::binary);
+        f.write(reinterpret_cast<const char*>(out.data()), static_cast<std::streamsize>(out.size()));
+    }
+    const std::vector<uint8_t> read = readStoredZipEntry(path.string(), name);
+    EXPECT_EQ(std::string(read.begin(), read.end()), content);
+    std::filesystem::remove(path);
+}

{openscad_cpp_evaluator-1.49.1 → openscad_cpp_evaluator-1.49.2}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.49.1"
+version = "1.49.2"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },