/+ - Name: SisuDoc Spine, Doc Reform [a part of] - Description: documents, structuring, processing, publishing, search - static content generator - Author: Ralph Amissah [ralph.amissah@gmail.com] - Copyright: (C) 2015 (continuously updated, current 2026) Ralph Amissah, All Rights Reserved. - License: AGPL 3 or later: Spine (SiSU), a framework for document structuring, publishing and search Copyright (C) Ralph Amissah This program is free software: you can redistribute it and/or modify it under the terms of the GNU AFERO General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see [https://www.gnu.org/licenses/]. If you have Internet connection, the latest version of the AGPL should be available at these locations: [https://www.fsf.org/licensing/licenses/agpl.html] [https://www.gnu.org/licenses/agpl.html] - Spine (by Doc Reform, related to SiSU) uses standard: - docReform markup syntax - standard SiSU markup syntax with modified headers and minor modifications - docReform object numbering - standard SiSU object citation numbering & system - Homepages: [https://www.sisudoc.org] [https://www.doc-reform.org] - Git [https://git.sisudoc.org/] +/ module ocda.zip; /+ ↓ enough of the zip format to find one file in a pod and read it. . Not a zip library. A pod archive holds a handful of entries, spine writes them **stored** (uncompressed) so that the outer zstd frame does the compressing once over the whole thing, and what is wanted from it here is one named entry. So: read the central directory, find the entry, return its bytes. . Deflate is *refused rather than mishandled*. Phobos can inflate, but a library that says it read an entry it in fact skipped is worse than one that says it cannot, and spine's own archives do not need it. +/ import std.algorithm : endsWith; import std.conv : to; class OcdaZipError : Exception { this(string msg) { super(msg); } } struct ZipEntry { string name; uint method; // 0 stored, 8 deflate uint compressed; uint uncompressed; uint local_offset; } /+ ↓ the entries, from the central directory at the end of the file +/ ZipEntry[] zipEntries(const(ubyte)[] bytes) { enum uint eocd_sig = 0x06054b50; enum uint cd_sig = 0x02014b50; if (bytes.length < 22) { throw new OcdaZipError("too short to be a zip archive"); } /+ ↓ the end of central directory record is last, and may be followed by a comment of up to 65535 bytes, so it is searched for backwards +/ ptrdiff_t eocd = -1; ptrdiff_t lowest = bytes.length > (22 + 65535) ? bytes.length - (22 + 65535) : 0; for (ptrdiff_t i = bytes.length - 22; i >= lowest; i--) { if (u32(bytes, i) == eocd_sig) { eocd = i; break; } } if (eocd < 0) { throw new OcdaZipError("no end of central directory record;" ~ " it does not look like a zip archive"); } uint count = u16(bytes, eocd + 10); uint offset = u32(bytes, eocd + 16); ZipEntry[] out_; size_t p = offset; foreach (_; 0 .. count) { if (p + 46 > bytes.length || u32(bytes, p) != cd_sig) { throw new OcdaZipError("central directory entry " ~ out_.length.to!string ~ " is malformed"); } ZipEntry e; e.method = u16(bytes, p + 10); e.compressed = u32(bytes, p + 20); e.uncompressed = u32(bytes, p + 24); uint name_len = u16(bytes, p + 28); uint extra_len = u16(bytes, p + 30); uint cmnt_len = u16(bytes, p + 32); e.local_offset = u32(bytes, p + 42); e.name = cast(string) bytes[p + 46 .. p + 46 + name_len].idup; out_ ~= e; p += 46 + name_len + extra_len + cmnt_len; } return out_; } /+ ↓ one entry's bytes, from its local header +/ ubyte[] zipRead(const(ubyte)[] bytes, ZipEntry e) { enum uint local_sig = 0x04034b50; size_t p = e.local_offset; if (p + 30 > bytes.length || u32(bytes, p) != local_sig) { throw new OcdaZipError(e.name ~ ": local header is malformed"); } uint name_len = u16(bytes, p + 26); uint extra_len = u16(bytes, p + 28); size_t start = p + 30 + name_len + extra_len; size_t end = start + e.compressed; if (end > bytes.length) { throw new OcdaZipError(e.name ~ ": runs past the end of the archive"); } if (e.method != 0) { throw new OcdaZipError(e.name ~ ": compression method " ~ e.method.to!string ~ "; this reader takes only stored entries," ~ " which is what spine writes"); } return bytes[start .. end].dup; } /+ ↓ the first entry whose name ends this way, or none. Used to find media/abstraction/..ssp without knowing the uid. +/ ZipEntry[] zipFindSuffix(ZipEntry[] entries, string suffix) { ZipEntry[] out_; foreach (e; entries) { if (e.name.endsWith(suffix)) { out_ ~= e; } } return out_; } private uint u16(const(ubyte)[] b, size_t i) { return cast(uint) b[i] | (cast(uint) b[i + 1] << 8); } private uint u32(const(ubyte)[] b, size_t i) { return cast(uint) b[i] | (cast(uint) b[i + 1] << 8) | (cast(uint) b[i + 2] << 16) | (cast(uint) b[i + 3] << 24); }