master
1//! The .ZIP File Format Specification is found here:
2//! https://pkwaredownloads.blob.core.windows.net/pem/APPNOTE.txt
3//!
4//! Note that this file uses the abbreviation "cd" for "central directory"
5
6const builtin = @import("builtin");
7const std = @import("std");
8const File = std.fs.File;
9const is_le = builtin.target.cpu.arch.endian() == .little;
10const Writer = std.Io.Writer;
11const Reader = std.Io.Reader;
12const flate = std.compress.flate;
13
14pub const CompressionMethod = enum(u16) {
15 store = 0,
16 deflate = 8,
17 _,
18};
19
20pub const central_file_header_sig = [4]u8{ 'P', 'K', 1, 2 };
21pub const local_file_header_sig = [4]u8{ 'P', 'K', 3, 4 };
22pub const end_record_sig = [4]u8{ 'P', 'K', 5, 6 };
23pub const end_record64_sig = [4]u8{ 'P', 'K', 6, 6 };
24pub const end_locator64_sig = [4]u8{ 'P', 'K', 6, 7 };
25pub const ExtraHeader = enum(u16) {
26 zip64_info = 0x1,
27 _,
28};
29
30const GeneralPurposeFlags = packed struct(u16) {
31 encrypted: bool,
32 _: u15,
33};
34
35pub const LocalFileHeader = extern struct {
36 signature: [4]u8 align(1),
37 version_needed_to_extract: u16 align(1),
38 flags: GeneralPurposeFlags align(1),
39 compression_method: CompressionMethod align(1),
40 last_modification_time: u16 align(1),
41 last_modification_date: u16 align(1),
42 crc32: u32 align(1),
43 compressed_size: u32 align(1),
44 uncompressed_size: u32 align(1),
45 filename_len: u16 align(1),
46 extra_len: u16 align(1),
47};
48
49pub const CentralDirectoryFileHeader = extern struct {
50 signature: [4]u8 align(1),
51 version_made_by: u16 align(1),
52 version_needed_to_extract: u16 align(1),
53 flags: GeneralPurposeFlags align(1),
54 compression_method: CompressionMethod align(1),
55 last_modification_time: u16 align(1),
56 last_modification_date: u16 align(1),
57 crc32: u32 align(1),
58 compressed_size: u32 align(1),
59 uncompressed_size: u32 align(1),
60 filename_len: u16 align(1),
61 extra_len: u16 align(1),
62 comment_len: u16 align(1),
63 disk_number: u16 align(1),
64 internal_file_attributes: u16 align(1),
65 external_file_attributes: u32 align(1),
66 local_file_header_offset: u32 align(1),
67};
68
69pub const EndRecord64 = extern struct {
70 signature: [4]u8 align(1),
71 end_record_size: u64 align(1),
72 version_made_by: u16 align(1),
73 version_needed_to_extract: u16 align(1),
74 disk_number: u32 align(1),
75 central_directory_disk_number: u32 align(1),
76 record_count_disk: u64 align(1),
77 record_count_total: u64 align(1),
78 central_directory_size: u64 align(1),
79 central_directory_offset: u64 align(1),
80};
81
82pub const EndLocator64 = extern struct {
83 signature: [4]u8 align(1),
84 zip64_disk_count: u32 align(1),
85 record_file_offset: u64 align(1),
86 total_disk_count: u32 align(1),
87};
88
89pub const EndRecord = extern struct {
90 signature: [4]u8 align(1),
91 disk_number: u16 align(1),
92 central_directory_disk_number: u16 align(1),
93 record_count_disk: u16 align(1),
94 record_count_total: u16 align(1),
95 central_directory_size: u32 align(1),
96 central_directory_offset: u32 align(1),
97 comment_len: u16 align(1),
98
99 pub fn need_zip64(self: EndRecord) bool {
100 return isMaxInt(self.record_count_disk) or
101 isMaxInt(self.record_count_total) or
102 isMaxInt(self.central_directory_size) or
103 isMaxInt(self.central_directory_offset);
104 }
105
106 pub const FindBufferError = error{ ZipNoEndRecord, ZipTruncated };
107
108 /// TODO audit this logic
109 pub fn findBuffer(buffer: []const u8) FindBufferError!EndRecord {
110 const pos = std.mem.lastIndexOf(u8, buffer, &end_record_sig) orelse return error.ZipNoEndRecord;
111 if (pos + @sizeOf(EndRecord) > buffer.len) return error.EndOfStream;
112 const record_ptr: *EndRecord = @ptrCast(buffer[pos..][0..@sizeOf(EndRecord)]);
113 var record = record_ptr.*;
114 if (!is_le) std.mem.byteSwapAllFields(EndRecord, &record);
115 return record;
116 }
117
118 pub const FindFileError = File.Reader.SizeError || File.SeekError || File.ReadError || error{
119 ZipNoEndRecord,
120 EndOfStream,
121 ReadFailed,
122 };
123
124 pub fn findFile(fr: *File.Reader) FindFileError!EndRecord {
125 const end_pos = try fr.getSize();
126
127 var buf: [@sizeOf(EndRecord) + std.math.maxInt(u16)]u8 = undefined;
128 const record_len_max = @min(end_pos, buf.len);
129 var loaded_len: u32 = 0;
130 var comment_len: u16 = 0;
131 while (true) {
132 const record_len: u32 = @as(u32, comment_len) + @sizeOf(EndRecord);
133 if (record_len > record_len_max)
134 return error.ZipNoEndRecord;
135
136 if (record_len > loaded_len) {
137 const new_loaded_len = @min(loaded_len + 300, record_len_max);
138 const read_len = new_loaded_len - loaded_len;
139
140 try fr.seekTo(end_pos - @as(u64, new_loaded_len));
141 const read_buf: []u8 = buf[buf.len - new_loaded_len ..][0..read_len];
142 fr.interface.readSliceAll(read_buf) catch |err| switch (err) {
143 error.ReadFailed => return fr.err.?,
144 error.EndOfStream => return error.EndOfStream,
145 };
146 loaded_len = new_loaded_len;
147 }
148
149 const record_bytes = buf[buf.len - record_len ..][0..@sizeOf(EndRecord)];
150 if (std.mem.eql(u8, record_bytes[0..4], &end_record_sig) and
151 std.mem.readInt(u16, record_bytes[20..22], .little) == comment_len)
152 {
153 const record: *align(1) EndRecord = @ptrCast(record_bytes.ptr);
154 if (!is_le) std.mem.byteSwapAllFields(EndRecord, record);
155 return record.*;
156 }
157
158 if (comment_len == std.math.maxInt(u16))
159 return error.ZipNoEndRecord;
160 comment_len += 1;
161 }
162 }
163};
164
165pub const Decompress = struct {
166 interface: Reader,
167 state: union {
168 inflate: flate.Decompress,
169 store: *Reader,
170 },
171
172 pub fn init(reader: *Reader, method: CompressionMethod, buffer: []u8) Reader {
173 return switch (method) {
174 .store => .{
175 .state = .{ .store = reader },
176 .interface = .{
177 .context = undefined,
178 .vtable = &.{ .stream = streamStore },
179 .buffer = buffer,
180 .end = 0,
181 .seek = 0,
182 },
183 },
184 .deflate => .{
185 .state = .{ .inflate = .init(reader, .raw) },
186 .interface = .{
187 .context = undefined,
188 .vtable = &.{ .stream = streamDeflate },
189 .buffer = buffer,
190 .end = 0,
191 .seek = 0,
192 },
193 },
194 else => unreachable,
195 };
196 }
197
198 fn streamStore(r: *Reader, w: *Writer, limit: std.Io.Limit) Reader.StreamError!usize {
199 const d: *Decompress = @fieldParentPtr("interface", r);
200 return d.store.read(w, limit);
201 }
202
203 fn streamDeflate(r: *Reader, w: *Writer, limit: std.Io.Limit) Reader.StreamError!usize {
204 const d: *Decompress = @fieldParentPtr("interface", r);
205 return flate.Decompress.read(&d.inflate, w, limit);
206 }
207};
208
209fn isBadFilename(filename: []const u8) bool {
210 if (filename.len == 0 or filename[0] == '/')
211 return true;
212
213 var it = std.mem.splitScalar(u8, filename, '/');
214 while (it.next()) |part| {
215 if (std.mem.eql(u8, part, ".."))
216 return true;
217 }
218
219 return false;
220}
221
222fn isMaxInt(uint: anytype) bool {
223 return uint == std.math.maxInt(@TypeOf(uint));
224}
225
226const FileExtents = struct {
227 uncompressed_size: u64,
228 compressed_size: u64,
229 local_file_header_offset: u64,
230};
231
232fn readZip64FileExtents(comptime T: type, header: T, extents: *FileExtents, data: []u8) !void {
233 var data_offset: usize = 0;
234 if (isMaxInt(header.uncompressed_size)) {
235 if (data_offset + 8 > data.len)
236 return error.ZipBadCd64Size;
237 extents.uncompressed_size = std.mem.readInt(u64, data[data_offset..][0..8], .little);
238 data_offset += 8;
239 }
240 if (isMaxInt(header.compressed_size)) {
241 if (data_offset + 8 > data.len)
242 return error.ZipBadCd64Size;
243 extents.compressed_size = std.mem.readInt(u64, data[data_offset..][0..8], .little);
244 data_offset += 8;
245 }
246
247 switch (T) {
248 CentralDirectoryFileHeader => {
249 if (isMaxInt(header.local_file_header_offset)) {
250 if (data_offset + 8 > data.len)
251 return error.ZipBadCd64Size;
252 extents.local_file_header_offset = std.mem.readInt(u64, data[data_offset..][0..8], .little);
253 data_offset += 8;
254 }
255 if (isMaxInt(header.disk_number)) {
256 if (data_offset + 4 > data.len)
257 return error.ZipInvalid;
258 const disk_number = std.mem.readInt(u32, data[data_offset..][0..4], .little);
259 if (disk_number != 0)
260 return error.ZipMultiDiskUnsupported;
261 data_offset += 4;
262 }
263 if (data_offset > data.len)
264 return error.ZipBadCd64Size;
265 },
266 else => {},
267 }
268}
269
270pub const Iterator = struct {
271 input: *File.Reader,
272
273 cd_record_count: u64,
274 cd_zip_offset: u64,
275 cd_size: u64,
276
277 cd_record_index: u64 = 0,
278 cd_record_offset: u64 = 0,
279
280 pub fn init(input: *File.Reader) !Iterator {
281 const end_record = try EndRecord.findFile(input);
282
283 if (!isMaxInt(end_record.record_count_disk) and end_record.record_count_disk > end_record.record_count_total)
284 return error.ZipDiskRecordCountTooLarge;
285
286 if (end_record.disk_number != 0 or end_record.central_directory_disk_number != 0)
287 return error.ZipMultiDiskUnsupported;
288
289 {
290 const counts_valid = !isMaxInt(end_record.record_count_disk) and !isMaxInt(end_record.record_count_total);
291 if (counts_valid and end_record.record_count_disk != end_record.record_count_total)
292 return error.ZipMultiDiskUnsupported;
293 }
294
295 var result: Iterator = .{
296 .input = input,
297 .cd_record_count = end_record.record_count_total,
298 .cd_zip_offset = end_record.central_directory_offset,
299 .cd_size = end_record.central_directory_size,
300 };
301 if (!end_record.need_zip64()) return result;
302
303 const locator_end_offset: u64 = @as(u64, end_record.comment_len) + @sizeOf(EndRecord) + @sizeOf(EndLocator64);
304 const stream_len = try input.getSize();
305
306 if (locator_end_offset > stream_len)
307 return error.ZipTruncated;
308 try input.seekTo(stream_len - locator_end_offset);
309 const locator = input.interface.takeStruct(EndLocator64, .little) catch |err| switch (err) {
310 error.ReadFailed => return input.err.?,
311 error.EndOfStream => return error.EndOfStream,
312 };
313 if (!std.mem.eql(u8, &locator.signature, &end_locator64_sig))
314 return error.ZipBadLocatorSig;
315 if (locator.zip64_disk_count != 0)
316 return error.ZipUnsupportedZip64DiskCount;
317 if (locator.total_disk_count != 1)
318 return error.ZipMultiDiskUnsupported;
319
320 try input.seekTo(locator.record_file_offset);
321
322 const record64 = input.interface.takeStruct(EndRecord64, .little) catch |err| switch (err) {
323 error.ReadFailed => return input.err.?,
324 error.EndOfStream => return error.EndOfStream,
325 };
326
327 if (!std.mem.eql(u8, &record64.signature, &end_record64_sig))
328 return error.ZipBadEndRecord64Sig;
329
330 if (record64.end_record_size < @sizeOf(EndRecord64) - 12)
331 return error.ZipEndRecord64SizeTooSmall;
332 if (record64.end_record_size > @sizeOf(EndRecord64) - 12)
333 return error.ZipEndRecord64UnhandledExtraData;
334
335 if (record64.version_needed_to_extract > 45)
336 return error.ZipUnsupportedVersion;
337
338 {
339 const is_multidisk = record64.disk_number != 0 or
340 record64.central_directory_disk_number != 0 or
341 record64.record_count_disk != record64.record_count_total;
342 if (is_multidisk)
343 return error.ZipMultiDiskUnsupported;
344 }
345
346 if (isMaxInt(end_record.record_count_total)) {
347 result.cd_record_count = record64.record_count_total;
348 } else if (end_record.record_count_total != record64.record_count_total)
349 return error.Zip64RecordCountTotalMismatch;
350
351 if (isMaxInt(end_record.central_directory_offset)) {
352 result.cd_zip_offset = record64.central_directory_offset;
353 } else if (end_record.central_directory_offset != record64.central_directory_offset)
354 return error.Zip64CentralDirectoryOffsetMismatch;
355
356 if (isMaxInt(end_record.central_directory_size)) {
357 result.cd_size = record64.central_directory_size;
358 } else if (end_record.central_directory_size != record64.central_directory_size)
359 return error.Zip64CentralDirectorySizeMismatch;
360
361 return result;
362 }
363
364 pub fn next(self: *Iterator) !?Entry {
365 if (self.cd_record_index == self.cd_record_count) {
366 if (self.cd_record_offset != self.cd_size)
367 return if (self.cd_size > self.cd_record_offset)
368 error.ZipCdOversized
369 else
370 error.ZipCdUndersized;
371
372 return null;
373 }
374
375 const header_zip_offset = self.cd_zip_offset + self.cd_record_offset;
376 const input = self.input;
377 try input.seekTo(header_zip_offset);
378 const header = input.interface.takeStruct(CentralDirectoryFileHeader, .little) catch |err| switch (err) {
379 error.ReadFailed => return input.err.?,
380 error.EndOfStream => return error.EndOfStream,
381 };
382 if (!std.mem.eql(u8, &header.signature, ¢ral_file_header_sig))
383 return error.ZipBadCdOffset;
384
385 self.cd_record_index += 1;
386 self.cd_record_offset += @sizeOf(CentralDirectoryFileHeader) + header.filename_len + header.extra_len + header.comment_len;
387
388 // Note: checking the version_needed_to_extract doesn't seem to be helpful, i.e. the zip file
389 // at https://github.com/ninja-build/ninja/releases/download/v1.12.0/ninja-linux.zip
390 // has an undocumented version 788 but extracts just fine.
391
392 if (header.flags.encrypted)
393 return error.ZipEncryptionUnsupported;
394 // TODO: check/verify more flags
395 if (header.disk_number != 0)
396 return error.ZipMultiDiskUnsupported;
397
398 var extents: FileExtents = .{
399 .uncompressed_size = header.uncompressed_size,
400 .compressed_size = header.compressed_size,
401 .local_file_header_offset = header.local_file_header_offset,
402 };
403
404 if (header.extra_len > 0) {
405 var extra_buf: [std.math.maxInt(u16)]u8 = undefined;
406 const extra = extra_buf[0..header.extra_len];
407
408 try input.seekTo(header_zip_offset + @sizeOf(CentralDirectoryFileHeader) + header.filename_len);
409 input.interface.readSliceAll(extra) catch |err| switch (err) {
410 error.ReadFailed => return input.err.?,
411 error.EndOfStream => return error.EndOfStream,
412 };
413
414 var extra_offset: usize = 0;
415 while (extra_offset + 4 <= extra.len) {
416 const header_id = std.mem.readInt(u16, extra[extra_offset..][0..2], .little);
417 const data_size = std.mem.readInt(u16, extra[extra_offset..][2..4], .little);
418 const end = extra_offset + 4 + data_size;
419 if (end > extra.len)
420 return error.ZipBadExtraFieldSize;
421 const data = extra[extra_offset + 4 .. end];
422 switch (@as(ExtraHeader, @enumFromInt(header_id))) {
423 .zip64_info => try readZip64FileExtents(CentralDirectoryFileHeader, header, &extents, data),
424 else => {}, // ignore
425 }
426 extra_offset = end;
427 }
428 }
429
430 return .{
431 .version_needed_to_extract = header.version_needed_to_extract,
432 .flags = header.flags,
433 .compression_method = header.compression_method,
434 .last_modification_time = header.last_modification_time,
435 .last_modification_date = header.last_modification_date,
436 .header_zip_offset = header_zip_offset,
437 .crc32 = header.crc32,
438 .filename_len = header.filename_len,
439 .compressed_size = extents.compressed_size,
440 .uncompressed_size = extents.uncompressed_size,
441 .file_offset = extents.local_file_header_offset,
442 };
443 }
444
445 pub const Entry = struct {
446 version_needed_to_extract: u16,
447 flags: GeneralPurposeFlags,
448 compression_method: CompressionMethod,
449 last_modification_time: u16,
450 last_modification_date: u16,
451 header_zip_offset: u64,
452 crc32: u32,
453 filename_len: u32,
454 compressed_size: u64,
455 uncompressed_size: u64,
456 file_offset: u64,
457
458 pub fn extract(
459 self: Entry,
460 stream: *File.Reader,
461 options: ExtractOptions,
462 filename_buf: []u8,
463 dest: std.fs.Dir,
464 ) !void {
465 if (filename_buf.len < self.filename_len)
466 return error.ZipInsufficientBuffer;
467 switch (self.compression_method) {
468 .store, .deflate => {},
469 else => return error.UnsupportedCompressionMethod,
470 }
471 const filename = filename_buf[0..self.filename_len];
472 {
473 try stream.seekTo(self.header_zip_offset + @sizeOf(CentralDirectoryFileHeader));
474 try stream.interface.readSliceAll(filename);
475 }
476
477 const local_data_header_offset: u64 = local_data_header_offset: {
478 const local_header = blk: {
479 try stream.seekTo(self.file_offset);
480 break :blk try stream.interface.takeStruct(LocalFileHeader, .little);
481 };
482 if (!std.mem.eql(u8, &local_header.signature, &local_file_header_sig))
483 return error.ZipBadFileOffset;
484 if (local_header.version_needed_to_extract != self.version_needed_to_extract)
485 return error.ZipMismatchVersionNeeded;
486 if (local_header.last_modification_time != self.last_modification_time)
487 return error.ZipMismatchModTime;
488 if (local_header.last_modification_date != self.last_modification_date)
489 return error.ZipMismatchModDate;
490
491 if (@as(u16, @bitCast(local_header.flags)) != @as(u16, @bitCast(self.flags)))
492 return error.ZipMismatchFlags;
493 if (local_header.crc32 != 0 and local_header.crc32 != self.crc32)
494 return error.ZipMismatchCrc32;
495 var extents: FileExtents = .{
496 .uncompressed_size = local_header.uncompressed_size,
497 .compressed_size = local_header.compressed_size,
498 .local_file_header_offset = 0,
499 };
500 if (local_header.extra_len > 0) {
501 var extra_buf: [std.math.maxInt(u16)]u8 = undefined;
502 const extra = extra_buf[0..local_header.extra_len];
503
504 {
505 try stream.seekTo(self.file_offset + @sizeOf(LocalFileHeader) + local_header.filename_len);
506 try stream.interface.readSliceAll(extra);
507 }
508
509 var extra_offset: usize = 0;
510 while (extra_offset + 4 <= local_header.extra_len) {
511 const header_id = std.mem.readInt(u16, extra[extra_offset..][0..2], .little);
512 const data_size = std.mem.readInt(u16, extra[extra_offset..][2..4], .little);
513 const end = extra_offset + 4 + data_size;
514 if (end > local_header.extra_len)
515 return error.ZipBadExtraFieldSize;
516 const data = extra[extra_offset + 4 .. end];
517 switch (@as(ExtraHeader, @enumFromInt(header_id))) {
518 .zip64_info => try readZip64FileExtents(LocalFileHeader, local_header, &extents, data),
519 else => {}, // ignore
520 }
521 extra_offset = end;
522 }
523 }
524
525 if (extents.compressed_size != 0 and
526 extents.compressed_size != self.compressed_size)
527 return error.ZipMismatchCompLen;
528 if (extents.uncompressed_size != 0 and
529 extents.uncompressed_size != self.uncompressed_size)
530 return error.ZipMismatchUncompLen;
531
532 if (local_header.filename_len != self.filename_len)
533 return error.ZipMismatchFilenameLen;
534
535 break :local_data_header_offset @as(u64, local_header.filename_len) +
536 @as(u64, local_header.extra_len);
537 };
538
539 if (options.allow_backslashes) {
540 std.mem.replaceScalar(u8, filename, '\\', '/');
541 } else {
542 if (std.mem.indexOfScalar(u8, filename, '\\')) |_|
543 return error.ZipFilenameHasBackslash;
544 }
545
546 if (isBadFilename(filename))
547 return error.ZipBadFilename;
548
549 // All entries that end in '/' are directories
550 if (filename[filename.len - 1] == '/') {
551 if (self.uncompressed_size != 0)
552 return error.ZipBadDirectorySize;
553 try dest.makePath(filename[0 .. filename.len - 1]);
554 return;
555 }
556
557 const out_file = blk: {
558 if (std.fs.path.dirname(filename)) |dirname| {
559 var parent_dir = try dest.makeOpenPath(dirname, .{});
560 defer parent_dir.close();
561
562 const basename = std.fs.path.basename(filename);
563 break :blk try parent_dir.createFile(basename, .{ .exclusive = true });
564 }
565 break :blk try dest.createFile(filename, .{ .exclusive = true });
566 };
567 defer out_file.close();
568 var out_file_buffer: [1024]u8 = undefined;
569 var file_writer = out_file.writer(&out_file_buffer);
570 const local_data_file_offset: u64 =
571 @as(u64, self.file_offset) +
572 @as(u64, @sizeOf(LocalFileHeader)) +
573 local_data_header_offset;
574 try stream.seekTo(local_data_file_offset);
575
576 // TODO limit based on self.compressed_size
577
578 switch (self.compression_method) {
579 .store => {
580 stream.interface.streamExact64(&file_writer.interface, self.uncompressed_size) catch |err| switch (err) {
581 error.ReadFailed => return stream.err.?,
582 error.WriteFailed => return file_writer.err.?,
583 error.EndOfStream => return error.ZipDecompressTruncated,
584 };
585 },
586 .deflate => {
587 var flate_buffer: [flate.max_window_len]u8 = undefined;
588 var decompress: flate.Decompress = .init(&stream.interface, .raw, &flate_buffer);
589 decompress.reader.streamExact64(&file_writer.interface, self.uncompressed_size) catch |err| switch (err) {
590 error.ReadFailed => return stream.err.?,
591 error.WriteFailed => return file_writer.err orelse decompress.err.?,
592 error.EndOfStream => return error.ZipDecompressTruncated,
593 };
594 },
595 else => return error.UnsupportedCompressionMethod,
596 }
597 try file_writer.end();
598 }
599 };
600};
601
602// returns true if `filename` starts with `root` followed by a forward slash
603fn filenameInRoot(filename: []const u8, root: []const u8) bool {
604 return (filename.len >= root.len + 1) and
605 (filename[root.len] == '/') and
606 std.mem.eql(u8, filename[0..root.len], root);
607}
608
609pub const Diagnostics = struct {
610 allocator: std.mem.Allocator,
611
612 /// The common root directory for all extracted files if there is one.
613 root_dir: []const u8 = "",
614
615 saw_first_file: bool = false,
616
617 pub fn deinit(self: *Diagnostics) void {
618 self.allocator.free(self.root_dir);
619 self.* = undefined;
620 }
621
622 // This function assumes name is a filename from a zip file which has already been verified to
623 // not start with a slash, backslashes have been normalized to forward slashes, and directories
624 // always end in a slash.
625 pub fn nextFilename(self: *Diagnostics, name: []const u8) error{OutOfMemory}!void {
626 if (!self.saw_first_file) {
627 self.saw_first_file = true;
628 std.debug.assert(self.root_dir.len == 0);
629 const root_len = std.mem.indexOfScalar(u8, name, '/') orelse return;
630 std.debug.assert(root_len > 0);
631 self.root_dir = try self.allocator.dupe(u8, name[0..root_len]);
632 } else if (self.root_dir.len > 0) {
633 if (!filenameInRoot(name, self.root_dir)) {
634 self.allocator.free(self.root_dir);
635 self.root_dir = "";
636 }
637 }
638 }
639};
640
641pub const ExtractOptions = struct {
642 /// Allow filenames within the zip to use backslashes. Back slashes are normalized
643 /// to forward slashes before forwarding them to platform APIs.
644 allow_backslashes: bool = false,
645 diagnostics: ?*Diagnostics = null,
646 verify_checksums: bool = false,
647};
648
649/// Extract the zipped files to the given `dest` directory.
650pub fn extract(dest: std.fs.Dir, fr: *File.Reader, options: ExtractOptions) !void {
651 if (options.verify_checksums) @panic("TODO unimplemented");
652
653 var iter = try Iterator.init(fr);
654
655 var filename_buf: [std.fs.max_path_bytes]u8 = undefined;
656 while (try iter.next()) |entry| {
657 try entry.extract(fr, options, &filename_buf, dest);
658 if (options.diagnostics) |d| {
659 try d.nextFilename(filename_buf[0..entry.filename_len]);
660 }
661 }
662}