/+ - 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.zstd; /+ ↓ libzstd, declared rather than bound. . A .sisupod is one zstd frame wrapping a zip archive, so reading one needs exactly two things from the library: is this a frame, and what is in it. Both are declared here and the C library is linked, which is the same arrangement ocda.sqlite uses: no vendored tree, no generated header, and the prototypes say what is being called. +/ extern (C) @nogc nothrow private { size_t ZSTD_decompress(void* dst, size_t dstCapacity, const(void)* src, size_t compressedSize); ulong ZSTD_getFrameContentSize(const(void)* src, size_t srcSize); uint ZSTD_isError(size_t code); const(char)* ZSTD_getErrorName(size_t code); } /+ ↓ the two values ZSTD_getFrameContentSize returns in place of a size +/ private enum ulong contentSizeUnknown = ulong.max; private enum ulong contentSizeError = ulong.max - 1; /+ ↓ the magic number of a zstd frame, little endian 0xFD2FB528 +/ private static immutable ubyte[4] zstd_magic = [0x28, 0xB5, 0x2F, 0xFD]; class OcdaZstdError : Exception { this(string msg) { super(msg); } } /+ ↓ does this begin with a zstd frame? Asked of the bytes rather than of the filename, because what is inside decides how a thing is opened. A .sisupod is a frame; a .zip published before spine wrapped them is not, and both are read. +/ bool zstdIsFrame(const(ubyte)[] bytes) { if (bytes.length < zstd_magic.length) { return false; } foreach (i, b; zstd_magic) { if (bytes[i] != b) { return false; } } return true; } /+ ↓ one frame in, its contents out. max_size is a refusal rather than a buffer size: a frame declares how much it expands to, and a frame that claims more than the caller is willing to hold is not decompressed at all. A reader of an artefact it did not make wants that limit. +/ ubyte[] zstdDecompress(const(ubyte)[] bytes, size_t max_size) { if (!zstdIsFrame(bytes)) { throw new OcdaZstdError("not a zstd frame"); } ulong declared = ZSTD_getFrameContentSize(bytes.ptr, bytes.length); if (declared == contentSizeError) { throw new OcdaZstdError("zstd frame: could not read its content size"); } if (declared == contentSizeUnknown) { throw new OcdaZstdError("zstd frame declares no content size;" ~ " this reader takes only frames that do"); } if (declared > max_size) { import std.conv : to; throw new OcdaZstdError("zstd frame expands to " ~ declared.to!string ~ " bytes, over the " ~ max_size.to!string ~ " byte limit"); } auto out_ = new ubyte[](cast(size_t) declared); size_t got = ZSTD_decompress(out_.ptr, out_.length, bytes.ptr, bytes.length); if (ZSTD_isError(got)) { import std.string : fromStringz; throw new OcdaZstdError("zstd: " ~ ZSTD_getErrorName(got).fromStringz.idup); } if (got != declared) { throw new OcdaZstdError("zstd frame expanded to a different size" ~ " than it declared"); } return out_; }