1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
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_;
}
|