Started changes to Zig 0.16.0

Mainly adding functions to File

.zed/debug.json

@@ -11,7 +11,7 @@
 
 		"build": {
 			"command": "zig",
-			"args": ["build", "-Ddebug=true"],
+			"args": ["build", "-Duse_c_libs=true", "-Ddebug=true"],
 		},
 
 		"program": "zig-out/bin/unsquashfs",

build.zig

@@ -1,28 +1,62 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) !void {
-    // const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
+    const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse true;
     // const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo support") orelse false;
-    const debug = b.option(bool, "debug", "Enable options to make debugging easier.");
+    const debug = b.option(bool, "debug", "Enable options to make debugging easier.") orelse false;
     const version_string_option = b.option([]const u8, "version", "Version of the library/binary");
 
-    // const zig_squashfs_options = b.addOptions();
+    const zig_squashfs_options = b.addOptions();
-    // zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
+    zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
     // zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);
 
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
-
+    const mod = b.addModule("zig_squashfs", .{
-    const lib = b.addLibrary(.{
-        .name = "squashfs",
-        .root_module = b.createModule(.{
-            .optimize = if (debug == true) .Debug else optimize,
-            .target = target,
-            .valgrind = debug,
         .root_source_file = b.path("src/root.zig"),
-        }),
+        .target = target,
-        .use_llvm = debug,
+        .optimize = if (debug == true) .Debug else optimize,
+        .valgrind = debug,
+        .error_tracing = debug,
+        .strip = if (debug == true) false else null,
     });
+    mod.addOptions("config", zig_squashfs_options);
+    if (!use_zig_decomp) {
+        mod.link_libc = true;
+
+        const c_imports = b.addTranslateC(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/imports.c"),
+        });
+        mod.addImport("c", c_imports.createModule());
+
+        var zlib_ng = b.dependency("zlib_ng", .{
+            .target = target,
+            .optimize = optimize,
+        });
+        mod.linkLibrary(zlib_ng.artifact("zng"));
+
+        mod.linkSystemLibrary("lzma", .{ .preferred_link_mode = .static });
+
+        var minilzo = b.dependency("minilzo", .{
+            .target = target,
+            .optimize = optimize,
+        });
+        mod.linkLibrary(minilzo.artifact("minilzo"));
+
+        var lz4 = b.dependency("lz4", .{
+            .target = target,
+            .optimize = optimize,
+        });
+        mod.linkLibrary(lz4.artifact("lz4"));
+
+        var zstd = b.dependency("zstd", .{
+            .target = target,
+            .optimize = optimize,
+        });
+        mod.linkLibrary(zstd.artifact("zstd"));
+    }
 
     var version = version_string_option orelse "0.0.0-testing";
     if (version[0] == 'v') version = version[1..];
@@ -32,30 +66,41 @@ pub fn build(b: *std.Build) !void {
         "version",
         try std.SemanticVersion.parse(version),
     );
+
+    var exe_mod = b.createModule(.{
+        .root_source_file = b.path("src/bin/unsquashfs.zig"),
+        .target = target,
+        .optimize = if (debug == true) .Debug else optimize,
+        .link_libc = !use_zig_decomp,
+        .imports = &.{
+            .{ .name = "zig_squashfs", .module = mod },
+        },
+        .valgrind = debug,
+        .error_tracing = debug,
+        .strip = if (debug == true) false else null,
+    });
+    exe_mod.addOptions("config", unsquashfs_options);
     const exe = b.addExecutable(.{
         .name = "unsquashfs",
-        .root_module = b.createModule(.{
+        .root_module = exe_mod,
-            .optimize = if (debug == true) .Debug else optimize,
+        .use_llvm = debug,
-            .target = target,
+    });
-            .valgrind = debug,
+
-            .root_source_file = b.path("src/bin/unsquashfs.zig"),
+    const lib = b.addLibrary(.{
-            .imports = &.{
+        .name = "squashfs",
-                .{ .name = "zig_squashfs", .module = lib.root_module },
+        .root_module = mod,
-            },
-        }),
         .use_llvm = debug,
     });
-    exe.root_module.addOptions("config", unsquashfs_options);
 
     b.installArtifact(lib);
     b.installArtifact(exe);
 
     const mod_tests = b.addTest(.{
-        .root_module = b.createModule(.{
+        .root_module = mod,
-            .optimize = optimize,
+        .test_runner = .{
-            .target = target,
+            .mode = .simple,
-            .root_source_file = b.path("src/test.zig"),
+            .path = b.path("src/test.zig"),
-        }),
+        },
     });
     const run_mod_tests = b.addRunArtifact(mod_tests);
     const test_step = b.step("test", "Run tests");
@@ -64,13 +109,13 @@ pub fn build(b: *std.Build) !void {
     // zls build check steps
     const lib_check = b.addLibrary(.{
         .name = "squashfs",
-        .root_module = exe.root_module,
+        .root_module = mod,
     });
     const exe_check = b.addExecutable(.{
         .name = "unsquashfs",
-        .root_module = lib.root_module,
+        .root_module = exe_mod,
     });
     const check = b.step("check", "Check if unsquashfs compiles");
-    check.dependOn(&lib_check.step);
     check.dependOn(&exe_check.step);
+    check.dependOn(&lib_check.step);
 }

build.zig.zon

@@ -2,11 +2,12 @@
     .name = .squashfs,
     .version = "0.0.6",
     .fingerprint = 0x37ba29474b87f145, // Changing this has security and trust implications.
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .zlib_ng = .{
-            .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
+            // .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
-            .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
+            // .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
+            .path = "../zig-zlib-ng",
         },
         .zstd = .{
             .url = "git+https://github.com/allyourcodebase/zstd.git?ref=1.5.7-1#e1a501be57f42c541e8a5597e4b59a074dfd09a3",
@@ -17,9 +18,14 @@
             .hash = "lz4-1.10.0-6-ewyzw-4NAAAWDpY4xpiqr4LQhZQAC0x_rGnW2iPh6jk2",
         },
         .minilzo = .{
-            .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
+            // .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
-            .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
+            // .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
+            .path = "../zig-minilzo",
         },
+        // .fastlzma2 = .{
+        //     .url = "git+https://github.com/allyourcodebase/fast-lzma2#d7615e0c957a62fcd6691b3fe9519a091885bfa2",
+        //     .hash = "fastlzma2-0.0.0-gNWHgVeLAAD0Tlak3xhNcgpPSYcjyJppq0tlGmPKCC_V",
+        // },
     },
     .paths = .{
         "build.zig",

run_tests.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-zig test \
-	-lc \
-	-lz \
-	-llzma \
-	-lminilzo \
-	-llz4 \
-	-lzstd \
-		src/test.zig

src/archive.zig

@@ -1,146 +1,113 @@
 const std = @import("std");
 const Io = std.Io;
 
+const DecompTypes = @import("decomp/types.zig");
+const Decompressor = @import("decomp.zig");
 const ExtractionOptions = @import("options.zig");
 const File = @import("file.zig");
 const Inode = @import("inode.zig");
+const BlockSize = @import("inode/file.zig").BlockSize;
 const LookupTable = @import("lookup_table.zig");
-const Decompressor = @import("util/decompressor.zig");
 const MetadataReader = @import("util/metadata.zig");
-const Utils = @import("util/misc.zig");
 const OffsetFile = @import("util/offset_file.zig");
+const Utils = @import("util/utils.zig");
+
+pub const Error = error{
+    BadMagic,
+    BadBlockLog,
+    BadVersion,
+    BadCheck,
+};
 
 const Archive = @This();
 
 file: OffsetFile,
+
 super: Superblock,
 
 stateless_decomp: Decompressor,
 
-pub fn init(io: Io, file: std.Io.File, offset: u64) !Archive {
+/// Create an Archive from a File.
-    var rdr = file.reader(io, &[0]u8{});
+pub fn init(io: Io, fil: Io.File, offset: u64) !Archive {
-    try rdr.seekTo(offset);
     var super: Superblock = undefined;
-    try rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
+    var fil_rdr = fil.reader(io, &[0]u8{});
-    return .{
+    if (offset > 0)
-        .file = .init(file, offset),
+        try fil_rdr.seekTo(offset);
-        .super = super,
+    try fil_rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
+    try super.validate();
 
-        .stateless_decomp = switch (super.compression) {
+    return .{
-            .gzip => @import("decomp/zlib.zig").stateless_decompressor,
+        .file = .{ .fil = fil, .offset = offset },
-            .lzma => @import("decomp/lzma.zig").stateless_decompressor,
+        .super = super,
-            .lzo => return error.LzoUnsupported,
+        .stateless_decomp = .{ .vtable = &.{ .stateless = try DecompTypes.getStatelessFn(super.compression) } },
-            .xz => @import("decomp/xz.zig").stateless_decompressor,
-            .lz4 => return error.Lz4Unsupported,
-            .zstd => @import("decomp/zstd.zig").stateless_decompressor,
-        },
     };
 }
 
-/// The root folder of the Archive. Used to open other Files.
+pub fn root(self: Archive, alloc: std.mem.Allocator) !File {
-pub fn root(self: Archive, alloc: std.mem.Allocator, io: Io) !File {
+    return .{
-    const root_inode = try Utils.inodeFromRef(
+        .file = self.file,
+        .super = self.super.toMinimal(),
+        .decomp = self.stateless_decomp.statelessCopy(alloc),
+
+        .inode = try Utils.readInode(
             alloc,
-        io,
-        self.file,
             &self.stateless_decomp,
+            self.file,
             self.super.inode_start,
             self.super.block_size,
-        self.super.root_ref,
+            self.super.root_ref.block_start,
-    );
+            self.super.root_ref.block_offset,
-    return .init(alloc, self, root_inode, "");
+        ),
+        .name = "",
+    };
 }
-/// Opens a File within the archive.
+pub fn open(self: Archive, alloc: std.mem.Allocator, path: []const u8) !File {
-pub fn open(self: Archive, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
+    if (Utils.pathIsSelf(path)) return self.root(alloc);
-    const root_file = try self.root(alloc, io);
+    var root_file = self.root(alloc);
-    const path = std.mem.trim(u8, filepath, "/");
-    if (Utils.pathIsSelf(path))
-        return root_file;
     defer root_file.deinit();
-    return root_file.open(alloc, io, filepath);
+    return root_file.open(alloc, path);
-}
-/// Extract the entire archive contents to the given directory.
-pub fn extract(self: Archive, alloc: std.mem.Allocator, io: Io, extract_dir: []const u8, options: ExtractionOptions) !void {
-    const root_inode = try Utils.inodeFromRef(
-        alloc,
-        io,
-        self.file,
-        &self.stateless_decomp,
-        self.super.inode_start,
-        self.super.block_size,
-        self.super.root_ref,
-    );
-    _ = root_inode;
-    _ = extract_dir;
-    _ = options;
-    return error.TODO;
 }
 
-/// Returns the inode with the given inode number.
+pub fn fragEntry(self: Archive, idx: u32) !FragEntry {
-/// Requires that the archive is exportable (has an export lookup table).
+    return LookupTable.stateless(FragEntry, self.fil, &self.stateless_decomp, self.super.frag_start, idx);
-pub fn inode(self: Archive, alloc: std.mem.Allocator, io: Io, num: u32) !Inode {
+}
-    if (!self.super.flags.exportable)
+pub fn id(self: Archive, idx: u32) !u16 {
-        return error.NotExportable;
+    return LookupTable.stateless(u16, self.fil, &self.stateless_decomp, self.super.id_start, idx);
-    const ref = try LookupTable.lookupValue(
+}
-        Inode.Ref,
+pub fn inode(self: Archive, alloc: std.mem.Allocator, inode_num: u32) !Inode {
+    const ref = try LookupTable.stateless(Inode.Ref, self.file, &self.stateless_decomp, self.super.export_start, inode_num - 1);
+    return Utils.readInode(
         alloc,
-        io,
         &self.stateless_decomp,
         self.file,
-        self.super.export_start,
-        num + 1,
-    );
-    return Utils.inodeFromRef(
-        alloc,
-        io,
-        self.file,
-        &self.stateless_decomp,
         self.super.inode_start,
         self.super.block_size,
-        ref,
+        ref.block_start,
+        ref.block_offset,
     );
 }
-/// Returns a value at the given index from the Archive's id (uid/gid) table.
+
-pub fn idTable(self: Archive, alloc: std.mem.Allocator, io: Io, idx: u32) !u16 {
+pub fn extract(self: Archive, alloc: std.mem.Allocator, path: []const u8, options: ExtractionOptions) !void {
-    return LookupTable.lookupValue(
+    _ = self;
-        u16,
+    _ = alloc;
-        alloc,
+    _ = path;
-        io,
+    _ = options;
-        &self.stateless_decomp,
+    return error.TODO;
-        self.file,
-        self.super.id_start,
-        idx,
-    );
 }
 
 // Superblock
 
 const SQUASHFS_MAGIC: u32 = std.mem.readInt(u32, "hsqs", .little);
 
-const SuperblockError = error{
+pub const Superblock = packed struct {
-    InvalidMagic,
-    InvalidBlockLog,
-    InvalidVersion,
-    InvalidCheck,
-};
-
-/// A squashfs Superblock
-pub const Superblock = extern struct {
     magic: u32,
     inode_count: u32,
     mod_time: u32,
     block_size: u32,
     frag_count: u32,
-    compression: enum(u16) {
+    compression: DecompTypes.Enum,
-        gzip = 1,
-        lzma,
-        lzo,
-        xz,
-        lz4,
-        zstd,
-    },
     block_log: u16,
-    flags: packed struct(u16) {
+    flags: packed struct {
         inode_uncompressed: bool,
         data_uncompressed: bool,
         check: bool,
@@ -168,14 +135,50 @@ pub const Superblock = extern struct {
     export_start: u64,
 
     /// Validate the Superblock. If an error is returned, it's likely the archive is corrupted or not a squashfs archive.
-    pub fn validate(self: Superblock) !void {
+    fn validate(self: Superblock) !void {
         if (self.magic != SQUASHFS_MAGIC)
-            return SuperblockError.InvalidMagic;
+            return Error.BadMagic;
         if (self.flags.check)
-            return SuperblockError.InvalidCheck;
+            return Error.BadCheck;
         if (self.ver_maj != 4 or self.ver_min != 0)
-            return SuperblockError.InvalidVersion;
+            return Error.BadVersion;
         if (std.math.log2(self.block_size) != self.block_log)
-            return SuperblockError.InvalidBlockLog;
+            return Error.BadBlockLog;
+    }
+
+    pub fn toMinimal(self: Superblock) MinimalSuperblock {
+        return .{
+            .inode_count = self.inode_count,
+            .block_size = self.block_size,
+            .frag_count = self.frag_count,
+            .id_count = self.id_count,
+            .id_start = self.id_start,
+            .xattr_start = self.xattr_start,
+            .inode_start = self.inode_start,
+            .dir_start = self.dir_start,
+            .frag_start = self.frag_start,
+            .export_start = self.export_start,
+        };
     }
 };
+
+pub const MinimalSuperblock = struct {
+    inode_count: u32,
+    block_size: u32,
+    frag_count: u32,
+    id_count: u16,
+    id_start: u64,
+    xattr_start: u64,
+    inode_start: u64,
+    dir_start: u64,
+    frag_start: u64,
+    export_start: u64,
+};
+
+// Frag Entry
+
+pub const FragEntry = packed struct {
+    block_start: u64,
+    size: BlockSize,
+    _: u32,
+};

src/bin/unsquashfs.zig

@@ -42,6 +42,7 @@ var force: bool = false;
 pub fn main(init: std.process.Init) !void {
     const alloc = init.gpa;
     const io = init.io;
+
     var stdout = std.Io.File.stdout();
     var out = stdout.writer(io, &[0]u8{});
     defer out.interface.flush() catch {};
@@ -51,9 +52,9 @@ pub fn main(init: std.process.Init) !void {
         try out.interface.print(help_mgs, .{});
         return;
     }
-    var fil = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
+    var fil: Io.File = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
     defer fil.close(io);
-    var arc: squashfs.Archive = try .init(io, fil, offset); //TODO: Update when memory size matters. //TODO: Handle error gracefully.
+    var arc: squashfs.Archive = try .init(io, fil, offset); //TODO: Handle error gracefully.
     const options: squashfs.ExtractionOptions = .{
         .threads = if (threads == 0) try std.Thread.getCpuCount() else threads,
         .verbose = verbose,
@@ -63,7 +64,7 @@ pub fn main(init: std.process.Init) !void {
     };
     if (force)
         try Io.Dir.cwd().deleteTree(io, extLoc);
-    try arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
+    try arc.extract(alloc, extLoc, options); //TODO: Handle error gracefully.
 }
 
 fn handleArgs(args: std.process.Args, out: *Writer) !void {

src/decomp.zig

@@ -0,0 +1,31 @@
+const std = @import("std");
+
+pub const StatelessDecomp = *const fn (std.mem.Allocator, in: []u8, out: []u8) Error!usize;
+
+pub const Error = error{
+    OutOfMemory,
+    EndOfStream,
+    ReadFailed,
+    WriteFailed,
+};
+
+const Decompressor = @This();
+
+alloc: std.mem.Allocator = std.heap.smp_allocator,
+vtable: *const struct {
+    decompress: *const fn (*const Decompressor, in: []u8, out: []u8) Error!usize = defaultDecompress,
+    stateless: StatelessDecomp,
+},
+
+/// Create a copy of the decompressor using it's stateless function and the new allocator.
+pub fn statelessCopy(self: Decompressor, alloc: std.mem.Allocator) Decompressor {
+    return &.{ .alloc = alloc, .vtable = &.{ .stateless = self.vtable.stateless } };
+}
+
+pub fn decompress(self: *const Decompressor, in: []u8, out: []u8) Error!usize {
+    return self.vtable.decompress(self, in, out);
+}
+
+fn defaultDecompress(self: *const Decompressor, in: []u8, out: []u8) Error!usize {
+    return self.vtable.stateless(self.alloc, in, out);
+}

src/decomp/c/lz4.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+
+const c = @import("c");
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
+
+pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    const res = c.LZ4_decompress_safe(in.ptr, out.ptr, @intCast(in.len), @intCast(out.len));
+    if (res > 0) return @abs(res);
+    return Decompressor.Error.ReadFailed; // TOOD: Find out what errors can be returned.
+}

src/decomp/c/lzma.zig

@@ -0,0 +1,142 @@
+const std = @import("std");
+
+const c = @import("c");
+const Decompressor = @import("../../decomp.zig");
+
+const Lzma = @This();
+
+streams: std.AutoHashMap(std.Thread.Id, c.lzma_stream),
+
+interface: Decompressor,
+
+err: ?Error = null,
+
+pub fn init(alloc: std.mem.Allocator) !Lzma {
+    return .{
+        .streams = try .init(alloc),
+        .interface = &.{
+            .alloc = alloc,
+            .vtable = .{ .decompress = decompress, .stateless = stateless },
+        },
+    };
+}
+pub fn deinit(self: *Lzma) void {
+    var values = self.streams.valueIterator();
+    while (values.next()) |val| {
+        c.lzma_end(val);
+    }
+    self.streams.deinit();
+}
+
+fn getOrCreate(self: *Lzma) !*c.lzma_stream {
+    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
+    if (res.found_existing) return res.value_ptr;
+    res.value_ptr.* = .{
+        .alloc = .{
+            .alloc = lzmaAlloc,
+            .free = lzmaFree,
+            .@"opaque" = &self.interface.alloc,
+        },
+    };
+    return res.value_ptr;
+}
+
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+    var self: *Lzma = @fieldParentPtr("interface", decomp);
+
+    const stream = try self.getOrCreate();
+    stream.next_in = in.ptr;
+    stream.avail_in = in.len;
+    stream.next_out = out.ptr;
+    stream.avail_out = out.len;
+    var res = c.lzma_alone_decoder(stream, out.len);
+    decodeResult(res) catch |err| {
+        self.err = err;
+        return lzmaErrorToDecompError(err);
+    };
+    while (true) {
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+        if (res == c.LZMA_OK) continue;
+        if (res == c.LZMA_STREAM_END) break;
+        decodeResult(res) catch |err| {
+            self.err = err;
+            return lzmaErrorToDecompError(err);
+        };
+    }
+    return stream.total_out;
+}
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var stream: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+        .allocator = &.{
+            .alloc = lzmaAlloc,
+            .free = lzmaFree,
+            .@"opaque" = @ptrCast(@constCast(&alloc)),
+        },
+    };
+    var res = c.lzma_alone_decoder(&stream, out.len);
+    decodeResult(res) catch |err| return lzmaErrorToDecompError(err);
+    while (true) {
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+        if (res == c.LZMA_OK) continue;
+        if (res == c.LZMA_STREAM_END) break;
+        decodeResult(res) catch |err| return lzmaErrorToDecompError(err);
+    }
+    return stream.total_out;
+}
+
+inline fn decodeResult(res: c_uint) Error!void {
+    return switch (res) {
+        c.LZMA_OK => {},
+        c.LZMA_STREAM_END => {},
+        c.LZMA_NO_CHECK => {},
+        c.LZMA_UNSUPPORTED_CHECK => Error.UnsupportedCheck,
+        c.LZMA_MEM_ERROR => Error.OutOfMemory,
+        c.LZMA_MEMLIMIT_ERROR => Error.OutOfMemory,
+        c.LZMA_FORMAT_ERROR => Error.Format,
+        c.LZMA_OPTIONS_ERROR => Error.Options,
+        c.LZMA_DATA_ERROR => Error.Data,
+        c.LZMA_BUF_ERROR => Error.BufferExhausted,
+        c.LZMA_PROG_ERROR => Error.Programming,
+        c.LZMA_SEEK_NEEDED => Error.SeekNeeded,
+        else => Error.Unknown,
+    };
+}
+fn lzmaErrorToDecompError(err: Error) Decompressor.Error {
+    switch (err) {
+        Error.OutOfMemory => return Decompressor.Error.OutOfMemory,
+        Error.UnsupportedCheck => return Decompressor.Error.ReadFailed,
+        Error.Format => return Decompressor.Error.ReadFailed,
+        Error.Options => return Decompressor.Error.ReadFailed,
+        Error.Data => return Decompressor.Error.ReadFailed,
+        Error.BufferExhausted => return Decompressor.Error.WriteFailed,
+        Error.Programming => return Decompressor.Error.ReadFailed,
+        Error.SeekNeeded => return Decompressor.Error.ReadFailed,
+        Error.Unknown => return Decompressor.Error.ReadFailed,
+    }
+}
+
+fn lzmaAlloc(ptr: ?*anyopaque, _: usize, size: usize) callconv(.c) ?*anyopaque {
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    return alloc.rawAlloc(size, .@"1", 0);
+}
+fn lzmaFree(ptr: ?*anyopaque, alloc_ptr: ?*anyopaque) callconv(.c) void {
+    if (alloc_ptr == null) return;
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    alloc.rawFree(@ptrCast(alloc_ptr), .@"1", 0);
+}
+
+pub const Error = error{
+    OutOfMemory,
+    UnsupportedCheck,
+    Format,
+    Options,
+    Data,
+    BufferExhausted,
+    Programming,
+    SeekNeeded,
+    Unknown,
+};

src/decomp/c/lzo.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+
+const c = @import("c");
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
+
+pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var out_len = out.len;
+    const res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &out_len, null);
+    return switch (res) {
+        c.LZO_E_OK => out_len,
+        c.LZO_E_ERROR => Decompressor.Error.ReadFailed,
+        c.LZO_E_OUT_OF_MEMORY => Decompressor.Error.OutOfMemory,
+        c.LZO_E_NOT_COMPRESSIBLE => Decompressor.Error.ReadFailed,
+        c.LZO_E_INPUT_OVERRUN => Decompressor.Error.ReadFailed,
+        c.LZO_E_OUTPUT_OVERRUN => Decompressor.Error.WriteFailed,
+        c.LZO_E_LOOKBEHIND_OVERRUN => Decompressor.Error.ReadFailed,
+        c.LZO_E_EOF_NOT_FOUND => Decompressor.Error.ReadFailed,
+        c.LZO_E_INPUT_NOT_CONSUMED => Decompressor.Error.ReadFailed,
+        c.LZO_E_NOT_YET_IMPLEMENTED => Decompressor.Error.ReadFailed,
+        c.LZO_E_INVALID_ARGUMENT => Decompressor.Error.ReadFailed,
+        c.LZO_E_INVALID_ALIGNMENT => Decompressor.Error.ReadFailed,
+        c.LZO_E_OUTPUT_NOT_CONSUMED => Decompressor.Error.WriteFailed,
+        c.LZO_E_INTERNAL_ERROR => Decompressor.Error.ReadFailed,
+        else => Decompressor.Error.ReadFailed,
+    };
+}

src/decomp/c/xz.zig

@@ -0,0 +1,142 @@
+const std = @import("std");
+
+const c = @import("c");
+const Decompressor = @import("../../decomp.zig");
+
+const Xz = @This();
+
+streams: std.AutoHashMap(std.Thread.Id, c.lzma_stream),
+
+interface: Decompressor,
+
+err: ?Error = null,
+
+pub fn init(alloc: std.mem.Allocator) !Xz {
+    return .{
+        .streams = try .init(alloc),
+        .interface = &.{
+            .alloc = alloc,
+            .vtable = .{ .decompress = decompress, .stateless = stateless },
+        },
+    };
+}
+pub fn deinit(self: *Xz) void {
+    var values = self.streams.valueIterator();
+    while (values.next()) |val| {
+        c.xz_end(val);
+    }
+    self.streams.deinit();
+}
+
+fn getOrCreate(self: *Xz) !*c.xz_stream {
+    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
+    if (res.found_existing) return res.value_ptr;
+    res.value_ptr.* = .{
+        .alloc = .{
+            .alloc = lzmaAlloc,
+            .free = lzmaFree,
+            .@"opaque" = &self.interface.alloc,
+        },
+    };
+    return res.value_ptr;
+}
+
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+    var self: *Xz = @fieldParentPtr("interface", decomp);
+
+    const stream = try self.getOrCreate();
+    stream.next_in = in.ptr;
+    stream.avail_in = in.len;
+    stream.next_out = out.ptr;
+    stream.avail_out = out.len;
+    var res = c.lzma_alone_decoder(stream, out.len);
+    decodeResult(res) catch |err| {
+        self.err = err;
+        return xzErrorToDecompError(err);
+    };
+    while (true) {
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+        if (res == c.LZMA_OK) continue;
+        if (res == c.LZMA_STREAM_END) break;
+        decodeResult(res) catch |err| {
+            self.err = err;
+            return xzErrorToDecompError(err);
+        };
+    }
+    return stream.total_out;
+}
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var stream: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+        .allocator = &.{
+            .alloc = lzmaAlloc,
+            .free = lzmaFree,
+            .@"opaque" = @ptrCast(@constCast(&alloc)),
+        },
+    };
+    var res = c.lzma_alone_decoder(&stream, out.len);
+    decodeResult(res) catch |err| return xzErrorToDecompError(err);
+    while (true) {
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+        if (res == c.LZMA_OK) continue;
+        if (res == c.LZMA_STREAM_END) break;
+        decodeResult(res) catch |err| return xzErrorToDecompError(err);
+    }
+    return stream.total_out;
+}
+
+inline fn decodeResult(res: c_uint) Error!void {
+    return switch (res) {
+        c.LZMA_OK => {},
+        c.LZMA_STREAM_END => {},
+        c.LZMA_NO_CHECK => {},
+        c.LZMA_UNSUPPORTED_CHECK => Error.UnsupportedCheck,
+        c.LZMA_MEM_ERROR => Error.OutOfMemory,
+        c.LZMA_MEMLIMIT_ERROR => Error.OutOfMemory,
+        c.LZMA_FORMAT_ERROR => Error.Format,
+        c.LZMA_OPTIONS_ERROR => Error.Options,
+        c.LZMA_DATA_ERROR => Error.Data,
+        c.LZMA_BUF_ERROR => Error.BufferExhausted,
+        c.LZMA_PROG_ERROR => Error.Programming,
+        c.LZMA_SEEK_NEEDED => Error.SeekNeeded,
+        else => Error.Unknown,
+    };
+}
+fn xzErrorToDecompError(err: Error) Decompressor.Error {
+    switch (err) {
+        Error.OutOfMemory => return Decompressor.Error.OutOfMemory,
+        Error.UnsupportedCheck => return Decompressor.Error.ReadFailed,
+        Error.Format => return Decompressor.Error.ReadFailed,
+        Error.Options => return Decompressor.Error.ReadFailed,
+        Error.Data => return Decompressor.Error.ReadFailed,
+        Error.BufferExhausted => return Decompressor.Error.WriteFailed,
+        Error.Programming => return Decompressor.Error.ReadFailed,
+        Error.SeekNeeded => return Decompressor.Error.ReadFailed,
+        Error.Unknown => return Decompressor.Error.ReadFailed,
+    }
+}
+
+fn lzmaAlloc(ptr: ?*anyopaque, _: usize, size: usize) callconv(.c) ?*anyopaque {
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    return alloc.rawAlloc(size, .@"1", 0);
+}
+fn lzmaFree(ptr: ?*anyopaque, alloc_ptr: ?*anyopaque) callconv(.c) void {
+    if (alloc_ptr == null) return;
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    alloc.rawFree(@ptrCast(alloc_ptr), .@"1", 0);
+}
+
+pub const Error = error{
+    OutOfMemory,
+    UnsupportedCheck,
+    Format,
+    Options,
+    Data,
+    BufferExhausted,
+    Programming,
+    SeekNeeded,
+    Unknown,
+};

src/decomp/c/zlib.zig

@@ -0,0 +1,106 @@
+const std = @import("std");
+
+const c = @import("c");
+const Decompressor = @import("../../decomp.zig");
+
+const Zlib = @This();
+
+streams: std.AutoHashMap(std.Thread.Id, c.zng_stream),
+
+interface: Decompressor,
+
+err: ?Error = null,
+
+pub fn init(alloc: std.mem.Allocator) !Zlib {
+    return .{
+        .streams = try .init(alloc),
+        .interface = &.{
+            .alloc = alloc,
+            .vtable = .{ .decompress = decompress, .stateless = stateless },
+        },
+    };
+}
+pub fn deinit(self: *Zlib) void {
+    var values = self.streams.valueIterator();
+    while (values.next()) |val| {
+        _ = c.zng_deflateEnd(val);
+    }
+    self.streams.deinit();
+}
+
+fn getOrCreate(self: *Zlib) !*c.zng_stream {
+    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
+    if (res.found_existing) return res.value_ptr;
+    res.value_ptr.* = .{
+        .@"opaque" = self,
+        .zalloc = zalloc,
+        .zfree = zfree,
+    };
+    return res.value_ptr;
+}
+
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+    var self: *Zlib = @fieldParentPtr("interface", decomp);
+
+    var stream = try self.getOrCreate();
+    stream.next_in = in.ptr;
+    stream.avail_in = in.len;
+    stream.next_out = out.ptr;
+    stream.avail_out = out.len;
+    var res = c.zng_inflateReset(stream);
+    decodeError(res) catch |err| {
+        self.err = err;
+        return Decompressor.Error.ReadFailed;
+    };
+    res = c.zng_inflate(stream, c.Z_FINISH);
+    decodeError(res) catch |err| {
+        self.err = err;
+        return switch (err) {
+            Error.OutOfMemory => err,
+            else => Decompressor.Error.ReadFailed,
+        };
+    };
+}
+
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    _ = alloc;
+    var out_len = out.len;
+    const res = c.zng_uncompress(out.ptr, &out_len, in.ptr, in.len);
+    return switch (res) {
+        c.Z_OK => out_len,
+        c.Z_MEM_ERROR => Decompressor.Error.OutOfMemory,
+        c.Z_BUF_ERROR => Decompressor.Error.WriteFailed,
+        else => Decompressor.Error.ReadFailed,
+    };
+}
+
+inline fn decodeError(res: i32) Error!void {
+    return switch (res) {
+        c.Z_OK => {},
+        c.Z_STREAM_ERROR => Error.Stream,
+        c.Z_BUF_ERROR => Error.Buffer,
+        c.Z_MEM_ERROR => Error.OutOfMemory,
+        c.Z_DATA_ERROR => Error.Data,
+        c.Z_VERSION_ERROR => Error.Version,
+        else => Error.Unknown,
+    };
+}
+
+fn zalloc(ptr: ?*anyopaque, items: c_uint, size: c_uint) callconv(.c) ?*anyopaque {
+    var self: *Zlib = @ptrCast(ptr);
+    return self.interface.alloc.rawAlloc(items * size, .@"1", 0);
+}
+
+fn zfree(ptr: ?*anyopaque, addr: ?*anyopaque) callconv(.c) void {
+    var self: *Zlib = @ptrCast(ptr);
+    self.interface.alloc.rawFree(@ptrCast(addr), .@"1", 0);
+}
+
+pub const Error = error{
+    OutOfMemory,
+    Stream,
+    Buffer,
+    Data,
+    Version,
+    Unknown,
+};

src/decomp/c/zstd.zig

@@ -0,0 +1,172 @@
+const std = @import("std");
+
+const c = @import("c");
+const Decompressor = @import("../../decomp.zig");
+
+const Zstd = @This();
+
+context: std.AutoHashMap(std.Thread.Id, ?*c.ZSTD_DCtx),
+
+interface: Decompressor,
+
+err: ?Error = null,
+
+pub fn init(alloc: std.mem.Allocator) !Zstd {
+    return .{
+        .streams = try .init(alloc),
+        .interface = &.{
+            .alloc = alloc,
+            .vtable = .{ .decompress = decompress, .stateless = stateless },
+        },
+    };
+}
+pub fn deinit(self: *Zstd) void {
+    var values = self.context.valueIterator();
+    while (values.next()) |val| {
+        _ = c.ZSTD_freeDCtx(val.*);
+    }
+    self.context.deinit();
+}
+
+fn getOrCreate(self: *Zstd) !*c.ZSTD_DCtx {
+    const res = try self.context.getOrPut(std.Thread.getCurrentId());
+    if (res.found_existing) return res.value_ptr;
+    res.value_ptr.* = c.ZSTD_createDCtx();
+    if (res.value_ptr.* == null) return Error.OutOfMemory;
+    return res.value_ptr;
+}
+
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+    var self: *Zstd = @fieldParentPtr("interface", decomp);
+
+    const ctx = self.getOrCreate();
+    const res = c.ZSTD_decompressDCtx(ctx, out.ptr, out.len, in.ptr, in.len);
+    decodeError(res) catch |err| {
+        self.err = err;
+        return ZstdErrorToDecompError(err);
+    };
+    return res;
+}
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    _ = alloc;
+    const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
+    decodeError(res) catch |err| return ZstdErrorToDecompError(err);
+    return res;
+}
+
+inline fn decodeError(res: usize) Error!void {
+    if (c.ZSTD_isError(res) == 0) return;
+    return switch (c.ZSTD_getErrorCode(res)) {
+        c.ZSTD_error_prefix_unknown => Error.PrefixUnknown,
+        c.ZSTD_error_version_unsupported => Error.VersionUnsupported,
+        c.ZSTD_error_frameParameter_unsupported => Error.FrameParameterUnsupported,
+        c.ZSTD_error_frameParameter_windowTooLarge => Error.FrameParameterWindowTooLarge,
+        c.ZSTD_error_corruption_detected => Error.CorruptionDetected,
+        c.ZSTD_error_checksum_wrong => Error.ChecksumWrong,
+        c.ZSTD_error_literals_headerWrong => Error.LiteralsHeaderWrong,
+        c.ZSTD_error_dictionary_corrupted => Error.DictionaryCorrupted,
+        c.ZSTD_error_dictionary_wrong => Error.DictionaryWrong,
+        c.ZSTD_error_dictionaryCreation_failed => Error.DictionaryCreationFailed,
+        c.ZSTD_error_parameter_unsupported => Error.ParameterUnsupported,
+        c.ZSTD_error_parameter_combination_unsupported => Error.ParameterCombinationUnsupported,
+        c.ZSTD_error_parameter_outOfBound => Error.ParameterOutOfBound,
+        c.ZSTD_error_tableLog_tooLarge => Error.TableLogTooLarge,
+        c.ZSTD_error_maxSymbolValue_tooLarge => Error.MaxSymbolValueTooLarge,
+        c.ZSTD_error_maxSymbolValue_tooSmall => Error.MaxSymbolValueTooSmall,
+        c.ZSTD_error_cannotProduce_uncompressedBlock => Error.CannotProduceUncompressedBlock,
+        c.ZSTD_error_stabilityCondition_notRespected => Error.StabilityConditionNotRespected,
+        c.ZSTD_error_stage_wrong => Error.StageWrong,
+        c.ZSTD_error_init_missing => Error.InitMissing,
+        c.ZSTD_error_memory_allocation => Error.MemoryAllocation,
+        c.ZSTD_error_workSpace_tooSmall => Error.WorkSpaceTooSmall,
+        c.ZSTD_error_dstSize_tooSmall => Error.DstSizeTooSmall,
+        c.ZSTD_error_srcSize_wrong => Error.SrcSizeWrong,
+        c.ZSTD_error_dstBuffer_null => Error.DstBufferNull,
+        c.ZSTD_error_noForwardProgress_destFull => Error.NoForwardProgressDestFull,
+        c.ZSTD_error_noForwardProgress_inputEmpty => Error.NoForwardProgressInputEmpty,
+        c.ZSTD_error_frameIndex_tooLarge => Error.FrameIndexTooLarge,
+        c.ZSTD_error_seekableIO => Error.SeekableIo,
+        c.ZSTD_error_dstBuffer_wrong => Error.DstBufferWrong,
+        c.ZSTD_error_srcBuffer_wrong => Error.SrcBufferWrong,
+        c.ZSTD_error_sequenceProducer_failed => Error.SequenceProducerFailed,
+        c.ZSTD_error_externalSequences_invalid => Error.ExternalSequencesInvalid,
+        else => Error.Generic,
+    };
+}
+inline fn ZstdErrorToDecompError(err: Error) Decompressor.Error {
+    return switch (err) {
+        Error.OutOfMemory => Decompressor.Error.OutOfMemory,
+        Error.Generic => Decompressor.Error.ReadFailed,
+        Error.PrefixUnknown => Decompressor.Error.ReadFailed,
+        Error.VersionUnsupported => Decompressor.Error.ReadFailed,
+        Error.FrameParameterUnsupported => Decompressor.Error.ReadFailed,
+        Error.FrameParameterWindowTooLarge => Decompressor.Error.ReadFailed,
+        Error.CorruptionDetected => Decompressor.Error.ReadFailed,
+        Error.ChecksumWrong => Decompressor.Error.ReadFailed,
+        Error.LiteralsHeaderWrong => Decompressor.Error.ReadFailed,
+        Error.DictionaryCorrupted => Decompressor.Error.ReadFailed,
+        Error.DictionaryWrong => Decompressor.Error.ReadFailed,
+        Error.DictionaryCreationFailed => Decompressor.Error.ReadFailed,
+        Error.ParameterUnsupported => Decompressor.Error.ReadFailed,
+        Error.ParameterCombinationUnsupported => Decompressor.Error.ReadFailed,
+        Error.ParameterOutOfBound => Decompressor.Error.ReadFailed,
+        Error.TableLogTooLarge => Decompressor.Error.ReadFailed,
+        Error.MaxSymbolValueTooLarge => Decompressor.Error.ReadFailed,
+        Error.MaxSymbolValueTooSmall => Decompressor.Error.ReadFailed,
+        Error.CannotProduceUncompressedBlock => Decompressor.Error.ReadFailed,
+        Error.StabilityConditionNotRespected => Decompressor.Error.ReadFailed,
+        Error.StageWrong => Decompressor.Error.ReadFailed,
+        Error.InitMissing => Decompressor.Error.ReadFailed,
+        Error.MemoryAllocation => Decompressor.Error.OutOfMemory,
+        Error.WorkSpaceTooSmall => Decompressor.Error.WriteFailed,
+        Error.DstSizeTooSmall => Decompressor.Error.WriteFailed,
+        Error.SrcSizeWrong => Decompressor.Error.ReadFailed,
+        Error.DstBufferNull => Decompressor.Error.WriteFailed,
+        Error.NoForwardProgressDestFull => Decompressor.Error.WriteFailed,
+        Error.NoForwardProgressInputEmpty => Decompressor.Error.ReadFailed,
+        Error.FrameIndexTooLarge => Decompressor.Error.ReadFailed,
+        Error.SeekableIo => Decompressor.Error.ReadFailed,
+        Error.DstBufferWrong => Decompressor.Error.WriteFailed,
+        Error.SrcBufferWrong => Decompressor.Error.ReadFailed,
+        Error.SequenceProducerFailed => Decompressor.Error.ReadFailed,
+        Error.ExternalSequencesInvalid => Decompressor.Error.ReadFailed,
+    };
+}
+
+pub const Error = error{
+    OutOfMemory,
+    Generic,
+    PrefixUnknown,
+    VersionUnsupported,
+    FrameParameterUnsupported,
+    FrameParameterWindowTooLarge,
+    CorruptionDetected,
+    ChecksumWrong,
+    LiteralsHeaderWrong,
+    DictionaryCorrupted,
+    DictionaryWrong,
+    DictionaryCreationFailed,
+    ParameterUnsupported,
+    ParameterCombinationUnsupported,
+    ParameterOutOfBound,
+    TableLogTooLarge,
+    MaxSymbolValueTooLarge,
+    MaxSymbolValueTooSmall,
+    CannotProduceUncompressedBlock,
+    StabilityConditionNotRespected,
+    StageWrong,
+    InitMissing,
+    MemoryAllocation,
+    WorkSpaceTooSmall,
+    DstSizeTooSmall,
+    SrcSizeWrong,
+    DstBufferNull,
+    NoForwardProgressDestFull,
+    NoForwardProgressInputEmpty,
+    FrameIndexTooLarge,
+    SeekableIo,
+    DstBufferWrong,
+    SrcBufferWrong,
+    SequenceProducerFailed,
+    ExternalSequencesInvalid,
+};

src/decomp/lzma.zig

@@ -1,77 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const lzma = std.compress.lzma;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList,
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        const buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return lzmaDecomp(buf, in, out);
-    }
-    var self: Self = @fieldParentPtr("interface", d.?);
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .{}, try self.alloc.alloc(u8, self.block_size + lzma.block_size_max) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return lzmaDecomp(self.alloc, &buf.buf, in, out);
-}
-
-inline fn lzmaDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = try lzma.Decompress.initOptions(&rdr, alloc, buffer.*, .{ .allow_incomplete = true }, 3 * 1024 * 1024);
-    defer {
-        buffer.* = d.takeBuffer();
-        d.deinit();
-    }
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-    return lzmaDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-}

src/decomp/types.zig

@@ -0,0 +1,64 @@
+const config = @import("config");
+
+const Decompressor = @import("../decomp.zig");
+
+pub fn getStatelessFn(decomp: Enum) !Decompressor.StatelessDecomp {
+    if (config.use_zig_decomp) {
+        return switch (decomp) {
+            .gzip => @import("zig/zlib.zig").stateless,
+            .lzma => @import("zig/lzma.zig").stateless,
+            .xz => @import("zig/xz.zig").stateless,
+            .zstd => @import("zig/zstd.zig").stateless,
+            .lz4 => error.ZigLz4Unsupported,
+            .lzo => error.ZigLzoUnsupported,
+        };
+    }
+    return switch (decomp) {
+        .gzip => @import("c/zlib.zig").stateless,
+        .lzma => @import("c/lzma.zig").stateless,
+        .lzo => @import("c/lzo.zig").stateless,
+        .xz => @import("c/xz.zig").stateless,
+        .lz4 => @import("c/lz4.zig").stateless,
+        .zstd => @import("c/zstd.zig").stateless,
+    };
+}
+
+pub const Enum = enum(u16) {
+    gzip = 1, // Though officially named gzip, it actually uses zlib.
+    lzma,
+    lzo,
+    xz,
+    lz4,
+    zstd,
+};
+
+pub const Decomp = if (config.use_zig_decomp)
+    union(enum) {
+        gzip: @import("zig/zlib.zig"),
+        lzma: @import("zig/lzma.zig"),
+        xz: @import("zig/xz.zig"),
+        zstd: @import("zig/zstd.zig"),
+
+        pub fn deinit(_: *Decomp) void {
+            return;
+        }
+    }
+else
+    union(enum) {
+        gzip: @import("c/zlib.zig"),
+        lzma: @import("c/lzma.zig"),
+        lzo: @import("c/lzo.zig"),
+        xz: @import("c/xz.zig"),
+        lz4: @import("c/lz4.zig"),
+        zstd: @import("c/zstd.zig"),
+
+        pub fn deinit(self: *Decomp) void {
+            switch (self) {
+                .gzip => self.gzip.deinit(),
+                .lzma => self.lzma.deinit(),
+                .xz => self.xz.deinit(),
+                .zstd => self.zstd.deinit(),
+                else => {},
+            }
+        }
+    };

src/decomp/xz.zig

@@ -1,77 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const xz = std.compress.xz;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList,
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        const buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return lzmaDecomp(buf, in, out);
-    }
-    var self: Self = @fieldParentPtr("interface", d.?);
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .{}, try self.alloc.alloc(u8, self.block_size + xz.block_size_max) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return lzmaDecomp(self.alloc, &buf.buf, in, out);
-}
-
-inline fn lzmaDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = try xz.Decompress.init(&rdr, alloc, buffer.*);
-    defer {
-        buffer.* = d.takeBuffer();
-        d.deinit();
-    }
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-    return lzmaDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-}

src/decomp/zig/lzma.zig

@@ -0,0 +1,23 @@
+const std = @import("std");
+const lzma = std.compress.lzma;
+const Reader = std.Io.Reader;
+
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
+
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var rdr: Reader = .fixed(in);
+    const buf = try alloc.alloc(u8, in.len);
+    defer alloc.free(buf);
+
+    var decomp = lzma.Decompress.initOptions(&rdr, alloc, buf, .{}, out.len) catch |err|
+        return switch (err) {
+            error.Overflow => Decompressor.Error.ReadFailed,
+            error.CorruptInput => Decompressor.Error.ReadFailed,
+            error.InvalidRangeCode => Decompressor.Error.ReadFailed,
+            else => @errorCast(err),
+        };
+    defer decomp.deinit();
+    return decomp.reader.readSliceShort(out);
+}

src/decomp/zig/xz.zig

@@ -0,0 +1,22 @@
+const std = @import("std");
+const xz = std.compress.xz;
+const Reader = std.Io.Reader;
+
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
+
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var rdr: Reader = .fixed(in);
+    const buf = try alloc.alloc(u8, in.len);
+    defer alloc.free(buf);
+
+    var decomp = xz.Decompress.init(&rdr, alloc, buf) catch |err|
+        return switch (err) {
+            error.WrongChecksum => Decompressor.Error.ReadFailed,
+            error.NotXzStream => Decompressor.Error.ReadFailed,
+            else => @errorCast(err),
+        };
+    defer decomp.deinit();
+    return decomp.reader.readSliceShort(out);
+}

src/decomp/zig/zlib.zig

@@ -0,0 +1,16 @@
+const std = @import("std");
+const flate = std.compress.flate;
+const Reader = std.Io.Reader;
+
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
+
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var rdr: Reader = .fixed(in);
+    const buf = try alloc.alloc(u8, out.len);
+    defer alloc.free(buf);
+
+    var decomp = flate.Decompress.init(&rdr, .zlib, buf);
+    return decomp.reader.readSliceShort(out);
+}

src/decomp/zig/zstd.zig

@@ -0,0 +1,16 @@
+const std = @import("std");
+const zstd = std.compress.zstd;
+const Reader = std.Io.Reader;
+
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = &.{ .stateless = stateless } },
+
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var rdr: Reader = .fixed(in);
+    const buf = try alloc.alloc(u8, out.len * 2);
+    defer alloc.free(buf);
+
+    var decomp = zstd.Decompress.init(&rdr, buf, .{ .window_len = @truncate(out.len) });
+    return decomp.reader.readSliceShort(out);
+}

src/decomp/zlib.zig

@@ -1,73 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const flate = std.compress.flate;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList,
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        const buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return zlibDecomp(buf, in, out);
-    }
-    var self: Self = @fieldParentPtr("interface", d.?);
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .{}, try self.alloc.alloc(u8, self.block_size) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return zlibDecomp(buf.buf, in, out);
-}
-
-inline fn zlibDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = flate.Decompress.init(&rdr, .zlib, buffer);
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const buf = try alloc.alloc(u8, in.len * 2);
-    defer alloc.free(buf);
-    return zlibDecomp(buf, in, out);
-}

src/decomp/zstd.zig

@@ -1,73 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList,
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        const buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return zstdDecomp(buf, in, out);
-    }
-    var self: Self = @fieldParentPtr("interface", d.?);
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .{}, try self.alloc.alloc(u8, self.block_size + zstd.block_size_max) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return zstdDecomp(buf.buf, in, out);
-}
-
-inline fn zstdDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = zstd.Decompress.init(&rdr, buffer, .{ .window_len = @truncate(out.len) });
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const buf = try alloc.alloc(u8, out.len + zstd.block_size_max);
-    defer alloc.free(buf);
-    return zstdDecomp(buf, in, out);
-}

src/directory.zig

@@ -1,51 +1,34 @@
 const std = @import("std");
 const Reader = std.Io.Reader;
 
-const Inode = @import("inode.zig");
+const InodeType = @import("inode.zig").Type;
 
-const DirEntry = @This();
+pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) []Entry {
-
+    var read: u32 = 3;
-block_start: u32,
-block_offset: u16,
-type: Inode.Type,
-name: []const u8,
-
-pub fn deinit(self: DirEntry, alloc: std.mem.Allocator) void {
-    alloc.free(self.name);
-}
-
-pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) ![]DirEntry {
     var hdr: Header = undefined;
     var raw: RawEntry = undefined;
-    var out: std.ArrayList(DirEntry) = try .initCapacity(alloc, 30);
+    var out: std.ArrayList(Entry) = .initCapacity(alloc, 50);
     errdefer {
-        for (out.items) |ent|
+        for (out.items) |i|
-            alloc.free(ent.name);
+            alloc.free(i.name);
         out.deinit(alloc);
     }
-
+    while (read < size) {
-    var tot_red: u32 = 3;
-    while (tot_red < size) {
         try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
         try out.ensureUnusedCapacity(alloc, hdr.count + 1);
-
+        read += @sizeOf(Header);
-        tot_red += @sizeOf(Header);
+        for (0..hdr.count + 1) |_| {
-
-        for (hdr.count + 1) |_| {
             try rdr.readSliceEndian(RawEntry, @ptrCast(&raw), .little);
-
+            read += @sizeOf(RawEntry) + raw.name_size + 1;
-            const new_name = try alloc.alloc(u8, raw.name_size + 1);
-            try rdr.readSliceEndian(u8, new_name, .little);
-
             const new = out.addOneAssumeCapacity();
             new.* = .{
                 .block_start = hdr.block_start,
                 .block_offset = raw.block_offset,
-                .type = raw.type,
+                .num = @abs(hdr.num + raw.num_offset),
-                .name = new_name,
+                .inode_type = raw.inode_type,
+                .name = try alloc.alloc(u8, raw.name_size + 1),
             };
-
+            try rdr.readSliceEndian(u8, new.name, .little);
-            tot_red += @sizeOf(RawEntry) + raw.name_size + 1;
         }
     }
     return out.toOwnedSlice(alloc);
@@ -53,15 +36,28 @@ pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) ![]DirEn
 
 // Types
 
+pub const Entry = struct {
+    block_start: u32,
+    block_offset: u16,
+    num: u32,
+    inode_type: InodeType,
+    name: []u8,
+
+    pub fn deinit(self: Entry, alloc: std.mem.Allocator) void {
+        alloc.free(self.name);
+    }
+};
+
+// extern instead of packed due to alignment issues (packed will read it as 16 bytes instead of 12).
 const Header = extern struct {
     count: u32,
     block_start: u32,
     num: u32,
 };
 
-const RawEntry = extern struct {
+const RawEntry = packed struct {
     block_offset: u16,
     num_offset: i16,
-    type: Inode.Type,
+    inode_type: InodeType,
     name_size: u16,
 };

src/file.zig

@@ -1,124 +1,118 @@
-//! An easier to use wrapper around an inode.
-
 const std = @import("std");
 const Io = std.Io;
 
 const Archive = @import("archive.zig");
-const DirEntry = @import("directory.zig");
+const Decompressor = @import("decomp.zig");
+const Directory = @import("directory.zig");
 const ExtractionOptions = @import("options.zig");
 const Inode = @import("inode.zig");
-const DataExtractor = @import("util/data_extractor.zig");
+const DataReader = @import("util/data_reader.zig");
-const Decompressor = @import("util/decompressor.zig");
+const FileIter = @import("util/iter.zig");
 const MetadataReader = @import("util/metadata.zig");
-const SharedCache = @import("util/shared_cache.zig");
+const OffsetFile = @import("util/offset_file.zig");
+const Utils = @import("util/utils.zig");
+
+pub const Error = error{
+    NotDirectory,
+    NotRegularFile,
+};
 
 const File = @This();
 
-alloc: std.mem.Allocator,
+file: OffsetFile,
+super: Archive.MinimalSuperblock,
+decomp: Decompressor,
 
-archive: Archive,
-
-inode: Inode,
 name: []const u8,
+inode: Inode,
 
-/// Creates a new File from an inode. Takes ownership of the Inode and creates a copy of the given name.
+pub fn init(alloc: std.mem.Allocator, archive: Archive, entry: Directory.Entry) !File {
-/// Requires the given allocator was used to create the Inode.
+    const new_name = try alloc.alloc(u8, entry.name.len);
-pub fn init(alloc: std.mem.Allocator, archive: Archive, in: Inode, name: []const u8) !File {
+    errdefer alloc.free(new_name);
-    const new_name = try alloc.alloc(u8, name.len);
+    @memcpy(new_name, entry.name);
-    @memcpy(new_name, name);
     return .{
-        .alloc = alloc,
+        .file = archive.file,
-
+        .super = archive.super,
-        .archive = archive,
+        .decomp = archive.stateless_decomp.statelessCopy(alloc),
-
-        .inode = in,
         .name = new_name,
+        .inode = try Utils.readInode(
+            alloc,
+            &archive.decomp,
+            archive.file,
+            archive.super.inode_start,
+            archive.super.block_size,
+            entry.block_start,
+            entry.block_offset,
+        ),
     };
 }
-pub fn fromDirEntry(alloc: std.mem.Allocator, io: Io, archive: Archive, ent: DirEntry) !File {
-    var rdr = try archive.file.readerAt(io, archive.super.inode_start + ent.block_start, &[0]u8{});
-    var meta: MetadataReader = .init(alloc, &rdr.interface, &archive.stateless_decomp);
-    try meta.interface.discardAll(ent.block_offset);
-
-    var in: Inode = try .read(alloc, &meta.interface, archive.super.block_size);
-    errdefer in.deinit(alloc);
-    return .init(alloc, archive, in, ent.name);
-}
 pub fn deinit(self: File) void {
-    self.alloc.free(self.name);
+    self.decomp.alloc.free(self.name);
-    self.inode.deinit(self.alloc);
+    self.inode.deinit(self.decomp.alloc);
 }
 
-pub fn open(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
+// Directory functions
-    const entries = try self.inode.readDirectory(
-        alloc,
-        io,
-        self.archive.file,
-        &self.archive.stateless_decomp,
-        self.archive.super.dir_start,
-    );
-    defer {
-        for (entries) |ent|
-            alloc.free(ent.name);
-        alloc.free(entries);
-    }
-    const path = std.mem.trim(u8, filepath, "/");
-    const first_element: []u8 = std.mem.sliceTo(path, "/");
 
-    var search_slice = entries;
+pub fn isDir(self: File) bool {
-    var idx: usize = undefined;
+    return switch (self.inode.hdr.inode_type) {
-    while (search_slice.len > 0) {
+        .dir, .ext_dir => true,
-        idx = search_slice / 2;
+        else => false,
-        const middle = search_slice[idx];
-        switch (std.mem.order(u8, first_element, middle.name)) {
-            .eq => break,
-            .lt => search_slice = search_slice[0..idx],
-            .gt => search_slice = search_slice[idx + 1 ..],
-        }
-    } else return Error.FileNotFound;
-
-    const first_elem_file = try fromDirEntry(alloc, io, self.archive, search_slice[idx]);
-    if (first_element.len == path.len)
-        return first_elem_file;
-    defer first_elem_file.deinit();
-    return first_elem_file.open(alloc, io, path[first_element.len + 1 ..]);
-}
-
-pub fn extract(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8, options: ExtractionOptions) !void {
-    var cache: SharedCache = try .init(alloc, 10); // TODO: calculate a good initial cache size.
-    defer cache.deinit();
-    var decomp = switch (self.archive.super.compression) {
-        .gzip => {},
-        .lzma => {},
-        .xz => {},
-        .zstd => {},
-        else => unreachable,
     };
-    return self.extractReal(alloc, io, &cache, &decomp.interface, filepath, options);
 }
-fn extractReal(self: File, alloc: std.mem.Allocator, io: Io, cache: *SharedCache, decomp: *const Decompressor, filepath: []const u8, options: ExtractionOptions) !void {
+/// Opens a sub-file. If the given path is "" or "." (after trimming /) a copy of the File is returned.
-    _ = options;
+pub fn open(self: File, alloc: std.mem.Allocator, filepath: []const u8) !File {
-    switch (self.inode.hdr.inode_type) {
+    var res = try self.inode.findInode(
-        .file, .ext_file => {
+        alloc,
-            var ext = try self.inode.dataExtractor(
+        &self.decomp,
-                self.archive.file,
+        self.file,
-                cache,
+        self.super.dir_start,
-                decomp,
+        self.super.inode_start,
-                self.archive.super.block_size,
+        self.super.block_size,
+        filepath,
     );
-
+    if (res.name.len == 0) {
-            var atomic_file = try Io.Dir.cwd().createFileAtomic(io, filepath, .{});
+        res.name = try alloc.alloc(u8, self.name.len);
-            defer atomic_file.deinit(io);
+        @memcpy(res.name, self.name);
-
-            try ext.extract(alloc, io, atomic_file.file);
-            try atomic_file.link(io);
-        },
-        else => return error.TODO,
     }
+    return .{
+        .file = self.file,
+        .super = self.super,
+        .decomp = self.decomp.statelessCopy(alloc),
+        .name = res.name,
+        .inode = res.inode,
+    };
+}
+pub fn iter(self: File, alloc: std.mem.Allocator) !FileIter {
+    return .{
+        .alloc = alloc,
+        .entries = try self.inode.readDirectory(alloc, &self.decomp, self.file, self.super.dir_start),
+    };
 }
 
-// Types
+// Regular file functions
 
-pub const Error = error{
+pub fn isRegularFile(self: File) bool {
-    FileNotFound,
+    return switch (self.inode.hdr.inode_type) {
-} || Inode.Error;
+        .file, .ext_file => true,
+        else => false,
+    };
+}
+// a std.Io.Reader compatible reader that reads a regular file's data.
+pub fn dataReader(self: File, alloc: std.mem.Allocator) !DataReader {
+    return self.inode.dataReader(
+        &self.decomp.statelessCopy(alloc),
+        self.file,
+        self.super.frag_start,
+        self.super.block_size,
+    );
+}
+
+// Universal functions
+
+pub fn extract(self: File, alloc: std.mem.Allocator, path: []const u8, options: ExtractionOptions) !void {
+    _ = self;
+    _ = alloc;
+    _ = path;
+    _ = options;
+    return error.TODO;
+}

src/frag.zig

@@ -1,7 +0,0 @@
-const BlockSize = @import("inode_data/file.zig").BlockSize;
-
-pub const FragEntry = extern struct {
-    start: u64,
-    size: BlockSize,
-    _: u32,
-};

src/imports.c

@@ -0,0 +1,5 @@
+#include <zlib-ng.h>
+#include <lzo/minilzo.h>
+#include <lz4.h>
+#include <zstd.h>
+#include <lzma.h>

src/inode.zig

@@ -1,23 +1,22 @@
-//! A file-system object. Represents a File or directory.
+//! This is the raw squashfs representation of a file/directory.
+//! Most of the time using File is a better experience and using Inodes directory
+//! is only required for more technical use cases.
 
 const std = @import("std");
 const Reader = std.Io.Reader;
-const Io = std.Io;
 
-const Archive = @import("archive.zig");
+const Decompressor = @import("decomp.zig");
-const DirEntry = @import("directory.zig");
+const Directory = @import("directory.zig");
-const ExtractionOptions = @import("options.zig");
+const FragEntry = @import("archive.zig").FragEntry;
-const dir = @import("inode_data/dir.zig");
+const Dir = @import("inode/dir.zig");
-const file = @import("inode_data/file.zig");
+const File = @import("inode/file.zig");
-const misc = @import("inode_data/misc.zig");
+const Misc = @import("inode/misc.zig");
+const Sym = @import("inode/sym.zig");
 const LookupTable = @import("lookup_table.zig");
-const DataExtractor = @import("util/data_extractor.zig");
+const MinimalSuperblock = @import("archive.zig").MinimalSuperblock;
 const DataReader = @import("util/data_reader.zig");
-const Decompressor = @import("util/decompressor.zig");
 const MetadataReader = @import("util/metadata.zig");
 const OffsetFile = @import("util/offset_file.zig");
-const SharedCache = @import("util/shared_cache.zig");
-const XattrTable = @import("xattr_table.zig");
 
 const Inode = @This();
 
@@ -30,124 +29,105 @@ pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
     return .{
         .hdr = hdr,
         .data = switch (hdr.inode_type) {
-            .dir => .{ .dir = try .read(rdr) },
+            .dir => .{ .dir = .read(rdr) },
-            .file => .{ .file = try .read(alloc, rdr, block_size) },
+            .file => .{ .file = .read(alloc, rdr, block_size) },
-            .symlink => .{ .symlink = try .read(alloc, rdr) },
+            .symlink => .{ .symlink = .read(alloc, rdr) },
-            .block_dev => .{ .block_dev = try .read(rdr) },
+            .block => .{ .block = .read(rdr) },
-            .char_dev => .{ .char_dev = try .read(rdr) },
+            .char => .{ .char = .read(rdr) },
-            .fifo => .{ .fifo = try .read(rdr) },
+            .fifo => .{ .fifo = .read(rdr) },
-            .socket => .{ .socket = try .read(rdr) },
+            .sock => .{ .sock = .read(rdr) },
-            .ext_dir => .{ .ext_dir = try .read(rdr) },
+            .ext_dir => .{ .ext_dir = .read(rdr) },
-            .ext_file => .{ .ext_file = try .read(alloc, rdr, block_size) },
+            .ext_file => .{ .ext_file = .read(alloc, rdr, block_size) },
-            .ext_symlink => .{ .ext_symlink = try .read(alloc, rdr) },
+            .ext_symlink => .{ .ext_symlink = .read(alloc, rdr) },
-            .ext_block_dev => .{ .ext_block_dev = try .read(rdr) },
+            .ext_block => .{ .ext_block = .read(rdr) },
-            .ext_char_dev => .{ .ext_char_dev = try .read(rdr) },
+            .ext_char => .{ .ext_char = .read(rdr) },
-            .ext_fifo => .{ .ext_fifo = try .read(rdr) },
+            .ext_fifo => .{ .ext_fifo = .read(rdr) },
-            .ext_socket => .{ .ext_socket = try .read(rdr) },
+            .ext_sock => .{ .ext_sock = .read(rdr) },
         },
     };
 }
 pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
     switch (self.data) {
-        .file => |d| d.deinit(alloc),
+        .file => |f| alloc.free(f.block_sizes),
-        .symlink => |d| d.deinit(alloc),
+        .ext_file => |f| alloc.free(f.block_sizes),
-        .ext_file => |d| d.deinit(alloc),
+        .symlink => |s| alloc.free(s.target),
-        .ext_symlink => |d| d.deinit(alloc),
+        .ext_symlink => |s| alloc.free(s.target),
         else => {},
     }
 }
-
+pub fn copy(self: Inode, alloc: std.mem.Allocator) !Inode {
-// Utility Functions
+    switch (self.data) {
-
+        .dir,
-/// Read the directory entries
+        .ext_dir,
-pub fn readDirectory(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64) ![]DirEntry {
+        .block,
-    return switch (self.data) {
+        .ext_block,
-        .dir => |d| readDirFromData(alloc, io, fil, decomp, dir_offset, d),
+        .char,
-        .ext_dir => |d| readDirFromData(alloc, io, fil, decomp, dir_offset, d),
+        .ext_char,
-        else => Error.NotDirectory,
+        .fifo,
+        .ext_fifo,
+        .sock,
+        .ext_sock,
+        => return self,
+        .file => |f| {
+            const new_sizes = try alloc.alloc(File.BlockSize, f.block_sizes.len);
+            @memcpy(new_sizes, f.block_sizes);
+            return .{
+                .hdr = self.hdr,
+                .data = .{ .file = .{
+                    .block_start = f.block_start,
+                    .frag_idx = f.frag_idx,
+                    .block_offset = f.block_offset,
+                    .size = f.size,
+                    .block_sizes = new_sizes,
+                } },
             };
-}
+        },
-fn readDirFromData(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64, d: anytype) ![]DirEntry {
+        .ext_file => |f| {
-    var rdr = try fil.readerAt(io, dir_offset + d.block_start, &[0]u8{});
+            const new_sizes = try alloc.alloc(File.BlockSize, f.block_sizes.len);
-    var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
+            @memcpy(new_sizes, f.block_sizes);
-    try meta.interface.discardAll(d.block_offset);
+            return .{
-
+                .hdr = self.hdr,
-    return DirEntry.readDirectory(alloc, &meta.interface, d.size);
+                .data = .{ .ext_file = .{
-}
+                    .block_start = self.block_start,
-/// Get a reader for a regular file's data.
+                    .size = self.size,
-pub fn dataReader(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32) !DataReader {
+                    .sparse = self.sparse,
-    return switch (self.data) {
+                    .hard_links = self.hard_links,
-        .file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
+                    .frag_idx = self.frag_idx,
-        .ext_file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
+                    .block_offset = self.block_offset,
-        else => Error.NotRegularFile,
+                    .xattr_idx = self.xattr_idx,
+                    .block_sizes = new_sizes,
+                } },
             };
-}
+        },
-fn getReaderFromData(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataReader {
+        .symlink => |s| {
-    const ext: DataReader = .init(alloc, io, fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
+            const new_target = try alloc.alloc(u8, s.target.len);
-    if (d.frag_block_offset == 0xFFFFFFFF) {
+            @memcpy(new_target, s.target);
-        // TODO:
+            return .{
-        return error.TODO;
+                .hdr = self.hdr,
-    }
+                .data = .{ .symlink = .{
-    return ext;
+                    .hard_links = s.hard_links,
-}
+                    .target = new_target,
-/// Get an extractor for a regular file's data.
+                } },
-pub fn dataExtractor(self: Inode, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32) !DataExtractor {
-    return switch (self.data) {
-        .file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
-        .ext_file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
-        else => Error.NotRegularFile,
             };
-}
+        },
-fn getExtractorFromData(fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataExtractor {
+        .ext_symlink => |s| {
-    const ext: DataExtractor = .init(fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
+            const new_target = try alloc.alloc(u8, s.target.len);
-    if (d.frag_block_offset == 0xFFFFFFFF) {
+            @memcpy(new_target, s.target);
-        // TODO:
+            return .{
-        return error.TODO;
+                .hdr = self.hdr,
-    }
+                .data = .{ .ext_symlink = .{
-    return ext;
+                    .hard_links = s.hard_links,
-}
+                    .xattr_idx = s.xattr_idx,
-// Get a symlink's target path
+                    .target = new_target,
-pub fn symlinkTarget(self: Inode) ![]const u8 {
+                } },
-    return switch (self.data) {
-        .symlink => |s| s.target,
-        .ext_symlink => |s| s.target,
-        else => Error.NotSymlink,
             };
+        },
     }
-// Get inode's gid
-pub fn gid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, id_table_start: u64) !u16 {
-    return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.gid_idx);
-}
-// Get inode's uid
-pub fn uid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, id_table_start: u64) !u16 {
-    return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.uid_idx);
-}
-// Get an inode's xattr values. If the inode does not have xattr values (including if the inode is not an extended type), an empty slice is returned.
-pub fn xattrValues(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, xattr_table_start: u64) ![]XattrTable.XattrOwned {
-    const idx = switch (self.data) {
-        .ext_dir => |e| e.xattr_idx,
-        .ext_file => |e| e.xattr_idx,
-        .ext_symlink => |e| e.xattr_idx,
-        .ext_block_dev => |e| e.xattr_idx,
-        .ext_char_dev => |e| e.xattr_idx,
-        .ext_fifo => |e| e.xattr_idx,
-        .ext_socket => |e| e.xattr_idx,
-        else => return &[0]XattrTable.XattrOwned{},
-    };
-    if (idx == 0xFFFFFFFF) return &[0]XattrTable.XattrOwned{};
-    return XattrTable.statelessLookup(alloc, io, decomp, fil, xattr_table_start, idx);
 }
 
 // Types
 
-pub const Error = error{
+pub const Ref = packed struct {
-    NotDirectory,
-    NotRegularFile,
-    NotSymlink,
-    NotExtended,
-};
-
-pub const Ref = packed struct(u64) {
     block_offset: u16,
     block_start: u32,
     _: u16,
@@ -157,50 +137,219 @@ pub const Type = enum(u16) {
     dir = 1,
     file,
     symlink,
-    block_dev,
+    block,
-    char_dev,
+    char,
     fifo,
-    socket,
+    sock,
     ext_dir,
     ext_file,
     ext_symlink,
-    ext_block_dev,
+    ext_block,
-    ext_char_dev,
+    ext_char,
     ext_fifo,
-    ext_socket,
+    ext_sock,
 };
 
-pub const Data = union(Type) {
+const Header = packed struct {
-    dir: dir.Dir,
-    file: file.File,
-    symlink: misc.Symlink,
-    block_dev: misc.Dev,
-    char_dev: misc.Dev,
-    fifo: misc.IPC,
-    socket: misc.IPC,
-    ext_dir: dir.ExtDir,
-    ext_file: file.ExtFile,
-    ext_symlink: misc.ExtSymlink,
-    ext_block_dev: misc.ExtDev,
-    ext_char_dev: misc.ExtDev,
-    ext_fifo: misc.ExtIPC,
-    ext_socket: misc.ExtIPC,
-};
-
-pub const Header = extern struct {
     inode_type: Type,
-    permissions: u16,
+    permission: u16,
     uid_idx: u16,
     gid_idx: u16,
     mod_time: u32,
     num: u32,
 };
 
-// Extract
+pub const Data = union(Type) {
+    dir: Dir.Dir,
+    file: File.File,
+    symlink: Sym.Symlink,
+    block: Misc.Device,
+    char: Misc.Device,
+    fifo: Misc.Ipc,
+    sock: Misc.Ipc,
+    ext_dir: Dir.ExtDir,
+    ext_file: File.ExtFile,
+    ext_symlink: Sym.ExtSymlink,
+    ext_block: Misc.ExtDevice,
+    ext_char: Misc.ExtDevice,
+    ext_fifo: Misc.ExtIpc,
+    ext_sock: Misc.ExtIpc,
+};
 
-pub fn extract(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {}
+// Errors
-pub fn extractDir(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {}
+
-pub fn extractRegFile(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {}
+pub const Error = error{
-pub fn extractSymlink(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {}
+    NotDirectory,
-pub fn extractDevice(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {}
+    NotFound,
-pub fn extractIPC(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {}
+    NotRegularFile,
+};
+
+// Utils functions
+
+// Universal
+
+pub fn uid(self: Inode, decomp: *const Decompressor, fil: OffsetFile, id_start: u64) !u16 {
+    return LookupTable.stateless(u16, fil, decomp, id_start, self.hdr.uid_idx);
+}
+pub fn uidCached(self: Inode, table: LookupTable.CachedTable(u16)) !u16 {
+    return table.get(self.hdr.uid_idx);
+}
+pub fn gid(self: Inode, decomp: *const Decompressor, fil: OffsetFile, id_start: u64) !u16 {
+    return LookupTable.stateless(u16, fil, decomp, id_start, self.hdr.gid_idx);
+}
+pub fn gidCached(self: Inode, table: LookupTable.CachedTable(u16)) !u16 {
+    return table.get(self.hdr.gid_idx);
+}
+pub fn xattr(self: Inode, alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, xattr_start: u64) !?LookupTable.XattrValues {
+    if (@intFromEnum(self.hdr.inode_type) < 8) return null;
+    const idx: u32 = switch (self.data) {
+        .ext_dir => |d| d.xattr_idx,
+        .ext_file => |f| f.xattr_idx,
+        .ext_symlink => |s| s.xattr_idx,
+        .ext_block, .ext_char => |d| d.xattr_idx,
+        .ext_fifo, .ext_sock => |d| d.xattr_idx,
+        else => unreachable,
+    };
+    if (idx == 0xFFFFFFFF) return null;
+    return LookupTable.statelessXattr(alloc, fil, decomp, xattr_start, idx);
+}
+
+// Dir inodes
+
+/// For directory inodes, tries to find the inode at the given path. Returns both the inode, and it's file name.
+/// If the path is empty or "." then a copy of this inode is returned with no name ("").
+pub fn findInode(
+    inode: Inode,
+    alloc: std.mem.Allocator,
+    decomp: *const Decompressor,
+    fil: OffsetFile,
+    dir_start: u64,
+    inode_start: u64,
+    block_size: u32,
+    filepath: []const u8,
+) !struct { inode: Inode, name: []const u8 } {
+    switch (inode.data) {
+        .dir => |d| {
+            const path: []const u8 = std.mem.trim(u8, filepath, "/");
+            if (path.len == 0 or (path.len == 1 and path[0] == '.'))
+                return .{ .inode = inode.copy(alloc), .name = "" };
+            return findInodeRaw(
+                alloc,
+                decomp,
+                fil,
+                dir_start,
+                inode_start,
+                block_size,
+                path,
+                d,
+            );
+        },
+        .ext_dir => |d| {
+            const path: []const u8 = std.mem.trim(u8, filepath, "/");
+            if (path.len == 0 or (path.len == 1 and path[0] == '.'))
+                return .{ .inode = inode.copy(alloc), .name = "" };
+            return findInodeRaw(
+                alloc,
+                decomp,
+                fil,
+                dir_start,
+                inode_start,
+                block_size,
+                path,
+                d,
+            );
+        },
+        else => return Error.NotDirectory,
+    }
+}
+inline fn findInodeRaw(
+    inode: Inode,
+    alloc: std.mem.Allocator,
+    decomp: *const Decompressor,
+    fil: OffsetFile,
+    dir_start: u64,
+    inode_start: u64,
+    block_size: u32,
+    path: []const u8,
+    dat: anytype,
+) !struct { inode: Inode, name: []const u8 } {
+    const first_element: []const u8 = std.mem.sliceTo(path, '/');
+
+    const dirs = try readDirRaw(alloc, decomp, fil, dir_start, dat);
+    defer {
+        for (dirs) |dir|
+            dir.deinit(alloc);
+        alloc.free(dirs);
+    }
+
+    // Directories are stored ASCIIbetically, so we can use binary search.
+    var cur_slice = dirs;
+    var idx: usize = 0;
+    while (cur_slice.len > 0) {
+        idx = cur_slice.len / 2;
+        const mid_name = cur_slice[idx].name;
+        switch (std.mem.order(u8, first_element, mid_name)) {
+            .gt => {
+                cur_slice = cur_slice[idx + 1 ..];
+                continue;
+            },
+            .lt => {
+                cur_slice = cur_slice[0..idx];
+                continue;
+            },
+            .eq => break,
+        }
+    } else return Error.NotFound;
+    const entry = cur_slice[idx];
+    var rdr = try fil.readerAt(inode_start + entry.block_start, &[0]u8{});
+    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
+    try meta_rdr.interface.discardAll(entry.block_offset);
+    const ret_inode: Inode = try .read(alloc, &meta_rdr.interface, block_size);
+    if (first_element.len == path.len) {
+        const name_copy = try alloc.alloc(u8, entry.name.len);
+        @memcpy(name_copy, entry.name.len);
+        return .{ .inode = ret_inode, .name = name_copy };
+    }
+    return inode.findInode(alloc, decomp, fil, dir_start, inode_start, block_size, path[first_element.len..]);
+}
+
+/// Get the directory entries for a directory inode.
+pub fn readDirectory(inode: Inode, alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, dir_start: u64) ![]Directory.Entry {
+    return switch (inode.data) {
+        .dir => |d| readDirRaw(alloc, decomp, fil, dir_start, d),
+        .ext_dir => |d| readDirRaw(alloc, decomp, fil, dir_start, d),
+        else => Error.NotDirectory,
+    };
+}
+inline fn readDirRaw(alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, dir_start: u64, dat: anytype) ![]Directory.Entry {
+    var rdr = try fil.readerAt(dir_start + dat.block_start, &[0]u8{});
+    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
+    try meta_rdr.interface.discardAll(dat.block_offset);
+    return Directory.readDirectory(alloc, meta_rdr, dat.size);
+}
+
+// file inodes
+
+/// Gets the data reader for a file inode.
+pub fn dataReader(inode: Inode, decomp: *const Decompressor, fil: OffsetFile, frag_start: u64, block_size: u32) !DataReader {
+    return switch (inode.data) {
+        .file => |f| dataReaderRaw(decomp, fil, frag_start, block_size, f),
+        .ext_file => |f| dataReaderRaw(decomp, fil, frag_start, block_size, f),
+        else => Error.NotRegularFile,
+    };
+}
+inline fn dataReaderRaw(decomp: *const Decompressor, fil: OffsetFile, frag_start: u64, block_size: u32, dat: anytype) !DataReader {
+    return .init(
+        decomp,
+        fil,
+        block_size,
+        dat.block_sizes,
+        dat.size,
+        dat.block_start,
+        if (dat.frag_idx != 0xFFFFFFFF)
+            try LookupTable.stateless(FragEntry, fil, decomp, frag_start, dat.frag_idx)
+        else
+            null,
+        dat.frag_offset,
+    );
+}

src/inode/dir.zig

@@ -0,0 +1,35 @@
+const Reader = @import("std").Io.Reader;
+
+pub const Dir = packed struct {
+    block_start: u32,
+    hard_links: u32,
+    size: u16,
+    block_offset: u16,
+    parent_num: u32,
+
+    const Self = @This();
+
+    pub fn read(rdr: *Reader) !Self {
+        var new: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
+        return new;
+    }
+};
+
+pub const ExtDir = packed struct {
+    hard_links: u32,
+    size: u32,
+    block_start: u32,
+    parent_num: u32,
+    idx_count: u16,
+    block_offset: u16,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    pub fn read(rdr: *Reader) !Self {
+        var new: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
+        return new;
+    }
+};

src/inode/file.zig

@@ -0,0 +1,69 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+
+pub const BlockSize = packed struct {
+    size: u31,
+    uncompressed: bool,
+};
+
+pub const File = struct {
+    block_start: u32,
+    frag_idx: u32,
+    frag_offset: u32,
+    size: u32,
+    block_sizes: []BlockSize,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
+        var buf: [16]u8 = undefined;
+        try rdr.readSliceAll(&buf);
+        const frag_idx = std.mem.readVarInt(u32, buf[4..8], .little);
+        const size = std.mem.readVarInt(u32, buf[12..], .little);
+        const sizes_len = size / block_size;
+        if (frag_idx != 0xFFFFFFFF and size % block_size > 0)
+            sizes_len += 1;
+        const sizes = try alloc.alloc(BlockSize, sizes_len);
+        errdefer alloc.free(sizes);
+        try rdr.readSliceEndian(BlockSize, sizes, .little);
+        return .{
+            .block_start = std.mem.readVarInt(u32, buf[0..4], .little),
+            .frag_idx = frag_idx,
+            .frag_offset = std.mem.readVarInt(u32, buf[8..12], .little),
+            .size = size,
+            .block_sizes = sizes,
+        };
+    }
+};
+
+pub const ExtFile = struct {
+    block_start: u64,
+    size: u64,
+    sparse: u64,
+    hard_links: u32,
+    frag_idx: u32,
+    frag_offset: u32,
+    xattr_idx: u32,
+    block_sizes: []BlockSize,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
+        var buf: [40]u8 = undefined;
+        try rdr.readSliceAll(&buf);
+        const frag_idx = std.mem.readVarInt(u32, buf[28..32], .little);
+        const size = std.mem.readVarInt(u64, buf[8..16], .little);
+        const sizes_len = size / block_size;
+        if (frag_idx != 0xFFFFFFFF and size % block_size > 0)
+            sizes_len += 1;
+        const sizes = try alloc.alloc(BlockSize, sizes_len);
+        errdefer alloc.free(sizes);
+        try rdr.readSliceEndian(BlockSize, sizes, .little);
+        return .{
+            .block_start = std.mem.readVarInt(u64, buf[0..8], .little),
+            .size = size,
+            .sparse = std.mem.readVarInt(u64, buf[16..24], .little),
+            .hard_links = std.mem.readVarInt(u32, buf[24..28], .little),
+            .frag_idx = frag_idx,
+            .frag_offset = std.mem.readVarInt(u32, buf[32..36], .little),
+            .xattr_idx = std.mem.readVarInt(u32, buf[36..40], .little),
+            .block_sizes = sizes,
+        };
+    }
+};

src/inode/misc.zig

@@ -0,0 +1,53 @@
+const Reader = @import("std").Io.Reader;
+
+pub const Device = packed struct {
+    hard_links: u32,
+    device: u32,
+
+    const Self = @This();
+
+    pub fn read(rdr: *Reader) !Self {
+        var new: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
+        return new;
+    }
+};
+
+pub const ExtDevice = packed struct {
+    hard_links: u32,
+    device: u32,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    pub fn read(rdr: *Reader) !Self {
+        var new: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
+        return new;
+    }
+};
+
+pub const Ipc = packed struct {
+    hard_links: u32,
+
+    const Self = @This();
+
+    pub fn read(rdr: *Reader) !Self {
+        var new: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
+        return new;
+    }
+};
+
+pub const ExtIpc = packed struct {
+    hard_links: u32,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    pub fn read(rdr: *Reader) !Self {
+        var new: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&new), .little);
+        return new;
+    }
+};

src/inode/sym.zig

@@ -0,0 +1,42 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+
+pub const Symlink = struct {
+    hard_links: u32,
+    target: []const u8,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !Symlink {
+        var buf: [8]u8 = undefined;
+        try rdr.readSliceAll(&buf);
+        const size = std.mem.readVarInt(u32, buf[4..], .little);
+        const target = try alloc.alloc(u8, size);
+        errdefer alloc.free(target);
+        try rdr.readSliceEndian(u8, target, .little);
+        return .{
+            .hard_links = std.mem.readVarInt(u32, buf[0..4], .little),
+            .target = target,
+        };
+    }
+};
+
+pub const ExtSymlink = struct {
+    hard_links: u32,
+    xattr_idx: u32,
+    target: []const u8,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !ExtSymlink {
+        var buf: [8]u8 = undefined;
+        try rdr.readSliceAll(&buf);
+        const size = std.mem.readVarInt(u32, buf[4..], .little);
+        const target = try alloc.alloc(u8, size);
+        errdefer alloc.free(target);
+        try rdr.readSliceEndian(u8, target, .little);
+        var xattr_idx: u32 = undefined;
+        try rdr.readSliceEndian(u32, @ptrCast(&xattr_idx), .little);
+        return .{
+            .hard_links = std.mem.readVarInt(u32, buf[0..4], .little),
+            .target = target,
+            .xattr_idx = xattr_idx,
+        };
+    }
+};

src/inode_data/dir.zig

@@ -1,32 +0,0 @@
-const Reader = @import("std").Io.Reader;
-
-pub const Dir = extern struct {
-    block_start: u32,
-    hard_links: u32,
-    size: u16,
-    block_offset: u16,
-    parent_num: u32,
-
-    pub fn read(rdr: *Reader) !Dir {
-        var d: Dir = undefined;
-        try rdr.readSliceEndian(Dir, @ptrCast(&d), .little);
-        return d;
-    }
-};
-
-pub const ExtDir = extern struct {
-    hard_links: u32,
-    size: u32,
-    block_start: u32,
-    parent_num: u32,
-    idx_count: u16,
-    block_offset: u16,
-    xattr_id: u32,
-    // index: []DirIndex
-
-    pub fn read(rdr: *Reader) !ExtDir {
-        var d: ExtDir = undefined;
-        try rdr.readSliceEndian(ExtDir, @ptrCast(&d), .little);
-        return d;
-    }
-};

src/inode_data/file.zig

@@ -1,97 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-
-pub const BlockSize = packed struct(u32) {
-    size: u24,
-    uncompressed: bool,
-    _: u7,
-};
-
-const FileRawRead = extern struct {
-    block_start: u32,
-    frag_idx: u32,
-    frag_block_offset: u32,
-    size: u32,
-};
-
-pub const File = struct {
-    block_start: u32,
-    frag_idx: u32,
-    frag_block_offset: u32,
-    size: u32,
-    block_sizes: []BlockSize,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
-        var raw: FileRawRead = undefined;
-        try rdr.readSliceEndian(FileRawRead, @ptrCast(&raw), .little);
-
-        var num_blocks: u32 = raw.size / block_size;
-        if (raw.size % block_size != 0 and raw.frag_idx == 0xFFFFFFFF)
-            num_blocks += 1;
-
-        const sizes = try alloc.alloc(BlockSize, num_blocks);
-        errdefer alloc.free(sizes);
-        try rdr.readSliceEndian(BlockSize, sizes, .little);
-
-        return .{
-            .block_start = raw.block_start,
-            .frag_idx = raw.frag_idx,
-            .frag_block_offset = raw.frag_block_offset,
-            .size = raw.size,
-            .block_sizes = sizes,
-        };
-    }
-
-    pub fn deinit(self: File, alloc: std.mem.Allocator) void {
-        alloc.free(self.block_sizes);
-    }
-};
-
-const ExtFileRawRead = extern struct {
-    block_start: u64,
-    size: u64,
-    sparse: u64,
-    hard_links: u32,
-    frag_idx: u32,
-    frag_block_offset: u32,
-    xattr_idx: u32,
-};
-
-pub const ExtFile = struct {
-    block_start: u64,
-    size: u64,
-    sparse: u64,
-    hard_links: u32,
-    frag_idx: u32,
-    frag_block_offset: u32,
-    xattr_idx: u32,
-    block_sizes: []BlockSize,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !ExtFile {
-        var raw: ExtFileRawRead = undefined;
-        try rdr.readSliceEndian(ExtFileRawRead, @ptrCast(&raw), .little);
-
-        var num_blocks: u32 = @truncate(raw.size / block_size);
-        if (raw.size % block_size != 0 and raw.frag_idx == 0xFFFFFFFF)
-            num_blocks += 1;
-
-        const sizes = try alloc.alloc(BlockSize, num_blocks);
-        errdefer alloc.free(sizes);
-        try rdr.readSliceEndian(BlockSize, sizes, .little);
-
-        return .{
-            .block_start = raw.block_start,
-            .size = raw.size,
-            .sparse = raw.sparse,
-            .hard_links = raw.hard_links,
-            .frag_idx = raw.frag_idx,
-            .frag_block_offset = raw.frag_block_offset,
-            .xattr_idx = raw.xattr_idx,
-            .block_sizes = sizes,
-        };
-    }
-
-    pub fn deinit(self: ExtFile, alloc: std.mem.Allocator) void {
-        alloc.free(self.block_sizes);
-    }
-};

src/inode_data/misc.zig

@@ -1,98 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-
-pub const Symlink = struct {
-    hard_links: u32,
-    target: []const u8,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !Symlink {
-        var start: [8]u8 = undefined;
-        try rdr.readSliceAll(&start);
-        const target_size = std.mem.readInt(u32, start[4..8], .little);
-        const target = try alloc.alloc(u8, target_size + 1);
-        errdefer alloc.free(target);
-        try rdr.readSliceEndian(u8, target, .little);
-        return .{
-            .hard_links = std.mem.readInt(u32, start[0..4], .little),
-            .target = target,
-        };
-    }
-
-    pub fn deinit(self: Symlink, alloc: std.mem.Allocator) void {
-        alloc.free(self.target);
-    }
-};
-
-pub const ExtSymlink = struct {
-    hard_links: u32,
-    target: []const u8,
-    xattr_idx: u32,
-
-    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !ExtSymlink {
-        var start: [8]u8 = undefined;
-        try rdr.readSliceAll(&start);
-        const target_size = std.mem.readInt(u32, start[4..8], .little);
-        const target = try alloc.alloc(u8, target_size + 1);
-        errdefer alloc.free(target);
-        try rdr.readSliceEndian(u8, target, .little);
-        var xattr_idx: u32 = undefined;
-        try rdr.readSliceEndian(u32, @ptrCast(&xattr_idx), .little);
-        return .{
-            .hard_links = std.mem.readInt(u32, start[0..4], .little),
-            .target = target,
-            .xattr_idx = xattr_idx,
-        };
-    }
-
-    pub fn deinit(self: ExtSymlink, alloc: std.mem.Allocator) void {
-        alloc.free(self.target);
-    }
-};
-
-/// A block or character device.
-pub const Dev = extern struct {
-    hard_links: u32,
-    dev: u32,
-
-    pub fn read(rdr: *Reader) !Dev {
-        var d: Dev = undefined;
-        try rdr.readSliceEndian(Dev, @ptrCast(&d), .little);
-        return d;
-    }
-};
-
-/// An extended block or character device.
-pub const ExtDev = extern struct {
-    hard_links: u32,
-    dev: u32,
-    xattr_idx: u32,
-
-    pub fn read(rdr: *Reader) !ExtDev {
-        var d: ExtDev = undefined;
-        try rdr.readSliceEndian(ExtDev, @ptrCast(&d), .little);
-        return d;
-    }
-};
-
-/// A socket or FIFO file.
-pub const IPC = extern struct {
-    hard_links: u32,
-
-    pub fn read(rdr: *Reader) !IPC {
-        var d: IPC = undefined;
-        try rdr.readSliceEndian(IPC, @ptrCast(&d), .little);
-        return d;
-    }
-};
-
-/// An extended socket or FIFO file.
-pub const ExtIPC = extern struct {
-    hard_links: u32,
-    xattr_idx: u32,
-
-    pub fn read(rdr: *Reader) !ExtIPC {
-        var d: ExtIPC = undefined;
-        try rdr.readSliceEndian(ExtIPC, @ptrCast(&d), .little);
-        return d;
-    }
-};

src/lookup_table.zig

@@ -1,84 +1,168 @@
 const std = @import("std");
-const Io = std.Io;
 
-const Decompressor = @import("util/decompressor.zig");
+const Decompressor = @import("decomp.zig");
 const MetadataReader = @import("util/metadata.zig");
 const OffsetFile = @import("util/offset_file.zig");
 
-pub fn lookupValue(comptime T: anytype, alloc: std.mem.Allocator, io: Io, decomp: *Decompressor, file: OffsetFile, table_start: u64, idx: u16) !T {
+pub fn stateless(comptime T: anytype, fil: OffsetFile, decomp: *const Decompressor, table_start: u64, idx: u32) !T {
-    const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
+    const VALS_PER_BLOCK = 8192 / @sizeOf(T);
+    const block = idx / VALS_PER_BLOCK;
+    const block_idx = idx % VALS_PER_BLOCK;
 
-    const block = idx / T_PER_BLOCK;
+    const offset = try fil.valueAt(u64, table_start + (8 * block));
-    const block_offset = idx % T_PER_BLOCK;
+    var buf: [8192]u8 = undefined;
+    var rdr = try fil.readerAt(offset, &buf);
+    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
+    try meta_rdr.interface.discardAll(@sizeOf(T) * block_idx);
 
-    var rdr = try file.readerAt(io, table_start + (8 * block), &[0]u8{});
-    var offset: u64 = undefined;
-    try rdr.interface.readSliceEndian(u64, @ptrCast(&offset), .little);
-
-    rdr = try file.readerAt(io, offset, &[0]u8{});
-    var meta: MetadataReader = .init(alloc, &rdr, decomp);
-
-    try meta.interface.discardAll(@sizeOf(T) * block_offset);
     var out: T = undefined;
-    try meta.interface.readSliceEndian(T, @ptrCast(&out), .little);
+    try meta_rdr.interface.readSliceEndian(T, @ptrCast(&out), .little);
+    return out;
+}
+
+const InodeRef = @import("inode.zig").Ref;
+
+const XattrLookup = packed struct {
+    // This isn't actuall an inode ref, but is stored that exact same way.
+    ref: InodeRef,
+    kv_count: u32,
+    size: u32,
+};
+
+const XattrKey = packed struct {
+    type: enum(u2) {
+        user,
+        trusted,
+        security,
+    },
+    out_of_line: bool,
+    _: u13,
+    name_size: u16,
+};
+
+pub const XattrValues = std.AutoHashMap([:0]u8, []u8);
+
+pub fn statelessXattr(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, table_start: u64, idx: u32) !XattrValues {
+    const xattr_start = try fil.valueAt(u64, table_start);
+    const block = idx / 512;
+    const block_idx = idx % 512;
+
+    const block_start = try fil.valueAt(u64, table_start + 8 + (block * 8));
+    var rdr = try fil.readerAt(block_start, &[0]u8{});
+    var meta_rdr: MetadataReader = .init(&rdr.interface, decomp);
+    try meta_rdr.interface.discardAll(16 * block_idx);
+
+    var lookup: XattrLookup = undefined;
+    try meta_rdr.interface.readSliceEndian(XattrLookup, @ptrCast(&lookup), .little);
+
+    rdr = try fil.readerAt(xattr_start + lookup.ref.block_start, &[0]u8{});
+    meta_rdr = .init(&rdr.interface, decomp);
+    try meta_rdr.interface.discardAll(lookup.ref.block_offset);
+
+    var out: XattrValues = try .init(alloc);
+    for (0..lookup.kv_count) |_| {
+        var key: XattrKey = undefined;
+        try meta_rdr.interface.readSliceEndian(XattrKey, @ptrCast(&key), .little);
+        const prefix_size = switch (key.type) {
+            .user => 4,
+            .trusted => 7,
+            .security => 8,
+        };
+        const name: [:0]u8 = try alloc.alloc(u8, prefix_size + key.name_size + 1);
+        name[prefix_size + key.name_size] = 0;
+        try meta_rdr.interface.readSliceEndian(u8, name[prefix_size .. prefix_size + key.name_size], .little);
+        switch (key.type) {
+            .user => @memcpy(name[0..4], "user"),
+            .trusted => @memcpy(name[0..7], "trusted"),
+            .security => @memcpy(name[0..8], "security"),
+        }
+        if (key.out_of_line) {
+            try meta_rdr.interface.discardAll(4);
+            var value_offset: InodeRef = undefined;
+            try meta_rdr.interface.readSliceEndian(InodeRef, @ptrCast(&value_offset), .little);
+
+            var value_rdr = try fil.readerAt(xattr_start + value_offset.block_start, &[0]u8{});
+            var value_meta: MetadataReader = .init(&value_rdr.interface, decomp);
+            try value_meta.interface.discardAll(value_offset.block_offset);
+
+            var val_size: u32 = undefined;
+            try value_meta.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
+            const value = try alloc.alloc(u8, val_size);
+            try value_meta.interface.readSliceEndian(u8, value, .little);
+            try out.put(name, value);
+        } else {
+            var val_size: u32 = undefined;
+            try meta_rdr.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
+            const value = try alloc.alloc(u8, val_size);
+            try meta_rdr.interface.readSliceEndian(u8, value, .little);
+            try out.put(name, value);
+        }
+    }
     return out;
 }
 
 pub fn CachedTable(comptime T: anytype) type {
     return struct {
-        const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
+        const Self = @This();
 
-        const Table = @This();
+        const VALS_PER_BLOCK = 8192 / @sizeOf(T);
 
         alloc: std.mem.Allocator,
+        decomp: *const Decompressor,
+
         fil: OffsetFile,
         table_start: u64,
-        total_num: u32,
+        num: u32,
 
-        table: std.AutoHashMap(u32, []T),
+        cache: std.AutoHashMap(u32, []T),
+        cache_mut: std.Thread.Mutex = .{},
 
-        mut: Io.Mutex = .init,
+        pub fn init(alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, table_offset: u64, num: u32) !Self {
-
-        pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, offset: u64, total_num: u32) Table {
             return .{
                 .alloc = alloc,
+                .decomp = decomp,
+
                 .fil = fil,
-                .table_start = offset,
+                .table_start = table_offset,
-                .total_num = total_num,
+                .num = num,
 
-                .table = .init(alloc),
+                .cache = .init(alloc),
             };
         }
-        pub fn deinit(self: *Table, io: Io) void {
+        pub fn deinit(self: *Self) void {
-            self.mut.lockUncancelable(io);
+            var values = self.cache.valueIterator();
-            self.table.deinit();
+            while (values.next()) |val|
+                self.alloc.free(val);
+            self.cache.deinit();
         }
 
-        pub fn get(self: *Table, io: Io, idx: u32) !T {
+        pub fn get(self: *Self, idx: u32) !T {
-            const block = idx / T_PER_BLOCK;
+            const block = idx / VALS_PER_BLOCK;
-            const block_offset = idx % T_PER_BLOCK;
+            const block_idx = idx % VALS_PER_BLOCK;
-            if (self.table.contains(block))
-                return self.table.get(block).?[block_offset];
 
-            try self.mut.lock(io);
+            if (self.cache.get(block)) |val|
-            defer self.mut.unlock(io);
+                return val[block_idx];
 
-            if (self.table.contains(block))
+            self.cache_mut.lock();
-                return self.table.get(block).?[block_offset];
+            defer self.cache_mut.unlock();
 
-            var rdr = try self.fil.readerAt(io, self.table_start + (8 * block), &[0]u8{});
+            // Double check in case another thread was doing your work.
-            var offset: u64 = undefined;
+            if (self.cache.get(block)) |val|
-            try rdr.interface.readSliceEndian(u64, @ptrCast(&offset), .little);
+                return val[block_idx];
 
-            const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
+            const offset = try self.fil.valueAt(u64, self.table_start + (8 * block));
-                self.total_num % T_PER_BLOCK
+            var buf: [8192]u8 = undefined;
+            var rdr = try self.fil.readerAt(offset, &buf);
+            var meta_rdr: MetadataReader = .init(&rdr.interface, self.decomp);
+            const block_size = if (block == (self.num - 1) / VALS_PER_BLOCK)
+                self.num % VALS_PER_BLOCK
             else
-                T_PER_BLOCK;
+                VALS_PER_BLOCK;
-
+            const new_block = try self.alloc.alloc(T, block_size);
-            rdr = try self.fil.readerAt(io, offset, &[0]u8{});
+            errdefer self.alloc.free(new_block);
-            var meta: MetadataReader = .init(self.alloc, &rdr, self.decomp);
+            try meta_rdr.interface.readSliceEndian(T, new_block, .little);
-
+            try self.cache.put(block, new_block);
-            try self.table.put(block, try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little));
+            return new_block[block_idx];
         }
     };
 }

src/root.zig

@@ -1,2 +1,3 @@
 pub const Archive = @import("archive.zig");
+
 pub const ExtractionOptions = @import("options.zig");

src/test.zig

@@ -1,83 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const io = std.testing.io;
-const alloc = std.testing.allocator;
-const stuff = @import("builtin");
-
-const Archive = @import("archive.zig");
-const Superblock = Archive.Superblock;
-
-const TestArchive = "testing/LinuxPATest.sfs";
-
-test "Basics" {
-    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
-    defer fil.close(io);
-    var sfs: Archive = try .init(io, fil, 0);
-    try std.testing.expectEqualDeep(sfs.super, LinuxPATestCorrectSuperblock);
-    const root_file = try sfs.root(alloc, io);
-    defer root_file.deinit();
-}
-
-const TestFile = "Start.exe";
-const TestFileExtractLocation = "testing/Start.exe";
-
-test "ExtractSingleFile" {
-    Io.Dir.cwd().deleteFile(io, TestFileExtractLocation) catch {};
-    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
-    defer fil.close(io);
-    var sfs: Archive = try .init(io, fil, 0);
-    var test_fil = try sfs.open(alloc, io, TestFile);
-    defer test_fil.deinit();
-    try test_fil.extract(alloc, io, TestFileExtractLocation, try .Default());
-    //TODO: validate extracted file.
-}
-
-const TestFullExtractLocation = "testing/TestExtract";
-
-test "ExtractCompleteArchive" {
-    Io.Dir.cwd().deleteTree(io, TestFullExtractLocation) catch {};
-    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
-    defer fil.close(io);
-    var sfs: Archive = try .init(io, fil, 0);
-    try sfs.extract(alloc, io, TestFullExtractLocation, try .Default());
-}
-
-const LinuxPATestCorrectSuperblock: Superblock = .{
-    .magic = std.mem.readInt(u32, "hsqs", .little),
-    .inode_count = 2974,
-    .mod_time = 1632696724,
-    .block_size = 131072,
-    .frag_count = 264,
-    .compression = .zstd,
-    .block_log = 17,
-    .flags = .{
-        .inode_uncompressed = false,
-        .data_uncompressed = false,
-        .check = false,
-        .frag_uncompressed = false,
-        .fragment_never = false,
-        .fragment_always = false,
-        .duplicates = true,
-        .exportable = true,
-        .xattr_uncompressed = false,
-        .xattr_never = false,
-        .compression_options = false,
-        .ids_uncompressed = false,
-        ._ = 0,
-    },
-    .id_count = 1,
-    .ver_maj = 4,
-    .ver_min = 0,
-    .root_ref = .{
-        .block_offset = 1363,
-        .block_start = 29237,
-        ._ = 0,
-    },
-    .size = 106841744,
-    .id_start = 106841632,
-    .xattr_start = 106841720,
-    .inode_start = 106778274,
-    .dir_start = 106807998,
-    .frag_start = 106837747,
-    .export_start = 106841602,
-};

src/util/data_extractor.zig

@@ -1,119 +0,0 @@
-//! The DataExtractor is meant to extract a regular file's data to a given file asyncronously.
-
-const std = @import("std");
-const Io = std.Io;
-
-const FragEntry = @import("../frag.zig").FragEntry;
-const BlockSize = @import("../inode_data/file.zig").BlockSize;
-const Decompressor = @import("decompressor.zig");
-const OffsetFile = @import("offset_file.zig");
-const SharedCache = @import("shared_cache.zig");
-
-const DataExtractor = @This();
-
-fil: OffsetFile,
-cache: *SharedCache,
-decomp: *const Decompressor,
-block_size: u32,
-
-file_size: u64,
-start: u64,
-blocks: []BlockSize,
-
-frag_offset: u32 = 0,
-frag_entry: ?FragEntry = null,
-
-pub fn init(fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) DataExtractor {
-    return .{
-        .fil = fil,
-        .cache = cache,
-        .decomp = decomp,
-        .block_size = block_size,
-
-        .file_size = file_size,
-        .start = data_start,
-        .blocks = blocks,
-    };
-}
-pub fn addFrag(self: *DataExtractor, frag_offset: u32, entry: FragEntry) void {
-    self.frag_offset = frag_offset;
-    self.frag_entry = entry;
-}
-
-fn numBlocks(self: DataExtractor) usize {
-    var num = self.blocks.len;
-    if (self.frag_entry != null) num += 1;
-    return num;
-}
-
-/// Starts extracting the data using the given group to spawn async tasks.
-pub fn extractAsync(self: DataExtractor, alloc: std.mem.Allocator, io: Io, group: *Io.Group, fil: Io.File) void {
-    var read_offset: u64 = self.start;
-    for (0..self.blocks.len) |idx| {
-        group.async(io, blockThread, .{ self, alloc, io, fil, read_offset, idx });
-        read_offset += self.blocks[idx].size;
-    }
-    if (self.frag_entry != null)
-        group.async(io, fragThread, .{ self, alloc, io, fil });
-}
-
-fn blockThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File, read_offset: u64, idx: u32) !void {
-    const block = self.blocks[idx];
-
-    const cur_block_size = if (idx == self.numBlocks() - 1)
-        self.file_size % self.block_size
-    else
-        self.block_size;
-
-    var wrt = fil.writer(io, &[0]u8{});
-    try wrt.seekTo(self.block_size * idx);
-    defer wrt.flush() catch {};
-
-    if (block.size == 0) {
-        try wrt.interface.splatByteAll(0, cur_block_size);
-        return;
-    }
-
-    var rdr = try self.fil.readerAt(io, read_offset, &[0]u8{});
-    if (block.uncompressed) {
-        try rdr.interface.streamExact(&wrt, cur_block_size);
-        return;
-    } else {
-        @branchHint(.likely);
-        var cache = try self.cache.getCache(io);
-        defer self.cache.returnCache(cache);
-
-        var tmp = try self.cache.getCache(io);
-        defer self.cache.returnCache(tmp);
-
-        try rdr.interface.readSliceAll(cache.cache[0..block.size]);
-        _ = try self.decomp.Decompress(alloc, cache.cache[0..block.size], tmp.cache[0..cur_block_size]);
-        try wrt.interface.writeAll(tmp.cache[0..cur_block_size]);
-    }
-}
-fn fragThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File) !void {
-    const frag = self.frag_entry.?;
-    const cur_block_size = self.file_size % self.block_size;
-
-    var wrt = fil.writer(io, &[0]u8{});
-    try wrt.seekTo(self.blocks.len * self.block_size);
-    defer wrt.flush() catch {};
-
-    var rdr = try self.fil.readerAt(io, frag.start, &[0]u8{});
-    if (frag.size.uncompressed) {
-        try rdr.interface.discardAll(self.frag_offset);
-        try rdr.interface.streamExact(&wrt, cur_block_size);
-        return;
-    } else {
-        @branchHint(.likely);
-        var cache = try self.cache.getCache(io);
-        defer self.cache.returnCache(cache);
-
-        var tmp = try self.cache.getCache(io);
-        defer self.cache.returnCache(tmp);
-
-        try rdr.interface.readSliceAll(cache.cache[0..frag.size.size]);
-        _ = try self.decomp.Decompress(alloc, cache.cache[0..frag.size.size], tmp.cache[0..self.block_size]);
-        try wrt.interface.writeAll(tmp.cache[0..cur_block_size]);
-    }
-}

src/util/data_reader.zig

@@ -1,208 +1,137 @@
-//! DataReader reads a regular file's data linearly from start to finish using Io.Reader interface.
-
 const std = @import("std");
-const Io = std.Io;
+const Reader = std.Io.Reader;
-const Reader = Io.Reader;
+const Writer = std.Io.Writer;
-const Writer = Io.Writer;
+const Limit = std.Io.Limit;
-const Limit = Io.Limit;
 
-const FragEntry = @import("../frag.zig").FragEntry;
+const FragEntry = @import("../archive.zig").FragEntry;
-const BlockSize = @import("../inode_data/file.zig").BlockSize;
+const Decompressor = @import("../decomp.zig");
-const Decompressor = @import("decompressor.zig");
+const BlockSize = @import("../inode/file.zig").BlockSize;
 const OffsetFile = @import("offset_file.zig");
-const SharedCache = @import("shared_cache.zig");
 
 const DataReader = @This();
 
-alloc: std.mem.Allocator,
-
-fil: OffsetFile,
-io: Io,
-cache: *SharedCache,
 decomp: *const Decompressor,
+file: OffsetFile,
 block_size: u32,
-
-file_size: u64,
-cur_offset: u64,
 blocks: []BlockSize,
+size: u64,
+frag: ?FragEntry,
+frag_offset: u32,
 
-frag_offset: u32 = 0,
+offset: u64,
-frag_entry: ?FragEntry = null,
+idx: usize = 0,
+sparse: bool = false,
 
-block_idx: usize = 0,
+interface: Reader,
-sparse_block: bool = false,
 
-interface: Io.Reader,
+pub fn init(decomp: *const Decompressor, file: OffsetFile, block_size: u32, blocks: []BlockSize, size: u64, init_offset: u64, frag: ?FragEntry, frag_offset: u32) DataReader {
-
-pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) !DataReader {
     return .{
-        .alloc = alloc,
-
-        .fil = fil,
-        .io = io,
         .decomp = decomp,
+        .file = file,
         .block_size = block_size,
-
-        .file_size = file_size,
-        .cur_offset = data_start,
         .blocks = blocks,
+        .size = size,
+        .frag = frag,
+        .frag_offset = frag_offset,
+
+        .offset = init_offset,
 
         .interface = .{
-            .buffer = try cache.getCache(io),
+            .buffer = &[1]u8{undefined} ** (1024 * 1024),
-            .seek = 0,
             .end = 0,
-            .vtable = &.{
+            .seek = 0,
-                .stream = stream,
+            .vtable = &.{ .stream = stream, .discard = discard, .readVec = readVec },
-                .discard = discard,
-                .readVec = readVec,
-            },
         },
     };
 }
-pub fn deinit(self: *DataReader) void {
-    if (self.interface.buffer.len > 0) {
-        const buf_nod: *SharedCache.BufferNode = @fieldParentPtr("cache", self.interface.buffer);
-        self.cache.returnCache(buf_nod);
-    }
-}
-pub fn addFrag(self: *DataReader, frag_offset: u32, entry: FragEntry) void {
-    self.frag_offset = frag_offset;
-    self.frag_entry = entry;
-}
 
-fn numBlocks(self: DataReader) usize {
+fn numBlocks(self: *DataReader) usize {
-    var num = self.blocks.len;
+    return if (self.frag == null)
-    if (self.frag_entry != null) num += 1;
+        self.blocks.len
-    return num;
+    else
+        self.blocks.len + 1;
 }
-fn advanceBuffer(self: *DataReader) !void {
+fn advanceBuffer(self: *DataReader) Reader.Error!void {
-    if (self.block_idx >= self.numBlocks()) {
+    if (self.idx >= self.numBlocks()) return Reader.Error.EndOfStream;
-        return Reader.Error.EndOfStream;
+    defer self.idx += 1;
+    self.sparse = false;
+    self.interface.end = 0; // If we error out and the error is ignored, we'll stil end up back here to error again.
+    self.interface.seek = 0;
+    if (self.idx == self.blocks.len) { // Fragment
+        var rdr = self.file.readerAt(self.frag.?.block_start, &[0]u8{}) catch return Reader.Error.ReadFailed;
+        const size = self.size % self.block_size;
+        if (self.frag.?.size.uncompressed) {
+            try rdr.interface.discardAll(self.frag_offset);
+            try rdr.interface.readSliceAll(self.interface.buffer[0..size]);
+            self.interface.end = size;
+            return;
         }
-    defer self.block_idx += 1;
+        const raw_loc = self.interface.buffer.len - self.frag.?.size.size;
-
+        try rdr.interface.readSliceAll(self.interface.buffer[raw_loc..]);
-    self.interface.end = if (self.block_idx == self.numBlocks() - 1)
+        _ = self.decomp.decompress(self.interface.buffer[raw_loc..], self.interface.buffer) catch
+            return Reader.Error.ReadFailed;
+        @memmove(self.interface.buffer[0..size], self.interface.buffer[self.frag_offset .. self.frag_offset + size]);
+        self.interface.end = size;
+        return;
+    }
+    const block = self.blocks[self.idx];
+    if (block.size == 0) {
+        self.interface.end = if (self.idx == self.numBlocks() - 1)
             self.size % self.block_size
         else
             self.block_size;
-
+        self.sparse = true;
-    // Fragment
-    if (self.block_idx == self.blocks.len) {
-        const entry = self.frag_entry.?;
-        if (entry.size.uncompressed) {
-            var rdr = try self.fil.readerAt(self.io, entry.start + self.frag_offset, &[0]u8{});
-            try rdr.interface.readSliceAll(self.interface.buffer[0..self.interface.end]);
-        } else {
-            @branchHint(.likely);
-            const tmp = try self.cache.getCache(self.io);
-            defer self.cache.returnCache(tmp);
-
-            var rdr = try self.fil.readerAt(self.io, entry.start, &[0]u8{});
-            try rdr.interface.readSliceAll(tmp.cache[0..entry.size.size]);
-            _ = try self.decomp.Decompress(self.alloc, tmp.cache[0..entry.size.size], self.interface.buffer[0..self.block_size]);
-            @memmove(self.interface.buffer[0..self.interface.end], self.interface.buffer[self.frag_offset .. self.frag_offset + self.interface.end]);
-        }
-        self.interface.seek = 0;
         return;
     }
-
+    defer self.offset += block.size;
-    // Normal Block
+    var rdr = try self.file.readerAt(self.offset, &[0]u8{});
-    const block = self.blocks[self.block_idx];
-    if (block.size == 0) {
-        self.interface.seek = 0;
-        self.sparse_block = true;
-        return;
-    } else {
-        self.sparse_block = false;
-    }
     if (block.uncompressed) {
-        try self.fil.readAt(self.io, self.cur_offset, self.interface.buffer[0..self.interface.end]);
+        try rdr.interface.readSliceAll(self.interface.buffer[0..block.size]);
-        self.cur_offset += self.interface.end;
+        self.interface.end = block.size;
-    } else {
+        return;
-        @branchHint(.likely);
-        const tmp = try self.cache.getCache(self.io);
-        defer self.cache.returnCache(tmp);
-
-        var rdr = try self.fil.readerAt(self.io, self.cur_offset, &[0]u8{});
-        try rdr.interface.readSliceAll(tmp.cache[0..block.size]);
-        self.cur_offset += block.size;
-        _ = try self.decomp.Decompress(self.alloc, tmp.cache[0..block.size], self.interface.buffer[0..self.interface.end]);
     }
-    self.interface.seek = 0;
+    const raw_loc = self.interface.buffer.len - block.size;
+    try rdr.interface.readSliceAll(self.interface.buffer[raw_loc..]);
+    self.interface.end = self.decomp.decompress(self.interface.buffer[raw_loc..], self.interface.buffer) catch
+        return Reader.Error.ReadFailed;
 }
 
-fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
+fn stream(r: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
-    var data: *DataReader = @fieldParentPtr("interface", rdr);
+    var self: *DataReader = @fieldParentPtr("interface", r);
-    if (rdr.seek == rdr.end)
+    if (r.seek == r.end) try self.advanceBuffer();
-        data.advanceBuffer() catch |err| return switch (err) {
+    if (limit == .nothing) return 0;
-            error.ReadFailed => error.ReadFailed,
-            error.EndOfStream => error.EndOfStream,
-            else => error.ReadFailed,
-        };
 
-    switch (limit) {
+    const to_write = @min(r.end - r.seek, @intFromEnum(limit));
-        .nothing => return 0,
+    const wrote = if (self.sparse)
-        .unlimited => {
+        try wrt.splatByte(0, to_write)
-            const wrote = if (data.sparse_block)
-                try wrt.splatByte(0, rdr.end - rdr.seek)
     else
-                try wrt.write(rdr.buffer[rdr.seek..rdr.end]);
+        try wrt.write(r.buffer[r.seek .. r.seek + to_write]);
-            rdr.seek += wrote;
+    r.seek += wrote;
     return wrote;
-        },
-        else => {
-            const to_read = @min(rdr.end - rdr.seek, @intFromEnum(limit));
-            const wrote = if (data.sparse_block)
-                try wrt.splatByte(0, to_read)
-            else
-                try wrt.write(rdr.buffer[rdr.seek .. rdr.seek + to_read]);
-            rdr.seek += wrote;
-            return wrote;
-        },
 }
-}
+fn discard(r: *Reader, limit: Limit) Reader.Error!usize {
-fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
+    var self: *DataReader = @fieldParentPtr("interface", r);
-    var data: *DataReader = @fieldParentPtr("interface", rdr);
+    if (r.seek == r.end) try self.advanceBuffer();
-    if (rdr.seek == rdr.end)
+    if (limit == .nothing) return 0;
-        data.advanceBuffer() catch |err| return switch (err) {
-            error.ReadFailed => error.ReadFailed,
-            error.EndOfStream => error.EndOfStream,
-            else => error.ReadFailed,
-        };
 
-    switch (limit) {
+    const adv = @min(r.end - r.seek, @intFromEnum(limit));
-        .nothing => return 0,
+    r.seek += adv;
-        .unlimited => {
-            const adv = rdr.end - rdr.seek;
-            rdr.seek = rdr.end;
     return adv;
-        },
-        else => {
-            const adv = @min(rdr.end - rdr.seek, @intFromEnum(limit));
-            rdr.seek += adv;
-            return adv;
-        },
 }
-}
+fn readVec(r: *Reader, vec: [][]u8) Reader.Error!usize {
-fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
+    var self: *DataReader = @fieldParentPtr("interface", r);
-    var data: *DataReader = @fieldParentPtr("interface", rdr);
+    if (r.seek == r.end) try self.advanceBuffer();
-    if (rdr.seek == rdr.end)
-        data.advanceBuffer() catch |err| return switch (err) {
-            error.ReadFailed => error.ReadFailed,
-            error.EndOfStream => error.EndOfStream,
-            else => error.ReadFailed,
-        };
 
     var wrote: usize = 0;
-    for (vec) |buf| {
+    for (vec) |slice| {
-        if (rdr.seek == rdr.end) break;
+        if (r.seek == r.end) break;
-
+        const to_copy = @min(r.end - r.seek, slice.len);
-        const to_copy = @min(rdr.end - rdr.seek, buf.len);
+        if (self.sparse) {
-        if (data.sparse_block)
+            @memset(slice[0..to_copy], 0);
-            @memset(buf[0..to_copy], 0)
+        } else {
-        else
+            @memcpy(slice[0..to_copy], r.buffer[r.seek .. r.seek + to_copy]);
-            @memcpy(buf[0..to_copy], rdr.buffer[rdr.seek .. rdr.seek + to_copy]);
+        }
-        rdr.seek += to_copy;
+        r.seek += to_copy;
         wrote += to_copy;
     }
     return wrote;

src/util/decompressor.zig

@@ -1,15 +0,0 @@
-//! A decompression interface
-
-const std = @import("std");
-
-const Decompressor = @This();
-
-pub const Error = std.Io.Reader.StreamError || std.mem.Allocator.Error;
-
-/// The actual decompression function.
-/// If the given decompressor is null, then the decompression should be done "stateless" without lasting allocations.
-decomp_fn: *const fn (?*const Decompressor, std.mem.Allocator, in: []u8, out: []u8) Error!usize,
-
-pub fn Decompress(self: *const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    return self.decomp_fn(self, alloc, in, out);
-}

src/util/iter.zig

@@ -0,0 +1,54 @@
+const std = @import("std");
+
+const MinimalSuperblock = @import("../archive.zig").MinimalSuperblock;
+const Decompressor = @import("../decomp.zig");
+const DirEntry = @import("../directory.zig").Entry;
+const File = @import("../file.zig");
+const Inode = @import("../inode.zig");
+const MetadataReader = @import("metadata.zig");
+const OffsetFile = @import("offset_file.zig");
+const Utils = @import("utils.zig");
+
+const Iter = @This();
+
+file: OffsetFile,
+super: MinimalSuperblock,
+decomp: Decompressor,
+
+entries: []DirEntry,
+idx: usize = 0,
+
+pub fn deinit(self: Iter) void {
+    for (self.entries) |ent|
+        ent.deinit(self.decomp.alloc);
+    self.decomp.alloc.free(self.entries);
+}
+
+pub fn next(self: *Iter) !?File {
+    if (self.idx >= self.entries.len) return null;
+    defer self.idx += 1;
+
+    const entry = self.entries[self.idx];
+
+    const new_name = try self.decomp.alloc.alloc(u8, entry.name.len);
+    @memcpy(new_name, entry.name);
+    return .{
+        .file = self.file,
+        .super = self.super,
+        .decomp = self.decomp,
+
+        .name = new_name,
+        .inode = Utils.readInode(
+            self.decomp.alloc,
+            &self.decomp,
+            self.file,
+            self.super.inode_start,
+            self.super.block_size,
+            entry.block_start,
+            entry.block_offset,
+        ),
+    };
+}
+pub fn reset(self: *Iter) void {
+    self.idx = 0;
+}

src/util/metadata.zig

@@ -2,102 +2,76 @@ const std = @import("std");
 const Reader = std.Io.Reader;
 const Writer = std.Io.Writer;
 const Limit = std.Io.Limit;
-const StreamError = std.Io.Reader.StreamError;
 
-const Decompressor = @import("decompressor.zig");
+const Decompressor = @import("../decomp.zig");
 
-const BlockHeader = packed struct(u16) {
+const Header = packed struct {
     size: u15,
     uncompressed: bool,
 };
 
-const This = @This();
+const MetadataReader = @This();
 
-alloc: std.mem.Allocator,
 rdr: *Reader,
 decomp: *const Decompressor,
 
-cur_block_start: u32 = 0,
+read_buf: [8192]u8 = undefined,
-next_start_start: u32 = 0,
-buf: [8192]u8 = undefined,
-
-err: ?anyerror = null,
 interface: Reader = .{
-    .buffer = &[0]u8{},
+    .buffer = &([1]u8{undefined} ** 8192),
     .end = 0,
     .seek = 0,
     .vtable = &.{
         .stream = stream,
         .discard = discard,
         .readVec = readVec,
-        // TODO: Potentially add rebase so that we can guarentee that self.block_start & interface.seek is correct.
     },
 },
 
-pub fn init(alloc: std.mem.Allocator, rdr: *Reader, decomp: *const Decompressor) This {
+pub fn init(rdr: *Reader, decomp: *const Decompressor) MetadataReader {
-    return .{
+    return .{ .rdr = rdr, .decomp = decomp };
-        .alloc = alloc,
-        .rdr = rdr,
-        .decomp = decomp,
-    };
 }
-
+fn advanceBuffer(self: *MetadataReader) Reader.Error!void {
-fn advance(self: *This) !void {
     self.interface.seek = 0;
-    var hdr: BlockHeader = undefined;
+    var hdr: Header = undefined;
-    try self.rdr.readSliceEndian(BlockHeader, @ptrCast(&hdr), .little);
+    try self.rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
-    self.cur_block_start = self.next_start_start;
+    try self.rdr.readSliceAll(self.read_buf[0..hdr.size]);
-    self.next_start_start += hdr.size;
     if (hdr.uncompressed) {
-        try self.rdr.readSliceEndian(u8, self.buf[0..hdr.size], .little);
+        @memcpy(self.interface.buffer[0..hdr.size], self.read_buf[0..hdr.size]);
         self.interface.end = hdr.size;
-        self.interface.buffer = self.buf[0..hdr.size];
         return;
-    } else {
-        @branchHint(.likely);
-        var tmp_buf: [8192]u8 = undefined;
-        try self.rdr.readSliceAll(tmp_buf[0..hdr.size]);
-        self.interface.end = try self.decomp.Decompress(self.alloc, tmp_buf[0..hdr.size], &self.buf);
-        self.interface.buffer = self.buf[0..self.interface.end];
     }
+    self.interface.end = self.decomp.decompress(self.read_buf[0..hdr.size], self.interface.buffer) catch |err|
+        return switch (err) {
+            error.OutOfMemory => error.ReadFailed,
+            else => err,
+        };
 }
 
-fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) StreamError!usize {
+fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
-    const self: *This = @fieldParentPtr("interface", rdr);
+    var self: *MetadataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.end == rdr.seek) self.advance() catch |err| {
+    if (rdr.seek == rdr.end) try self.advanceBuffer();
-        self.err = err;
+    const to_write = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-        return StreamError.ReadFailed;
+    const wrote = try wrt.write(rdr.buffer[rdr.seek .. rdr.seek + to_write]);
-    };
+    rdr.seek += wrote;
-    if (@intFromEnum(limit) == 0) return 0;
-    const to_write = @min(rdr.end - rdr.seek, @intFromEnum(limit));
-    const wrote = try wrt.write(self.buf[rdr.seek .. rdr.seek + to_write]);
-    self.interface.seek += wrote;
     return wrote;
 }
 fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
-    const self: *This = @fieldParentPtr("interface", rdr);
+    var self: *MetadataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.end == rdr.seek) self.advance() catch |err| {
+    if (rdr.seek == rdr.end) try self.advanceBuffer();
-        self.err = err;
+    const to_adv = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-        return error.ReadFailed;
+    rdr.seek += to_adv;
-    };
+    return to_adv;
-    if (@intFromEnum(limit) == 0) return 0;
-    const to_skip = @min(rdr.end - rdr.seek, @intFromEnum(limit));
-    rdr.seek += to_skip;
-    return to_skip;
 }
 fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
-    const self: *This = @fieldParentPtr("interface", rdr);
+    var self: *MetadataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.end == rdr.seek) self.advance() catch |err| {
+    if (rdr.seek == rdr.end) try self.advanceBuffer();
-        self.err = err;
+    var wrote = 0;
-        return error.ReadFailed;
+    for (vec) |v| {
-    };
+        if (rdr.seek == rdr.end) break;
-    var cur_red: usize = 0;
+        const to_write = @min(v.len, rdr.end - rdr.seek);
-    for (vec) |s| {
+        @memcpy(v[0..to_write], rdr.buffer[rdr.seek .. rdr.seek + to_write]);
-        const to_copy: usize = @min(rdr.end - rdr.seek, s.len);
+        wrote += to_write;
-        @memcpy(s[0..to_copy], self.buf[rdr.seek .. rdr.seek + to_copy]);
+        rdr.seek += to_write;
-        rdr.seek += to_copy;
-        cur_red += to_copy;
-        if (rdr.end == rdr.seek) break;
     }
-    return cur_red;
+    return wrote;
 }

src/util/misc.zig

@@ -1,25 +0,0 @@
-//! Miscellaneous utility functions.
-
-const std = @import("std");
-const Io = std.Io;
-
-const Inode = @import("../inode.zig");
-const Decompressor = @import("decompressor.zig");
-const MetadataReader = @import("metadata.zig");
-const OffsetFile = @import("offset_file.zig");
-
-/// check is the path is referencing itself ("" or ".").
-/// separators must be trimmed before calling this function for it to work properly.
-pub fn pathIsSelf(path: []const u8) bool {
-    if (path.len == 0) return true;
-    if (path.len > 1) return false;
-    return path[0] == '.';
-}
-/// Creates an Inode from an Inode.Ref.
-pub fn inodeFromRef(alloc: std.mem.Allocator, io: Io, file: OffsetFile, decomp: *const Decompressor, inode_start: u64, block_size: u32, ref: Inode.Ref) !Inode {
-    var rdr = try file.readerAt(io, inode_start + ref.block_start, &[0]u8{});
-    var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
-    try meta.interface.discardAll(ref.block_offset);
-
-    return .read(alloc, &meta.interface, block_size);
-}

src/util/offset_file.zig

@@ -1,29 +1,21 @@
-//! A File where it's meaningful (to us) content starts at a given offset.
-
 const std = @import("std");
 const Io = std.Io;
-const File = Io.File;
+const FileReader = Io.File.Reader;
-const Reader = File.Reader;
 
 const OffsetFile = @This();
 
-fil: File,
+fil: Io.File,
-offset: u64,
+offset: u64 = 0,
 
-pub fn init(fil: File, init_offset: u64) OffsetFile {
+pub fn readerAt(self: OffsetFile, io: Io, offset: u64, buf: []u8) !FileReader {
-    return .{ .fil = fil, .offset = init_offset };
+    var rdr = self.fil.reader(io, buf);
-}
-
-pub fn readerAt(self: OffsetFile, io: Io, offset: u64, buffer: []u8) !Reader {
-    var rdr = self.fil.reader(io, buffer);
     try rdr.seekTo(self.offset + offset);
     return rdr;
 }
-pub fn readAt(self: OffsetFile, io: Io, offset: u64, buf: []u8) !void {
+pub fn valueAt(self: OffsetFile, comptime T: type, io: Io, offset: u64) !T {
-    _ = try self.fil.readPositionalAll(io, buf, self.offset + offset);
+    var rdr = self.fil.reader(io, &[0]u8{});
-}
+    try rdr.seekTo(self.offset + offset);
-pub fn readValueAt(self: OffsetFile, comptime T: anytype, io: Io, offset: u64) !void {
-    //TODO: check for endianess and decode accordingly.
     var new: T = undefined;
-    _ = try self.fil.readPositionalAll(io, @ptrCast(&new), self.offset + offset);
+    try rdr.interface.readSliceEndian(T, @ptrCast(&new), .little);
+    return new;
 }

src/util/shared_cache.zig

@@ -1,52 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Node = std.SinglyLinkedList.Node;
-
-const SharedCache = @This();
-
-pub const CACHE_SIZE = 1024 * 1024;
-
-pub const BufferNode = struct {
-    node: Node,
-    cache: [CACHE_SIZE]u8,
-};
-
-alloc: std.mem.Allocator,
-
-caches: std.ArrayList(BufferNode),
-cache_queue: std.SinglyLinkedList,
-queue_mut: Io.Mutex,
-
-pub fn init(alloc: std.mem.Allocator, init_cache_size: u32) !SharedCache {
-    const caches: std.ArrayList(BufferNode) = try .initCapacity(alloc, init_cache_size);
-    var queue: std.SinglyLinkedList = .{};
-    for (caches.items) |item|
-        queue.prepend(&item.node);
-    return .{
-        .alloc = alloc,
-
-        .caches = caches,
-        .cache_queue = queue,
-    };
-}
-pub fn deinit(self: *SharedCache) void {
-    self.caches.deinit(self.alloc);
-}
-
-pub fn getCache(self: *SharedCache, io: Io) !*BufferNode {
-    self.queue_mut.lock(io);
-    const nxt = self.cache_queue.popFirst();
-    self.queue_mut.unlock(io);
-    if (nxt == null) {
-        const new = try self.caches.addOne(self.alloc);
-        new.* = .{
-            .node = .{},
-            .cache = undefined,
-        };
-        return new;
-    }
-    return @fieldParentPtr("node", nxt.?);
-}
-pub fn returnCache(self: *SharedCache, buf: *BufferNode) void {
-    self.cache_queue.prepend(buf);
-}

src/util/utils.zig

@@ -0,0 +1,25 @@
+const std = @import("std");
+
+const Decompressor = @import("../decomp.zig");
+const DirEntry = @import("../directory.zig").Entry;
+const Inode = @import("../inode.zig");
+const MetadataReader = @import("metadata.zig");
+const OffsetFile = @import("offset_file.zig");
+
+pub fn pathIsSelf(path: []const u8) bool {
+    if (path.len == 0) return true;
+    if (path.len == 1) {
+        return switch (path[0]) {
+            '.', '/' => true,
+            else => false,
+        };
+    }
+    return std.mem.eql(u8, path, "./");
+}
+
+pub fn readInode(alloc: std.mem.Allocator, decomp: *const Decompressor, fil: OffsetFile, inode_start: u64, block_size: u32, block_start: u32, block_offset: u16) !Inode {
+    var rdr = try fil.readerAt(inode_start + block_start, &[0]u8{});
+    var meta: MetadataReader = .init(&rdr.interface, decomp);
+    try meta.interface.discardAll(block_offset);
+    return .read(alloc, &meta.interface, block_size);
+}

src/xattr_table.zig

@@ -1,284 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const InodeRef = @import("inode.zig").Ref;
-const LookupTable = @import("lookup_table.zig");
-const Decompressor = @import("util/decompressor.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-
-const XattrCachedTable = @This();
-
-alloc: std.mem.Allocator,
-
-fil: OffsetFile,
-decomp: *const Decompressor,
-
-kv_start: u64,
-
-table: LookupTable.CachedTable(TableValue),
-value_cache: std.AutoHashMap(InodeRef, []const u8),
-value_mut: Io.Mutex,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, xattr_start: u64) !XattrCachedTable {
-    var rdr = try fil.readerAt(io, xattr_start, &[0]u8{});
-
-    var start: u64 = undefined;
-    try rdr.interface.readSliceEndian(u64, @ptrCast(&start), .little);
-    var num: u32 = undefined;
-    try rdr.interface.readSliceEndian(u32, @ptrCast(&num), .little);
-
-    return .{
-        .alloc = alloc,
-
-        .fil = fil,
-        .decomp = decomp,
-
-        .kv_start = start,
-
-        .table = .init(alloc, fil, xattr_start + 16, num),
-        .value_cache = .init(alloc),
-    };
-}
-pub fn deinit(self: *XattrCachedTable) void {
-    self.table.deinit();
-    self.value_cache.deinit();
-}
-
-pub fn get(self: *XattrCachedTable, alloc: std.mem.Allocator, io: Io, idx: u32) ![]XattrSemiOwned {
-    const lookup = try self.table.get(io, idx);
-
-    var rdr = try self.fil.readerAt(io, self.kv_start + lookup.ref.block_start, &[0]u8{});
-    var meta: MetadataReader = .init(alloc, &rdr.interface, self.decomp);
-    try meta.interface.discardAll(lookup.ref.block_offset);
-
-    const out = try alloc.alloc(XattrSemiOwned, lookup.count);
-    errdefer alloc.free(out);
-
-    for (0..lookup.count) |i| {
-        const key_entry: KeyEntry = undefined;
-        try meta.interface.readSliceEndian(KeyEntry, @ptrCast(&key_entry), .little);
-
-        const key = switch (key_entry.type.namespace) {
-            .user => blk: {
-                const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 5);
-                errdefer alloc.free(tmp);
-                try meta.interface.readSliceEndian(u8, tmp[5 .. tmp.len - 1], .little);
-                @memset(tmp[0..5], "user.");
-                break :blk tmp;
-            },
-            .trusted => blk: {
-                const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 8);
-                errdefer alloc.free(tmp);
-                try meta.interface.readSliceEndian(u8, tmp[8 .. tmp.len - 1], .little);
-                @memset(tmp[0..8], "trusted.");
-                break :blk tmp;
-            },
-            .security => blk: {
-                const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 9);
-                errdefer alloc.free(tmp);
-                try meta.interface.readSliceEndian(u8, tmp[9 .. tmp.len - 1], .little);
-                @memset(tmp[0..9], "security.");
-                break :blk tmp;
-            },
-        };
-        key[key.len - 1] = 0;
-        errdefer alloc.free(key);
-
-        if (key_entry.type.out_of_line) {
-            const value: ValueOutOfLineEntry = undefined;
-            try meta.interface.readSliceEndian(ValueOutOfLineEntry, @ptrCast(&value), .little);
-
-            out[i] = .{
-                .key = key,
-                .value = try self.valueAt(io, value.ref),
-            };
-            continue;
-        }
-        const val_ref: InodeRef = .{ .block_start = meta.cur_block_start, .block_offset = meta.interface.seek };
-
-        try self.value_mut.lock(io);
-        defer self.value_mut.unlock(io);
-        if (self.value_cache.contains(val_ref)) {
-            out[i] = .{
-                .key = key,
-                .value = try self.valueAt(io, val_ref),
-            };
-            continue;
-        }
-
-        var val_size: u32 = undefined;
-        try meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
-
-        const val = try self.alloc.alloc(u8, val_size);
-        errdefer alloc.free(val);
-        try meta.interface.readSliceEndian(u8, val, .little);
-
-        try self.value_cache.put(val_ref, val);
-        out[i] = .{
-            .key = key,
-            .value = val,
-        };
-    }
-    return out;
-}
-
-fn valueAt(self: *XattrCachedTable, io: Io, ref: InodeRef) ![]const u8 {
-    try self.value_mut.lock(io);
-    defer self.value_mut.unlock(io);
-
-    if (self.value_cache.contains(ref)) return self.value_cache.get(ref).?;
-
-    var rdr = try self.fil.readerAt(io, self.kv_start + ref.block_start, &[0]u8{});
-    var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
-    try meta.interface.discardAll(ref.block_offset);
-
-    var val_size: u32 = undefined;
-    try meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
-
-    const val = try self.alloc.alloc(u8, val_size);
-    errdefer self.alloc.free(val);
-    try meta.interface.readSliceEndian(u8, val, .little);
-
-    try self.value_cache.put(ref, val);
-    return val;
-}
-
-// Types
-
-/// An Xattr return value where the reciever only owns the key value.
-pub const XattrSemiOwned = struct {
-    key: [:0]const u8,
-    value: []const u8,
-
-    pub fn deinit(self: XattrSemiOwned, alloc: std.mem.Allocator) void {
-        alloc.free(self.key);
-    }
-};
-/// An Xattr return value where the reciever owns both the key & value.
-pub const XattrOwned = struct {
-    key: [:0]const u8,
-    value: []const u8,
-
-    pub fn deinit(self: XattrSemiOwned, alloc: std.mem.Allocator) void {
-        alloc.free(self.key);
-        alloc.free(self.value);
-    }
-};
-
-const TableValue = extern struct {
-    ref: InodeRef,
-    count: u32,
-    size: u32,
-};
-
-const KeyEntry = extern struct {
-    type: XattrPrefix,
-    name_size: u16,
-};
-const ValueOutOfLineEntry = extern struct {
-    _: u32,
-    ref: InodeRef,
-};
-
-const XattrPrefix = packed struct(u16) {
-    namespace: enum(u8) {
-        user,
-        trusted,
-        security,
-
-        fn prefixSize(self: @This()) u16 {
-            return switch (self) {
-                .user => 5,
-                .trusted => 8,
-                .security => 9,
-            };
-        }
-    },
-    out_of_line: bool,
-    _: u7,
-};
-
-// Stateless
-
-pub fn statelessLookup(alloc: std.mem.Allocator, io: Io, decomp: *const Decompressor, fil: OffsetFile, table_start: u64, idx: u16) ![]XattrOwned {
-    var rdr = try fil.readerAt(io, table_start, &[0]u8{});
-
-    var kv_start: u64 = undefined;
-    try rdr.interface.readSliceEndian(u64, @ptrCast(&kv_start), .little);
-
-    const lookup = try LookupTable.lookupValue(TableValue, alloc, io, decomp, fil, table_start + 16, idx);
-
-    rdr = try fil.readerAt(io, kv_start + lookup.ref.block_start, &[0]u8{});
-    var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
-    try meta.interface.discardAll(lookup.ref.block_offset);
-
-    const out = try alloc.alloc(XattrOwned, lookup.count);
-    errdefer alloc.free(out);
-
-    for (0..lookup.count) |i| {
-        const key_entry: KeyEntry = undefined;
-        try meta.interface.readSliceEndian(KeyEntry, @ptrCast(&key_entry), .little);
-
-        const key = switch (key_entry.type.namespace) {
-            .user => blk: {
-                const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 5);
-                errdefer alloc.free(tmp);
-                try meta.interface.readSliceEndian(u8, tmp[5 .. tmp.len - 1], .little);
-                @memset(tmp[0..5], "user.");
-                break :blk tmp;
-            },
-            .trusted => blk: {
-                const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 8);
-                errdefer alloc.free(tmp);
-                try meta.interface.readSliceEndian(u8, tmp[8 .. tmp.len - 1], .little);
-                @memset(tmp[0..8], "trusted.");
-                break :blk tmp;
-            },
-            .security => blk: {
-                const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 9);
-                errdefer alloc.free(tmp);
-                try meta.interface.readSliceEndian(u8, tmp[9 .. tmp.len - 1], .little);
-                @memset(tmp[0..9], "security.");
-                break :blk tmp;
-            },
-        };
-        key[key.len - 1] = 0;
-        errdefer alloc.free(key);
-
-        if (key_entry.type.out_of_line) {
-            const value: ValueOutOfLineEntry = undefined;
-            try meta.interface.readSliceEndian(ValueOutOfLineEntry, @ptrCast(&value), .little);
-
-            var ool_rdr = try fil.readerAt(io, kv_start + value.ref.block_start, &[0]u8{});
-            var ool_meta: MetadataReader = .init(alloc, &ool_rdr.interface, decomp);
-            try ool_meta.interface.discardAll(value.ref.block_offset);
-
-            var val_size: u32 = undefined;
-            try ool_meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
-
-            const val = try alloc.alloc(u8, val_size);
-            errdefer alloc.free(val);
-            try ool_meta.interface.readSliceEndian(u8, val, .little);
-
-            out[i] = .{
-                .key = key,
-                .value = val,
-            };
-            continue;
-        }
-
-        var val_size: u32 = undefined;
-        try meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
-
-        const val = try alloc.alloc(u8, val_size);
-        errdefer alloc.free(val);
-        try meta.interface.readSliceEndian(u8, val, .little);
-
-        out[i] = .{
-            .key = key,
-            .value = val,
-        };
-    }
-    return out;
-}