summaryrefslogtreecommitdiffhomepage
path: root/dlang/src/ocda/zip.d
blob: 9dff6f463bdb55cffddddc49241fd297f7a150a8 (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
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);
}