diff options
| -rw-r--r-- | src/main.zig | 104 |
1 files changed, 104 insertions, 0 deletions
diff --git a/src/main.zig b/src/main.zig index d123e7f..34cb59c 100644 --- a/src/main.zig +++ b/src/main.zig @@ -4,6 +4,13 @@ const std = @import("std"); // See spec.txt. const ZipFile = struct { + const CompressionMethod = enum(u16) { + store = 0, + deflate = 8, + lzma = 14, + zstd = 93, + xz = 95, + }; // [local file header 1] // [encryption header 1] // [file data 1] @@ -82,6 +89,51 @@ const ZipFile = struct { fn file_name(self: ZipFile, index: u16) []const u8 { return self.central_directory_headers[index].file_name; } + fn extract(self: ZipFile, index: u16, stream_or_file_in: anytype, stream_or_file_out: anytype) !void { + const cdh = self.central_directory_headers[index]; + try stream_or_file_in.seekTo(cdh.relative_offset_of_local_header); + var lfh = try LocalFileHeader.read(self.allocator, stream_or_file_in); + defer lfh.deinit(self.allocator); + const is_encrypted = lfh.general_purpose_bit_flag.isSet(0); + if (is_encrypted) return error.EncryptionNotSupported; + + var reader = stream_or_file_in.reader(); + var lr = std.io.limitedReader(reader, lfh.compressed_size); + var limited_reader = lr.reader(); + switch (lfh.compression_method) { + .store => { // no compression (store) + var writer = stream_or_file_out.writer(); + try pump(limited_reader, writer, lfh.uncompressed_size, lfh.crc32); + }, + .deflate => { // deflate + var decomp = try std.compress.deflate.decompressor(self.allocator, limited_reader, null); + defer decomp.deinit(); + var decomp_reader = decomp.reader(); + var writer = stream_or_file_out.writer(); + try pump(decomp_reader, writer, lfh.uncompressed_size, lfh.crc32); + }, + else => { + std.log.err("compression method {} not supported", .{lfh.compression_method}); + return error.CompressionMethodNotSupported; + }, + } + } + fn pump(reader: anytype, writer: anytype, expected_size_written: usize, expected_crc32: u32) !void { + var buf = [_]u8{0} ** 1024; + var crc32 = std.hash.Crc32.init(); + var written: usize = 0; + while (true) { + const read = try reader.read(&buf); + if (read == 0) break; + const write = buf[0..read]; + try writer.writeAll(write); + + crc32.update(write); + written += read; + } + if (written != expected_size_written) return error.WrongUncompressedSize; + if (crc32.final() != expected_crc32) return error.WrongChecksum; + } }; const CentralDirectoryHeader = struct { @@ -143,6 +195,32 @@ const EndOfCentralDirectoryRecord = struct { } }; +const LocalFileHeader = struct { + const SIG: u32 = @as(u32, 0x04034b50); + version_needed_to_extract: u16, + general_purpose_bit_flag: std.bit_set.IntegerBitSet(16), + compression_method: ZipFile.CompressionMethod, + last_mod_file_time: u16, + last_mod_file_date: u16, + crc32: u32, + compressed_size: u32, + uncompressed_size: u32, + file_name_length: u16, + extra_field_length: u16, + file_name: []const u8, + extra_field: []const u8, + fn read(allocator: std.mem.Allocator, stream_or_file: anytype) !LocalFileHeader { + return read2(allocator, stream_or_file, LocalFileHeader, &[_]Dynamic{ + .{ .field_name = "file_name", .length_field_name = "file_name_length" }, + .{ .field_name = "extra_field", .length_field_name = "extra_field_length" }, + }); + } + fn deinit(self: *LocalFileHeader, allocator: std.mem.Allocator) void { + allocator.free(self.file_name); + allocator.free(self.extra_field); + } +}; + const Dynamic = struct { field_name: []const u8, length_field_name: []const u8, @@ -185,6 +263,18 @@ fn read2( .Int => { @field(t, field.name) = try reader.readIntLittle(field.type); }, + .Struct => |fsi| { + if (fsi.backing_integer) |bi| { + const int = try reader.readIntLittle(bi); + @field(t, field.name) = @bitCast(int); + } else @compileError("only packed struct with backing integer are supported, field " ++ field.name ++ " type " ++ @typeName(field.type) ++ "is not such a struct"); + }, + .Enum => |fei| { + if (@typeInfo(fei.tag_type) == .Int) { + const int = try reader.readIntLittle(fei.tag_type); + @field(t, field.name) = @enumFromInt(int); + } else @compileError("only enum with integer tag type are supported field " ++ field.name ++ " type " ++ @typeName(field.type) ++ "is not such a struct"); + }, else => @compileError("don't know how to handle field " ++ field.name ++ " of type " ++ @tagName(fti)), } } @@ -210,3 +300,17 @@ test "foo2" { try std.testing.expectEqualStrings(zf.file_name(0), "hello.txt"); try std.testing.expectEqualStrings(zf.file_name(1), "foo.txt"); } + +test "extract" { + const test_zip = @embedFile("hello.zip"); + var fbs = std.io.fixedBufferStream(test_zip); + var zf = try ZipFile.from(std.testing.allocator, &fbs); + defer zf.deinit(); + var out = [_]u8{0} ** 1024; + var fbs_out = std.io.fixedBufferStream(&out); + try zf.extract(0, &fbs, &fbs_out); + try std.testing.expectEqualStrings("Hello, Zip!", fbs_out.getWritten()); + fbs_out.reset(); + try zf.extract(1, &fbs, &fbs_out); + try std.testing.expectEqualStrings("hi there\n", fbs_out.getWritten()); +} |