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); }