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
|
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/<uid>.<lang>.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);
}
|