summaryrefslogtreecommitdiffhomepage
path: root/dlang/src/ocda/zstd.d
blob: 3793f0920871c35ce398a84e0f2802f5ebc6a3bd (plain)
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
/+
- 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_;
}