struct Entry [src]

Fields

version_needed_to_extract: u16
flags: GeneralPurposeFlags
compression_method: CompressionMethod
last_modification_time: u16
last_modification_date: u16
header_zip_offset: u64
crc32: u32
filename_len: u32
compressed_size: u64
uncompressed_size: u64
file_offset: u64
Members

extract (Function)
Source

  pub const Entry = struct {
    version_needed_to_extract: u16,
    flags: GeneralPurposeFlags,
    compression_method: CompressionMethod,
    last_modification_time: u16,
    last_modification_date: u16,
    header_zip_offset: u64,
    crc32: u32,
    filename_len: u32,
    compressed_size: u64,
    uncompressed_size: u64,
    file_offset: u64,

    pub fn extract(
        self: Entry,
        stream: *File.Reader,
        options: ExtractOptions,
        filename_buf: []u8,
        dest: std.fs.Dir,
    ) !void {
        if (filename_buf.len < self.filename_len)
            return error.ZipInsufficientBuffer;
        switch (self.compression_method) {
            .store, .deflate => {},
            else => return error.UnsupportedCompressionMethod,
        }
        const filename = filename_buf[0..self.filename_len];
        {
            try stream.seekTo(self.header_zip_offset + @sizeOf(CentralDirectoryFileHeader));
            try stream.interface.readSliceAll(filename);
        }

        const local_data_header_offset: u64 = local_data_header_offset: {
            const local_header = blk: {
                try stream.seekTo(self.file_offset);
                break :blk try stream.interface.takeStruct(LocalFileHeader, .little);
            };
            if (!std.mem.eql(u8, &local_header.signature, &local_file_header_sig))
                return error.ZipBadFileOffset;
            if (local_header.version_needed_to_extract != self.version_needed_to_extract)
                return error.ZipMismatchVersionNeeded;
            if (local_header.last_modification_time != self.last_modification_time)
                return error.ZipMismatchModTime;
            if (local_header.last_modification_date != self.last_modification_date)
                return error.ZipMismatchModDate;

            if (@as(u16, @bitCast(local_header.flags)) != @as(u16, @bitCast(self.flags)))
                return error.ZipMismatchFlags;
            if (local_header.crc32 != 0 and local_header.crc32 != self.crc32)
                return error.ZipMismatchCrc32;
            var extents: FileExtents = .{
                .uncompressed_size = local_header.uncompressed_size,
                .compressed_size = local_header.compressed_size,
                .local_file_header_offset = 0,
            };
            if (local_header.extra_len > 0) {
                var extra_buf: [std.math.maxInt(u16)]u8 = undefined;
                const extra = extra_buf[0..local_header.extra_len];

                {
                    try stream.seekTo(self.file_offset + @sizeOf(LocalFileHeader) + local_header.filename_len);
                    try stream.interface.readSliceAll(extra);
                }

                var extra_offset: usize = 0;
                while (extra_offset + 4 <= local_header.extra_len) {
                    const header_id = std.mem.readInt(u16, extra[extra_offset..][0..2], .little);
                    const data_size = std.mem.readInt(u16, extra[extra_offset..][2..4], .little);
                    const end = extra_offset + 4 + data_size;
                    if (end > local_header.extra_len)
                        return error.ZipBadExtraFieldSize;
                    const data = extra[extra_offset + 4 .. end];
                    switch (@as(ExtraHeader, @enumFromInt(header_id))) {
                        .zip64_info => try readZip64FileExtents(LocalFileHeader, local_header, &extents, data),
                        else => {}, // ignore
                    }
                    extra_offset = end;
                }
            }

            if (extents.compressed_size != 0 and
                extents.compressed_size != self.compressed_size)
                return error.ZipMismatchCompLen;
            if (extents.uncompressed_size != 0 and
                extents.uncompressed_size != self.uncompressed_size)
                return error.ZipMismatchUncompLen;

            if (local_header.filename_len != self.filename_len)
                return error.ZipMismatchFilenameLen;

            break :local_data_header_offset @as(u64, local_header.filename_len) +
                @as(u64, local_header.extra_len);
        };

        if (options.allow_backslashes) {
            std.mem.replaceScalar(u8, filename, '\\', '/');
        } else {
            if (std.mem.indexOfScalar(u8, filename, '\\')) |_|
                return error.ZipFilenameHasBackslash;
        }

        if (isBadFilename(filename))
            return error.ZipBadFilename;

        // All entries that end in '/' are directories
        if (filename[filename.len - 1] == '/') {
            if (self.uncompressed_size != 0)
                return error.ZipBadDirectorySize;
            try dest.makePath(filename[0 .. filename.len - 1]);
            return;
        }

        const out_file = blk: {
            if (std.fs.path.dirname(filename)) |dirname| {
                var parent_dir = try dest.makeOpenPath(dirname, .{});
                defer parent_dir.close();

                const basename = std.fs.path.basename(filename);
                break :blk try parent_dir.createFile(basename, .{ .exclusive = true });
            }
            break :blk try dest.createFile(filename, .{ .exclusive = true });
        };
        defer out_file.close();
        var out_file_buffer: [1024]u8 = undefined;
        var file_writer = out_file.writer(&out_file_buffer);
        const local_data_file_offset: u64 =
            @as(u64, self.file_offset) +
            @as(u64, @sizeOf(LocalFileHeader)) +
            local_data_header_offset;
        try stream.seekTo(local_data_file_offset);

        // TODO limit based on self.compressed_size

        switch (self.compression_method) {
            .store => {
                stream.interface.streamExact64(&file_writer.interface, self.uncompressed_size) catch |err| switch (err) {
                    error.ReadFailed => return stream.err.?,
                    error.WriteFailed => return file_writer.err.?,
                    error.EndOfStream => return error.ZipDecompressTruncated,
                };
            },
            .deflate => {
                var flate_buffer: [flate.max_window_len]u8 = undefined;
                var decompress: flate.Decompress = .init(&stream.interface, .raw, &flate_buffer);
                decompress.reader.streamExact64(&file_writer.interface, self.uncompressed_size) catch |err| switch (err) {
                    error.ReadFailed => return stream.err.?,
                    error.WriteFailed => return file_writer.err orelse decompress.err.?,
                    error.EndOfStream => return error.ZipDecompressTruncated,
                };
            },
            else => return error.UnsupportedCompressionMethod,
        }
        try file_writer.end();
    }
}  