path: root/src/main.zig

const std = @import("std");

// ZIP file implementation
// See spec.txt.

const CompressionMethod = enum(u16) {
    store = 0,
    shrink = 1,
    reduce_1 = 2,
    reduce_2 = 3,
    reduce_3 = 4,
    reduce_4 = 5,
    implode = 6,
    reserved_1 = 7,
    deflate = 8,
    deflate64 = 9,
    pkware_implode = 10,
    reserved_2 = 11,
    bzip2 = 12,
    reserved_3 = 13,
    lzma = 14,
    reserved_4 = 15,
    ibm_zos_zmpsc = 16,
    reserved_5 = 17,
    ibm_terse = 18,
    ibm_lz77_z = 19,
    zstd_deprecated = 20,
    zstd = 93,
    mp3 = 94,
    xz = 95,
    jpeg = 96,
    wavpack = 97,
    ppmd_version_i_rev1 = 98,
    aex_encryption_marker = 99,
};
// [local file header 1]
// [encryption header 1]
// [file data 1]
// [data descriptor 1]
// .
// .
// .
// [local file header n]
// [encryption header n]
// [file data n]
// [data descriptor n]
// [archive decryption header]
// [archive extra data record]
// [central directory header 1]
// .
// .
// .
// [central directory header n]
// [zip64 end of central directory record]
// [zip64 end of central directory locator]
// [end of central directory record]
allocator: std.mem.Allocator,
end_of_central_directory_record: EndOfCentralDirectoryRecord,
central_directory_headers: []CentralDirectoryHeader,

pub fn from(allocator: std.mem.Allocator, file_or_stream: anytype) !@This() {
    // Find the EndOfCentralDirectoryRecord. It must be in the last 64k of the file
    const eocdr_search_width_max: usize = 64_000;
    const epos = try file_or_stream.getEndPos();
    const eocdr_search_width: usize = @min(epos, eocdr_search_width_max);
    const eocdr_seek_start: usize = epos - eocdr_search_width;
    try file_or_stream.seekTo(eocdr_seek_start);
    var reader = file_or_stream.reader();
    const sb = try read_to_sig(reader, EndOfCentralDirectoryRecord.SIG);
    try file_or_stream.seekBy(sb);

    var eocdr = try EndOfCentralDirectoryRecord.read(allocator, reader);
    errdefer eocdr.deinit(allocator);
    if (eocdr.disk_number_this != 0 or eocdr.disk_number_central_dir_start != 0) return error.SpansNotSupported;
    if (eocdr.total_central_dir_entries != eocdr.total_central_dir_entries_on_this_disk) return error.SpansNotSupported;

    var central_directory_headers = try allocator.alloc(CentralDirectoryHeader, eocdr.total_central_dir_entries);
    errdefer allocator.free(central_directory_headers);
    try file_or_stream.seekTo(eocdr.central_dir_offset);
    for (0..eocdr.total_central_dir_entries) |i| {
        central_directory_headers[i] = try CentralDirectoryHeader.read(allocator, reader);
    }

    return .{
        .allocator = allocator,
        .end_of_central_directory_record = eocdr,
        .central_directory_headers = central_directory_headers,
    };
}

/// returns how much to seekBy after the signature  is found (becuase we'll now have read over it.)
fn read_to_sig(reader: anytype, sig: u32) !i32 {
    const needle = @byteSwap(sig);
    var window: u32 = try reader.readIntLittle(u32);
    while (true) {
        if (window == needle) {
            return -4;
        }
        const nb = try reader.readByte();
        window <<= 8;
        window |= nb;
    } else {
        return error.SignatureNotFound;
    }
}

pub fn deinit(self: *@This()) void {
    self.end_of_central_directory_record.deinit(self.allocator);
    for (0..self.central_directory_headers.len) |i| {
        self.central_directory_headers[i].deinit(self.allocator);
    }
    self.allocator.free(self.central_directory_headers);
}

pub fn count_files(self: @This()) u16 {
    return self.end_of_central_directory_record.total_central_dir_entries;
}
pub fn file_name(self: @This(), index: usize) []const u8 {
    return self.central_directory_headers[index].file_name;
}
pub fn file_comment(self: @This(), index: usize) []const u8 {
    return self.central_directory_headers[index].file_comment;
}
pub fn extract(self: @This(), index: usize, stream_or_file_in: anytype, writer: anytype) !void {
    const cdh = self.central_directory_headers[index];
    try stream_or_file_in.seekTo(cdh.relative_offset_of_local_header);
    var reader = stream_or_file_in.reader();
    var lfh = try LocalFileHeader.read(self.allocator, reader);
    defer lfh.deinit(self.allocator);
    return try lfh.extract(self.allocator, reader, writer);
}

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 {
    const SIG: u32 = @as(u32, 0x02014b50);
    version_made_by: u16,
    version_needed_to_extract: u16,
    general_purpose_bit_flag: u16,
    compression_method: 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_comment_length: u16,
    disk_number_start: u16,
    internal_file_attributes: u16,
    external_file_attributes: u32,
    relative_offset_of_local_header: u32,
    file_name: []const u8,
    extra_field: []const u8,
    file_comment: []const u8,

    fn read(allocator: std.mem.Allocator, reader: anytype) !CentralDirectoryHeader {
        return read2(allocator, reader, CentralDirectoryHeader, &[_]Dynamic{
            .{ .field_name = "file_name", .length_field_name = "file_name_length" },
            .{ .field_name = "extra_field", .length_field_name = "extra_field_length" },
            .{ .field_name = "file_comment", .length_field_name = "file_comment_length" },
        });
    }

    fn deinit(self: *CentralDirectoryHeader, allocator: std.mem.Allocator) void {
        allocator.free(self.file_name);
        allocator.free(self.extra_field);
        allocator.free(self.file_comment);
    }
};

const EndOfCentralDirectoryRecord = struct {
    const SIG: u32 = @as(u32, 0x06054b50);
    disk_number_this: u16,
    disk_number_central_dir_start: u16,
    total_central_dir_entries_on_this_disk: u16,
    total_central_dir_entries: u16,
    size_of_central_dir: u32,
    central_dir_offset: u32,
    comment_length: u16,
    comment: []const u8,

    fn read(allocator: std.mem.Allocator, reader: anytype) !EndOfCentralDirectoryRecord {
        return read2(allocator, reader, EndOfCentralDirectoryRecord, &[_]Dynamic{
            .{ .field_name = "comment", .length_field_name = "comment_length" },
        });
    }

    fn deinit(self: *EndOfCentralDirectoryRecord, allocator: std.mem.Allocator) void {
        allocator.free(self.comment);
    }
};

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: 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, reader: anytype) !LocalFileHeader {
        return read2(allocator, reader, 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);
    }

    fn is_dir(self: *LocalFileHeader) bool {
        return std.mem.endsWith(u8, self.file_name, "/"); // This is what the java stdlib does
    }

    fn extract(self: *LocalFileHeader, allocator: std.mem.Allocator, reader: anytype, writer: anytype) !void {
        const is_encrypted = self.general_purpose_bit_flag.isSet(0);
        if (is_encrypted) return error.EncryptionNotSupported;

        if (self.is_dir()) {
            if (self.compressed_size != 0) {
                // directories can't have a size, this is very likely wrong.
                return error.InvalidFileName;
            }
            return; // Do nothing here. If we were definitely writing to the filesystem we could make an empty dir I guess.
        }

        var lr = std.io.limitedReader(reader, self.compressed_size);
        var limited_reader = lr.reader();
        switch (self.compression_method) {
            .store => {
                try pump(limited_reader, writer, self.uncompressed_size, self.crc32);
            },
            .deflate => {
                var decomp = try std.compress.deflate.decompressor(allocator, limited_reader, null);
                defer decomp.deinit();
                var decomp_reader = decomp.reader();
                try pump(decomp_reader, writer, self.uncompressed_size, self.crc32);
            },
            .lzma => {
                var decomp = try std.compress.lzma.decompress(allocator, limited_reader);
                defer decomp.deinit();
                var decomp_reader = decomp.reader();
                try pump(decomp_reader, writer, self.uncompressed_size, self.crc32);
            },
            else => {
                std.log.err("compression method {} not supported", .{self.compression_method});
                return error.CompressionMethodNotSupported;
            },
        }
    }
};

const Dynamic = struct {
    field_name: []const u8,
    length_field_name: []const u8,
};

fn read2(
    allocator: std.mem.Allocator,
    reader: anytype,
    comptime T: type,
    comptime dynamics: []const Dynamic,
) !T {
    if (!@hasDecl(T, "SIG")) @compileError("Expected decl SIG:u32 on type " ++ @typeName(T));
    const ti = @typeInfo(T);
    if (ti != .Struct) @compileError("read2 expects type parameter T to be a struct, but it was a " ++ @typeName(T));
    const si = ti.Struct;

    const sig_actual = try reader.readIntLittle(u32);
    if (sig_actual != T.SIG) {
        std.log.err("invalid signature expected {x} got {x}", .{ T.SIG, sig_actual });
        return error.InvalidSignature;
    }
    var t: T = undefined;
    inline for (si.fields) |field| {
        const fti = @typeInfo(field.type);
        dynamic: inline for (dynamics) |dyn| {
            if (comptime std.mem.eql(u8, dyn.field_name, field.name)) {
                if (fti != .Pointer) @compileError("field " ++ field.name ++ " is marked dynamic but isn't a pointer. Instead it's a " ++ @typeName(field.type));
                const pi = fti.Pointer;
                if (pi.size != .Slice) @compileError("field " ++ field.name ++ " is marked dynamic, but isn't a slice, instead it's sized " ++ @tagName(pi.size));
                const len = @field(t, dyn.length_field_name);
                var buf = try allocator.alloc(pi.child, len);
                // TODO how to errdefer in a loop, not sure where the scope ends.
                _ = try reader.readAll(buf);
                @field(t, field.name) = buf;
                break :dynamic;
            }
        } else {
            switch (fti) {
                .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)),
            }
        }
    }
    return t;
}

test "open stream" {
    const test_zip = @embedFile("hello.zip");
    var fbs = std.io.fixedBufferStream(test_zip);
    var zf = try @This().from(std.testing.allocator, &fbs);
    defer zf.deinit();
    try std.testing.expectEqual(zf.count_files(), 2);
    try std.testing.expectEqualStrings(zf.file_name(0), "hello.txt");
    try std.testing.expectEqualStrings(zf.file_name(1), "foo.txt");
}

test "open file" {
    const test_zip = try std.fs.cwd().openFile("src/hello.zip", .{});
    var zf = try @This().from(std.testing.allocator, &test_zip);
    defer zf.deinit();
    try std.testing.expectEqual(zf.count_files(), 2);
    try std.testing.expectEqualStrings(zf.file_name(0), "hello.txt");
    try std.testing.expectEqualStrings(zf.file_name(1), "foo.txt");
}

test "extract stored" {
    const test_zip = @embedFile("hello.zip");
    var fbs = std.io.fixedBufferStream(test_zip);
    var zf = try @This().from(std.testing.allocator, &fbs);
    defer zf.deinit();
    var out = [_]u8{0} ** 1024;
    var fbs_out = std.io.fixedBufferStream(&out);
    var writer = fbs_out.writer();
    try zf.extract(0, &fbs, writer);
    try std.testing.expectEqualStrings("Hello, Zip!", fbs_out.getWritten());
    fbs_out.reset();
    try zf.extract(1, &fbs, writer);
    try std.testing.expectEqualStrings("hi there\n", fbs_out.getWritten());
}

test "extract deflate" {
    const test_zip = @embedFile("deflate.zip");
    var fbs = std.io.fixedBufferStream(test_zip);
    var zf = try @This().from(std.testing.allocator, &fbs);
    defer zf.deinit();
    var out = [_]u8{0} ** 1024;
    var fbs_out = std.io.fixedBufferStream(&out);
    var writer = fbs_out.writer();
    try std.testing.expectEqualStrings("Here is a comment :)", zf.file_comment(0));
    try std.testing.expectEqual(@This().CompressionMethod.deflate, zf.central_directory_headers[0].compression_method);
    try zf.extract(0, &fbs, writer);
    try std.testing.expectEqualStrings(@embedFile("foo.txt"), fbs_out.getWritten());
}
test "subdir" {
    const test_zip = @embedFile("subfolder.zip");
    var fbs = std.io.fixedBufferStream(test_zip);
    var zf = try @This().from(std.testing.allocator, &fbs);
    defer zf.deinit();
    for (0..zf.count_files()) |i| {
        _ = i;
        // std.log.err("cdh {any}", .{zf.central_directory_headers[i]});
    }
}
pub const Options = struct {
    allocator: std.mem.Allocator,
};
// tar.zig compatibility, ish. It manages a forwards-only read of the filesystem anyway
pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !void {
    const allocator = options.allocator;
    // var peek_stream = std.io.peekStream(4, reader);
    // var peek_reader = peek_stream.reader();
    while (true) {
        var lfh = try LocalFileHeader.read(allocator, reader);
        defer lfh.deinit(allocator);
        if (std.fs.path.dirname(lfh.file_name)) |dn| {
            try dir.makePath(dn);
        }
        if (!lfh.is_dir()) {
            var f = try dir.createFile(lfh.file_name, .{});
            defer f.close();
            var writer = f.writer();
            try lfh.extract(allocator, reader, writer);
        }
        try reader.skipBytes(12, .{}); // Data descriptor signature.
        // _ = read_to_sig(peek_reader, LocalFileHeader.SIG) catch |e| switch (e) {
        //     error.EndOfStream => return,
        //     else => return e,
        // };
        // try peek_stream.putBack(&@as([4]u8, @bitCast(LocalFileHeader.SIG)));
    }
}

test "filesystem" {
    var f = try std.fs.cwd().openFile("src/subfolder.zip", .{});
    defer f.close();
    try pipeToFileSystem(try std.fs.cwd().makeOpenPath("test", .{}), f.reader(), .{ .allocator = std.testing.allocator });
}