Finished (theoretically) file extraction.

Work on extraction
Created DataExtractor & DataReader Created Lookup tables
2026-05-30 17:29:50 -05:00 · 2026-05-30 06:22:26 -05:00 · 2026-05-29 18:50:45 -05:00 · 2026-05-29 06:20:06 -05:00 · 2026-05-28 06:13:00 -05:00 · 2026-04-02 06:27:34 -05:00
38 changed files with 2232 additions and 1620 deletions
@@ -0,0 +1,31 @@
+name: Release Build
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+      - uses: mlugg/setup-zig@v2
+      - name: Install deps
+        run: sudo apt update && sudo apt install -y liblzma-dev liblzo2-dev
+      - name: Build normal version
+        run: zig build --release=fast -Duse_zig_decomp=true -Dversion=${{ github.ref_name }}
+      - name: Move zig build out
+        run: mv zig-out/bin/unsquashfs ./unsquashfs-x86_64-zig-libs
+      - name: Rebuild with C libraries
+        run: zig build --release=fast -Dversion="${{ github.ref_name }}"
+      - name: Move C build out
+        run: mv zig-out/bin/unsquashfs ./unsquashfs-x86_64-c-libs
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          prerelease: true
+          files: |
+            unsquashfs-x86_64-zig-libs
+            unsquashfs-x86_64-c-libs
@@ -2,3 +2,4 @@ testing/

 .zig-cache/
 zig-out/
+zig-pkg/
@@ -0,0 +1,25 @@
+// Project-local debug tasks
+//
+// For more documentation on how to configure debug tasks,
+// see: https://zed.dev/docs/debugger
+[
+	{
+		"label": "Build & Run",
+
+		"adapter": "CodeLLDB",
+		"request": "launch",
+
+		"build": {
+			"command": "zig",
+			"args": ["build", "-Ddebug=true"],
+		},
+
+		"program": "zig-out/bin/unsquashfs",
+		"args": [
+			"--force",
+			"-d",
+			"testing/TestExtractUnsquashfs",
+			"testing/LinuxPATest.sfs",
+		],
+	},
+]
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2025 Caleb Gardner
+Copyright (c) 2026 Caleb Gardner

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -1,7 +1,75 @@
 # zig-squashfs

-Messing around with zig via making a squashfs library. May amount to something. Or not.
+This is my experiments to learn Zig. Might amount to something. Might not.

-## Current state
+A library and application to decompress or view squashfs archives.

-Performance is reatively bad (when compared to the official [squashfs-tools](https://github.com/plougher/squashfs-tools), but the basics should fully work.
+## Current State
+
+Overall works, but currently is missing some features ([see below](#capabilities)) and has significantly slow performance compared to `unsquashfs` ([see below](#performance)).
+
+## Build options
+
+> `-Duse_c_libs=true`
+
+Instead of using Zig's standard library for decompression, use the system's C libraries. Has the benefit of being much faster and enabling LZO and LZ4 decompression.
+
+> `-Dallow_lzo=true`
+
+Enable compiling with LZO decompression support. The LZO library currently has some issues with Zig when imported so it's easier to just disable it by default. Only has an effect when using `-Duse_c_libs=true`.
+
+> `-Ddebug=true`
+
+Sets various build options that make debugging easier. Specifically, debug optimization is forced, valgrind support is enabled, error tracing is enabled, stipping is disabled, and copmilation uses LLVM (this is due to some linking issues when on Debug optimization and is required for debugging tools such as `lldb`. In the future this may be removed from the debug flag).
+
+> `-Dversion=0.0.0`
+
+Sets the version of `unsquashfs` shown when `--version` is passed.
+
+## Capabilities
+
+Most features are present except for the following:
+
+* When using Zig decompression libraries then lzo and lz4 compression types are unavailable. I don't _currently_ plan on spending the time to find and validate a library since neither is popular.
+* When using C decompression libraries, lzo is not supported by default due to [some issues](#build-considerations). If it's needed it's trivial to fix, but it's easiest to just leave it disabled.
+
+## Performance
+
+This is some basic observation's I've made about this library's performance when compared to `unsquashfs`. Unless otherwise stated, most observations were made when extracting my test archive (which is fairly small and uses zstd compression) and with `--release=fast`.
+
+Currently, my only performance checks are checking execution time, nothing deeper.
+
+* Under ideal circumstances, my library is ~70% slower (.12s vs .20s).
+* Using Zig decompression libraries *significantly* increases decompression time by ~600%. Under ideal circumstances.
+* Performance improvements/regressions will be common. I'm still learning Zig.
+
+Example Times:
+
+* *unsquashfs, multi-threaded*: .12s
+* *unsquashfs, single-threaded*: .13s
+* *C-libs, single-threaded*: .45s
+* *C-libs, multi-threaded*: .20s
+* *Zig-libs, single-threaded*: 5.78s
+* *Zig-libs, multi-threaded*: 1.08s
+
+## Build considerations
+
+Compilation without `use_c_libs` works completely fine, but Zig has issues with some symbols from the lzo library that needs to be manually fixed. In particular you need to fix the definitions for `lzo_bytep` and `lzo_voidp` to be `*u8` and `?*anyopaque` respectively. Due to this, you have to manually enable LZO decompression using `-Dallow_lzo=true` when building.
+
+```zig
+pub const lzo_bytep = @compileError("unable to translate C expr: unexpected token ''");
+// /usr/include/lzo/lzoconf.h:148:9
+pub const lzo_charp = @compileError("unable to translate C expr: unexpected token ''");
+// /usr/include/lzo/lzoconf.h:149:9
+pub const lzo_voidp = @compileError("unable to translate C expr: unexpected token ''");
+```
+
+to
+
+```zig
+pub const lzo_bytep = *u8;
+// /usr/include/lzo/lzoconf.h:148:9
+pub const lzo_charp = @compileError("unable to translate C expr: unexpected token ''");
+// /usr/include/lzo/lzoconf.h:149:9
+pub const lzo_voidp = ?*anyopaque;
+```
@@ -1,53 +1,125 @@
 const std = @import("std");
-
-/// version if version isn't provided during build
-const def_version = "0.0.0+testing";
+const Build = std.Build;

 pub fn build(b: *std.Build) !void {
-    const opt = b.addOptions();
-    const ver = b.option([]const u8, "version", "sematic version") orelse def_version;
-    const sem_ver = try std.SemanticVersion.parse(ver);
-    opt.addOption(std.SemanticVersion, "version", sem_ver);
-    const target = b.standardTargetOptions(.{});
+    const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
+    const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo decompression support.") orelse false;
+    const dynamic = b.option(bool, "dynamic", "Dynamic link C decompression libraries.") orelse false;
+    const debug = b.option(bool, "debug", "Enable options to make debugging easier.") orelse false;
+    const version_string = b.option([]const u8, "version", "Version of the library/binary") orelse "0.0.0-testing";
+
+    const version: std.SemanticVersion = try .parse(version_string);
+
+    const zig_squashfs_options = b.addOptions();
+    zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
+    zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);
+
    const optimize = b.standardOptimizeOption(.{});
-    const lib_mod = b.createModule(.{
-        .root_source_file = b.path("src/root.zig"),
-        .target = target,
+    const target = b.standardTargetOptions(.{});
+
+    const c = b.addTranslateC(.{
        .optimize = optimize,
+        .target = target,
+        .root_source_file = b.path("src/c.h"),
    });
+    if (allow_lzo)
+        c.defineCMacro("ALLOW_LZO", null);
+    if (dynamic) {
+        c.linkSystemLibrary("z", .{});
+        c.linkSystemLibrary("lzma", .{});
+        c.linkSystemLibrary("lz4", .{});
+        c.linkSystemLibrary("zstd", .{});
+        if (allow_lzo)
+            c.linkSystemLibrary("minilzo", .{});
+    }
+
+    const deps = try getDependencies(b, optimize, target, allow_lzo);
+
    const lib = b.addLibrary(.{
-        .linkage = .static,
-        .name = "zig_squashfs",
-        .root_module = lib_mod,
-        .version = sem_ver,
+        .name = "squashfs",
+        .use_llvm = debug,
+        .version = version,
+        .root_module = b.createModule(.{
+            .imports = &.{
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
+                .{ .name = "c", .module = c.createModule() },
+            },
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/root.zig"),
+            .valgrind = debug,
+        }),
    });

-    const exe_mod = b.createModule(.{
-        .root_source_file = b.path("src/bin/unsquashfs.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-    exe_mod.addImport("squashfs", lib_mod);
-    exe_mod.addOptions("config", opt);
-    const exe = b.addExecutable(.{
-        .linkage = .static,
-        .name = "unsquashfs",
-        .root_module = exe_mod,
-        .version = sem_ver,
-    });
+    for (deps) |d|
+        lib.root_module.linkLibrary(d);

    b.installArtifact(lib);
+
+    const exe_config = b.addOptions();
+    exe_config.addOption(std.SemanticVersion,"version", version);
+
+    const exe = b.addExecutable(.{
+        .name = "unsquashfs",
+        .use_llvm = debug,
+        .version = version,
+        .root_module = b.createModule(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/bin/unsquashfs.zig"),
+            .valgrind = debug,
+            .imports = &.{
+                .{ .name = "config", .module = exe_config.createModule() },
+                .{ .name = "squashfs", .module = lib.root_module }
+            },
+        }),
+    });
+
    b.installArtifact(exe);

-    const lib_unit_tests = b.addTest(.{
-        .root_module = lib_mod,
+    const lib_test = b.addTest(.{
+        .name = "squashfs-test",
+        .root_module = lib.root_module,
    });
-    const exe_unit_test = b.addTest(.{
-        .root_module = exe_mod,
+    const test_step = b.step("test", "Run tests");
+    test_step.dependOn(&lib_test.step);
+
+    // zls check step
+    const lib_check = b.addLibrary(.{
+        .name = "squashfs-check",
+        .root_module = lib.root_module,
    });
-    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
-    const run_exe_unit_tests = b.addRunArtifact(exe_unit_test);
-    const test_step = b.step("test", "Run unit tests");
-    test_step.dependOn(&run_lib_unit_tests.step);
-    test_step.dependOn(&run_exe_unit_tests.step);
+    const exe_check = b.addLibrary(.{
+        .name = "unsquashfs-check",
+        .root_module = exe.root_module,
+    });
+
+    const check = b.step("check", "Check if squashfs compiles");
+    check.dependOn(&lib_check.step);
+    check.dependOn(&exe_check.step);
+}
+
+fn getDependencies(b: *Build, optimize: std.builtin.OptimizeMode, target: Build.ResolvedTarget, allow_lzo: bool) ![]*Build.Step.Compile {
+    const alloc = b.allocator;
+
+    var list: std.ArrayList(*Build.Step.Compile) = .empty;
+
+    const zlib_ng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, zlib_ng.artifact("zng"));
+
+    const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, xz.artifact("lzma"));
+
+    const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, lz4.artifact("lz4"));
+
+    const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
+    try list.append(alloc, zstd.artifact("zstd"));
+
+    if (allow_lzo) {
+        const minilzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
+        try list.append(alloc, minilzo.artifact("minilzo"));
+    }
+
+    return list.toOwnedSlice(b.allocator);
 }
@@ -1,55 +1,30 @@
 .{
-    .name = .zig_squashfs,
-    .version = "0.0.1",
-    .fingerprint = 0x527960c72c03ffe3, // Changing this has security and trust implications.
-
-    .minimum_zig_version = "0.14.0",
-
-    // This field is optional.
-    // Each dependency must either provide a `url` and `hash`, or a `path`.
-    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
-    // Once all dependencies are fetched, `zig build` no longer requires
-    // internet connectivity.
+    .name = .squashfs,
+    .version = "0.0.6",
+    .fingerprint = 0x37ba29474b87f145, // Changing this has security and trust implications.
+    .minimum_zig_version = "0.16.0",
    .dependencies = .{
-        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
-        //.example = .{
-        //    // When updating this field to a new URL, be sure to delete the corresponding
-        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
-        //    // the new URL. If the contents of a URL change this will result in a hash mismatch
-        //    // which will prevent zig from using it.
-        //    .url = "https://example.com/foo.tar.gz",
-        //
-        //    // This is computed from the file contents of the directory of files that is
-        //    // obtained after fetching `url` and applying the inclusion rules given by
-        //    // `paths`.
-        //    //
-        //    // This field is the source of truth; packages do not come from a `url`; they
-        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
-        //    // obtain a package matching this `hash`.
-        //    //
-        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
-        //    .hash = "...",
-        //
-        //    // When this is provided, the package is found in a directory relative to the
-        //    // build root. In this case the package's hash is irrelevant and therefore not
-        //    // computed. This field and `url` are mutually exclusive.
-        //    .path = "foo",
-        //
-        //    // When this is set to `true`, a package is declared to be lazily
-        //    // fetched. This makes the dependency only get fetched if it is
-        //    // actually used.
-        //    .lazy = false,
-        //},
+        .zlib_ng = .{
+            .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
+            .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
+        },
+        .zstd = .{
+            .url = "git+https://github.com/allyourcodebase/zstd.git?ref=1.5.7-1#e1a501be57f42c541e8a5597e4b59a074dfd09a3",
+            .hash = "zstd-1.5.7-1-KEItkAMwAAD6OKY3m0OOmXG7aL-aLUfrDqbP5J5oYapU",
+        },
+        .lz4 = .{
+            .url = "git+https://github.com/allyourcodebase/lz4.git?ref=1.10.0-6#41f52ab227caf9d48cf88c89a4d2946caa12b102",
+            .hash = "lz4-1.10.0-6-ewyzw-4NAAAWDpY4xpiqr4LQhZQAC0x_rGnW2iPh6jk2",
+        },
+        .minilzo = .{
+            .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
+            .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
+        },
+        .xz = .{
+            .url = "git+https://github.com/akunaakwei/zig-xz.git#e2d389262c8291907e3e4c6fb119819141c16c0f",
+            .hash = "xz-5.8.2-6v47_JYeAABSL-jonprpL5-E_YaaGc4B5xrbe93WsJ3G",
+        },
    },
-
-    // Specifies the set of files and directories that are included in this package.
-    // Only files and directories listed here are included in the `hash` that
-    // is computed for this package. Only files listed here will remain on disk
-    // when using the zig package manager. As a rule of thumb, one should list
-    // files required for compilation plus any license(s).
-    // Paths are relative to the build root. Use the empty string (`""`) to refer to
-    // the build root itself.
-    // A directory listed here means that all files within, recursively, are included.
    .paths = .{
        "build.zig",
        "build.zig.zon",
@@ -0,0 +1,10 @@
+#!/bin/sh
+
+zig test \
+	-lc \
+	-lz \
+	-llzma \
+	-lminilzo \
+	-llz4 \
+	-lzstd \
+		src/test.zig
@@ -0,0 +1,185 @@
+const std = @import("std");
+const Io = std.Io;
+const File = Io.File;
+const MemoryMap = File.MemoryMap;
+
+const Decomp = @import("decomp.zig");
+const DecompCache = @import("decomp_cache.zig");
+const Extract = @import("extract.zig");
+const ExtractionOptions = @import("options.zig");
+const Inode = @import("inode.zig");
+const SfsFile = @import("file.zig");
+
+const Archive = @This();
+
+const CACHE_MEM_MAX = 1024 * 1024 * 1024;
+
+super: Superblock,
+
+cache: DecompCache,
+
+pub fn init(alloc: std.mem.Allocator, io: Io, fil: File) !Archive {
+    return initAdvanced(alloc, io, fil, 0, 0);
+}
+pub fn initAdvanced(alloc: std.mem.Allocator, io: Io, fil: File, offset: u64, cache_memory_max: u64) !Archive {
+    var rdr = fil.reader(io, &[0]u8{});
+    try rdr.seekTo(offset);
+    var super: Superblock = undefined;
+    try rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
+    try super.validate();
+
+    const map = try fil.createMemoryMap(io, .{
+        .offset = offset,
+        .len = super.size,
+        .protection = .{ .read = true },
+    });
+
+    return .{
+        .super = super,
+
+        .cache = try .init(
+            alloc,
+            map,
+            super.compression,
+            if (cache_memory_max != 0)
+                cache_memory_max
+            else
+                @min(CACHE_MEM_MAX, (try std.process.totalSystemMemory()) / 2),
+        ),
+    };
+}
+pub fn deinit(self: *Archive, io: Io) void {
+    self.cache.deinit(io);
+}
+
+pub fn root(self: *Archive, alloc: std.mem.Allocator, io: Io) !SfsFile {
+    const inode: Inode = try .initRef(
+        alloc,
+        io,
+        &self.cache,
+        self.super.inode_start,
+        self.super.block_size,
+        self.super.root_ref,
+    );
+    return .init(alloc, self, inode, "");
+}
+pub fn open(self: *Archive, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !SfsFile {
+    const path = std.mem.trim(u8, filepath, "/");
+
+    var root_file = try self.root(alloc, io);
+
+    if (path.len == 0 or path[0] == '.') return root_file;
+
+    defer root_file.deinit();
+    return root_file.open(alloc, io, filepath);
+}
+
+pub fn extract(self: *Archive, alloc: std.mem.Allocator, io: Io, ext_loc: []const u8, options: ExtractionOptions) !void {
+    const root_inode: Inode = try .initRef(
+        alloc,
+        io,
+        &self.cache,
+        self.super.inode_start,
+        self.super.block_size,
+        self.super.root_ref,
+    );
+    return Extract.extract(alloc, io, root_inode, &self.cache, self.super, ext_loc, options);
+}
+
+// Superblock
+
+pub const Superblock = extern struct {
+    magic: u32,
+    inode_count: u32,
+    mod_time: u32,
+    block_size: u32,
+    frag_count: u32,
+    compression: Decomp.Enum,
+    block_log: u16,
+    flags: packed struct(u16) {
+        inode_uncompressed: bool,
+        data_uncompressed: bool,
+        check: bool,
+        frag_uncompressed: bool,
+        frag_never: bool,
+        frag_always: bool,
+        de_dupe: bool,
+        exportable: bool,
+        xattr_uncompressed: bool,
+        xattr_never: bool,
+        compression_options: bool,
+        id_uncompressed: bool,
+        _: u4,
+    },
+    id_count: u16,
+    ver_maj: u16,
+    ver_min: u16,
+    root_ref: Inode.Ref,
+    size: u64,
+    id_start: u64,
+    xattr_start: u64,
+    inode_start: u64,
+    dir_start: u64,
+    frag_start: u64,
+    export_start: u64,
+
+    pub fn validate(self: Superblock) !void {
+        if (self.magic != std.mem.readInt(u32, "hsqs", .little))
+            return error.BadMagic;
+        if (self.ver_maj != 4 or self.ver_min != 0)
+            return error.InvalidVersion;
+        if (self.block_log != std.math.log2(self.block_size))
+            return error.BadBlockLog;
+        if (self.flags.check)
+            return error.BadCheckFlag;
+    }
+};
+
+// Test
+
+const TestArchive = "testing/LinuxPATest.sfs";
+
+test "Basics" {
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var archive_file = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer archive_file.close(io);
+    var arc: Archive = try .init(alloc, io, archive_file);
+    defer arc.deinit(io);
+
+    var root_file = try arc.root(alloc, io);
+    defer root_file.deinit();
+}
+
+const TestFile = "Start.exe";
+const TestFileExtractLocation = "testing/Start.exe";
+
+test "SingleFileExtraction" {
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var archive_file = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer archive_file.close(io);
+    var arc: Archive = try .init(alloc, io, archive_file);
+    defer arc.deinit(io);
+
+    var ext_file = try arc.open(alloc, io, TestFile);
+    defer ext_file.deinit();
+
+    try ext_file.extract(alloc, io, TestFileExtractLocation, .default);
+}
+
+const TestFullExtractLocation = "testing/TestExtract";
+
+test "FullExtraction" {
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var archive_file = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer archive_file.close(io);
+    var arc: Archive = try .init(alloc, io, archive_file);
+    defer arc.deinit(io);
+
+    try arc.extract(alloc, io, TestFullExtractLocation, .default);
+}
@@ -1,146 +1,136 @@
 const std = @import("std");
+const Io = std.Io;
+const Writer = Io.Writer;
+const File = Io.File;
+const builtin = @import("builtin");
+
 const config = @import("config");
 const squashfs = @import("squashfs");

-const help_msg =
-    \\Basic Usage: zig-unsquashfs [Options] SQUASHFS_FILE <EXTRACT_LOCATION>
+//TODO: Add more options
+const help_mgs =
    \\
-    \\General options:
-    \\  -e <path>           Path to a file or directory inside the archive to extract instead of the whole archive.
-    \\                          Can be given multiple times.
-    \\  -o <bytes>          Skip <bytes> before reading from the archive.
-    \\  -v                  Verbose output.
+    \\Usage: unsquashfs [options] <archive>
    \\
-    \\Extraction options:
-    \\  --unbreak-symlinks  Attempt extract symlink targets along with symlinks. Will not place files outside of the extraction location.
-    \\  -us                 Same as --unbreak-symlinks
-    \\  --deref-symlinks    Replace symlink files with their target.
-    \\  -ds                 Same as --deref-symlinks
-    \\  -p <#>              Use at most # of processors. Defaults to logical core count.
+    \\Options:
+    \\  -d <location>   Extract to the given location instead of "squashfs-root"
    \\
-    \\Listing Options:
-    \\  -l                  List files instead of extracting. When used, you do not need to specify an extraction location.
-    \\  -ll                 Similiar to -l, but with file attributes.
-    \\  -lln                Similiar to -ll, but with numeric uids and gids.
+    \\  -o <offset>     Start reading the archive at the given offset.
+    \\  -dx             Don't set xattr values
+    \\  -dp             Don't set permissions (includes setting uid & gid owner)
    \\
-    \\Other:
-    \\  --help              Prints this help message.
-    \\  -h                  Same as --help
-    \\  --version           Print version number.
+    \\  -p <threads>    Specify how many threads to use. If no present or zero, the system's logical cores count is used.
+    \\  -v              Verbose
+    \\
+    \\  --force         Force extraction. If the destination already exists, it will be deleted.
+    \\
+    \\  --help          Display this messages
+    \\  --version       Display the version
    \\
 ;

-const stdout = std.io.getStdOut();
+const errors = error{InvalidArguments};

-var extr_files: std.ArrayList([]const u8) = undefined;
+var archive: []const u8 = "";
+var extLoc: []const u8 = "squashfs-root";
 var offset: u64 = 0;
+var threads: u32 = 0;
 var verbose: bool = false;
-var unbreak: bool = false;
-var deref: bool = false;
-var processors: u16 = 0;
-var list: ListTypes = .None;
+var ignore_xattrs: bool = false;
+var ignore_permissions: bool = false;
+var force: bool = false;

-var filename: []const u8 = "";
-var extr_location: []const u8 = "";
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.gpa;
+    const io = init.io;

-const ListTypes = enum {
-    None,
-    List,
-    ListAttr,
-    ListNumeric,
-};
-
-pub fn main() !void {
-    const alloc = std.heap.smp_allocator;
-    extr_files = .init(alloc);
-    defer extr_files.deinit();
-    var args = std.process.argsWithAllocator(alloc) catch {
-        _ = try stdout.writeAll("Unable to allocate memory");
+    var stdout = File.stdout();
+    var out = stdout.writer(io, &[0]u8{});
+    defer out.interface.flush() catch {};
+    try handleArgs(init.minimal.args, &out.interface);
+    if (archive.len == 0) {
+        try out.interface.print("You must provide a squashfs archive\n", .{});
+        try out.interface.print(help_mgs, .{});
        return;
+    }
+    var fil: File = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
+    defer fil.close(io);
+    var arc: squashfs.Archive = try .initAdvanced(alloc, io, fil, offset, 0); //TODO: Update when memory size matters. //TODO: Handle error gracefully.
+    defer arc.deinit(io);
+    const options: squashfs.ExtractionOptions = .{
+        .verbose = verbose,
+        .verbose_writer = if (verbose) &out.interface else null,
+        .ignore_xattr = ignore_xattrs,
+        .ignore_permissions = ignore_permissions,
    };
-    defer args.deinit();
-    _ = args.next();
-    while (args.next()) |arg| {
-        if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
-            _ = try stdout.writeAll(help_msg);
-            return;
-        } else if (std.mem.eql(u8, arg, "--version")) {
-            try config.version.format("", .{}, stdout.writer());
-            _ = try stdout.write("\n");
-            return;
+    if (force)
+        try Io.Dir.cwd().deleteTree(io, extLoc);
+    try arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
+}
+
+fn handleArgs(args: std.process.Args, out: *Writer) !void {
+    var arg_iter = args.iterate();
+    defer arg_iter.deinit();
+    _ = arg_iter.skip(); // args[0] is the application launch command.
+    while (arg_iter.next()) |arg| {
+        if (std.mem.eql(u8, arg, "-o")) {
+            const nxt = arg_iter.next();
+            if (nxt == null or nxt.?.len == 0) {
+                try out.print("-o must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            }
+            offset = std.fmt.parseInt(u64, nxt.?, 10) catch {
+                try out.print("-o must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            };
+            continue;
+        } else if (std.mem.eql(u8, arg, "-d")) {
+            const nxt = arg_iter.next();
+            if (nxt == null or nxt.?.len == 0) {
+                try out.print("-d must be followed by a location\n", .{});
+                return errors.InvalidArguments;
+            }
+            extLoc = nxt.?;
+            continue;
+        } else if (std.mem.eql(u8, arg, "-p")) {
+            const nxt = arg_iter.next();
+            if (nxt == null or nxt.?.len == 0) {
+                try out.print("-p must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            }
+            threads = std.fmt.parseInt(u32, nxt.?, 10) catch {
+                try out.print("-p must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            };
+            continue;
        } else if (std.mem.eql(u8, arg, "-v")) {
            verbose = true;
-        } else if (std.mem.eql(u8, arg, "--unbreak-symlinks") or std.mem.eql(u8, arg, "-us")) {
-            unbreak = true;
-        } else if (std.mem.eql(u8, arg, "--deref-symlinks") or std.mem.eql(u8, arg, "-ds")) {
-            deref = true;
-        } else if (std.mem.eql(u8, arg, "-l")) {
-            list = .List;
-        } else if (std.mem.eql(u8, arg, "-ll")) {
-            list = .ListAttr;
-        } else if (std.mem.eql(u8, arg, "-lln")) {
-            list = .ListNumeric;
-        } else if (std.mem.eql(u8, arg, "-e")) {
-            const next = args.next();
-            if (next == null) {
-                _ = try stdout.writeAll("path required after -e\n");
-                return;
-            }
-            try extr_files.append(next.?);
-        } else if (std.mem.eql(u8, arg, "-o")) {
-            const next = args.next();
-            if (next == null) {
-                _ = try stdout.writeAll("offset required after -o\n");
-                return;
-            }
-            offset = try std.fmt.parseInt(u64, next.?, 10);
-        } else if (std.mem.eql(u8, arg, "-p")) {
-            const next = args.next();
-            if (next == null) {
-                _ = try stdout.writeAll("number required after -p\n");
-                return;
-            }
-            processors = try std.fmt.parseInt(u16, next.?, 10);
-        } else if (filename.len == 0) {
-            filename = arg;
-        } else if (extr_location.len == 0) {
-            extr_location = arg;
-        } else {
-            _ = try stdout.writeAll("invalid or too many arguments\n");
+            continue;
+        } else if (std.mem.eql(u8, arg, "-dx")) {
+            ignore_xattrs = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "-dp")) {
+            ignore_permissions = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "--force")) {
+            force = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "--version")) {
+            try out.print("zig-unsquashfs v", .{});
+            try config.version.format(out);
+            try out.print("\nBuilt using Zig {s} in {} mode\n", .{ builtin.zig_version_string, builtin.mode });
+            std.process.exit(0);
+            return;
+        } else if (std.mem.eql(u8, arg, "--help")) {
+            try out.print(help_mgs, .{});
+            std.process.exit(0);
            return;
        }
+        if (archive.len > 0) {
+            try out.print("you can only provide one file at a time\n", .{});
+            try out.print(help_mgs, .{});
+            return errors.InvalidArguments;
+        }
+        archive = arg;
    }
-    if (filename.len == 0) {
-        _ = try stdout.writeAll("no archive given\n");
-        return;
-    }
-    if (list == .None and extr_location.len == 0) {
-        _ = try stdout.writeAll("no extract location given\n");
-        return;
-    }
-    const fil = try std.fs.cwd().openFile(filename, .{});
-    defer fil.close();
-    var th_alloc: std.heap.ThreadSafeAllocator = .{ .child_allocator = std.heap.smp_allocator };
-    var rdr = squashfs.SfsFile.init(
-        th_alloc.allocator(),
-        fil,
-        offset,
-    ) catch |err| {
-        try std.fmt.format(stdout.writer(), "Error opening {s} as squashfs: {any}\n", .{ filename, err });
-        return;
-    };
-    defer rdr.deinit();
-    //TODO: list and extr_files;
-    var op: squashfs.ExtractionOptions = squashfs.ExtractionOptions.init() catch |err| {
-        try std.fmt.format(stdout.writer(), "Error setting extraction options: {any}\n", .{err});
-        return;
-    };
-    op.verbose = verbose;
-    op.dereference_symlinks = deref;
-    op.unbreak_symlinks = unbreak;
-    if (processors != 0) op.thread_count = processors;
-    rdr.extract(op, extr_location) catch |err| {
-        try std.fmt.format(stdout.writer(), "Error extracting archive: {any}\n", .{err});
-        return;
-    };
 }
@@ -0,0 +1,7 @@
+#include <zlib.h>
+#include <lzma.h>
+#include <lz4.h>
+#include <zstd.h>
+#ifdef ALLOW_LZO
+#include <lzo/minilzo.h>
+#endif
@@ -0,0 +1,61 @@
+const std = @import("std");
+
+const c = @import("c");
+
+const Error = @import("decomp.zig").Error;
+
+pub fn zlibDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var strem: c.z_stream = .{
+        .next_in = in.ptr,
+        .avail_in = @truncate(in.len),
+        .next_out = out.ptr,
+        .avail_out = @truncate(out.len),
+    };
+    var res = c.inflateInit(&strem);
+    if (res != c.Z_OK) return Error.ReadFailed;
+    defer _ = c.inflateEnd(&strem);
+
+    res = c.inflate(&strem, c.Z_FULL_FLUSH);
+    if (res != c.Z_OK) return Error.ReadFailed;
+
+    return strem.total_out;
+}
+pub fn lzmaDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var strem: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+    };
+    var res = c.lzma_auto_decoder(&strem, out.len * 2, 0);
+    if (res != c.LZMA_OK) return Error.ReadFailed;
+    defer c.lzma_end(&strem);
+
+    while (res == c.LZMA_OK)
+        res = c.lzma_code(&strem, c.LZMA_RUN);
+    if (res != c.LZMA_FINISH) return Error.ReadFailed;
+
+    return strem.total_out;
+}
+pub fn lzoDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var out_len = out.len;
+    const res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &out_len, null);
+    if (res != c.LZO_E_OK) return Error.ReadFailed;
+    return out_len;
+}
+pub fn lz4Decompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const res = c.LZ4_decompress_safe(
+        in.ptr,
+        out.ptr,
+        @bitCast(@as(u32, @truncate(in.len))),
+        @bitCast(@as(u32, @truncate(out.len))),
+    );
+    if (res < 0) return Error.ReadFailed;
+    return @abs(res);
+}
+pub fn zstdDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
+    if (c.ZSTD_isError(res) != 0)
+        return Error.ReadFailed;
+    return res;
+}
@@ -0,0 +1,102 @@
+const std = @import("std");
+const Io = std.Io;
+
+const DecompCache = @import("../decomp_cache.zig");
+const DataBlock = @import("../inode.zig").DataBlock;
+
+const Extractor = @This();
+
+cache: *DecompCache,
+block_size: u32,
+
+start: u64,
+size: u64,
+blocks: []DataBlock,
+
+frag_data: ?[]u8 = null,
+frag_offset: u32 = 0,
+
+pub fn init(cache: *DecompCache, block_size: u32, size: u64, start: u64, blocks: []DataBlock) Extractor {
+    return .{
+        .cache = cache,
+        .block_size = block_size,
+
+        .start = start,
+        .size = size,
+        .blocks = blocks,
+    };
+}
+
+pub fn addFragment(self: *Extractor, data: []u8, offset: u32) void {
+    self.frag_data = data;
+    self.frag_offset = offset;
+}
+
+pub fn asyncExtract(self: Extractor, io: Io, fil: Io.File) Error!void {
+    try fil.writePositionalAll(io, &.{&.{0}}, self.size - 1);
+
+    var map = try fil.createMemoryMap(io, .{ .len = self.size, .protection = .{ .write = true } });
+    defer map.destroy(io);
+
+    var group: Io.Group = .init;
+    defer group.cancel(io);
+
+    var ret_err: ?Error = null;
+
+    var offset = self.start;
+    for (0..self.blocks.len) |i| {
+        group.async(io, blockThread, .{ self, io, map, offset, i, &ret_err });
+
+        offset += self.blocks[i].size;
+    }
+    if (self.frag_data != null)
+        group.async(io, fragThread, .{ self, map });
+
+    group.await(io) catch |err| return ret_err orelse err;
+
+    try map.write(io);
+}
+
+fn blockThread(self: Extractor, io: Io, map: Io.File.MemoryMap, read_offset: u64, idx: usize, ret_err: *?Error) error{Canceled}!void {
+    const write_pos = idx * self.block_size;
+    const size = if (self.frag_data == null and idx == self.block_size.len - 1)
+        self.size % self.block_size
+    else
+        self.block_size;
+    const block = self.blocks[idx];
+
+    if (block.size == 0) {
+        @memset(map.memory[write_pos..][0..size], 0);
+        return;
+    }
+    if (block.uncompressed) {
+        @memcpy(map[write_pos..][0..size], self.cache.map.memory[read_offset..][0..size]);
+        return;
+    }
+    const data = self.cache.get(io, read_offset, block.size, size) catch |err| switch (err) {
+        error.Canceled => {
+            io.recancel();
+            return error.Canceled;
+        },
+        else => |e| {
+            ret_err.* = e;
+            return error.Canceled;
+        },
+    };
+    defer self.cache.finished(io, read_offset);
+    if (data.len != size) {
+        std.debug.print("Size of decompression at {} is {} and should be {}\n", .{ read_offset, data.len, size });
+        return Error.BadDecompressionSize;
+    }
+    @memcpy(map[write_pos..][0..size], data);
+}
+fn fragThread(self: Extractor, map: Io.File.MemoryMap) error{Canceled}!void {
+    const write_pos = self.blocks.len * self.block_size;
+    const size = self.size % self.block_size;
+
+    @memcpy(map.memory[write_pos..][0..size], self.frag_data.?[self.frag_offset..][0..size]);
+}
+
+// Types
+
+pub const Error = error{BadDecompressionSize} || Io.File.WritePositionalError || Io.File.MemoryMap.CreateError;
@@ -0,0 +1,151 @@
+const std = @import("std");
+const Io = std.Io;
+
+const DecompCache = @import("../decomp_cache.zig");
+const DataBlock = @import("../inode.zig").DataBlock;
+
+const Reader = @This();
+
+io: Io,
+
+cache: *DecompCache,
+block_size: u32,
+
+size: u64,
+blocks: []DataBlock,
+
+frag_data: ?[]u8 = null,
+frag_offset: u32 = 0,
+
+cur_offset: u64 = 0,
+next_offset: u64,
+
+idx: u32 = 0,
+cur_block_sparse: bool = false,
+
+interface: Io.Reader = .{
+    .buffer = &[0]u8{},
+    .end = 0,
+    .seek = 0,
+    .vtable = &.{
+        .stream = stream,
+        .discard = discard,
+        .readVec = readVec,
+    },
+},
+
+pub fn init(io: Io, cache: *DecompCache, block_size: u32, size: u64, start: u64, blocks: []DataBlock) Reader {
+    return .{
+        .io = io,
+
+        .cache = cache,
+        .block_size = block_size,
+
+        .size = size,
+        .blocks = blocks,
+
+        .next_offset = start,
+    };
+}
+pub fn deinit(self: Reader) void {
+    self.cache.finished(self.io);
+}
+
+pub fn addFragment(self: *Reader, data: []u8, offset: u32) void {
+    self.frag_data = data;
+    self.frag_offset = offset;
+}
+
+fn advance(self: *Reader) Io.Reader.Error!void {
+    errdefer self.interface.end = 0;
+    self.interface.seek = 0;
+
+    if (self.idx > self.blocks.len) return error.EndOfStream;
+    defer self.idx += 1;
+    self.cache.finished(self.io, self.cur_offset);
+
+    if (self.idx == self.blocks.len) {
+        if (self.frag_data == null) return error.EndOfStream;
+        self.cur_offset = 0;
+
+        const size = self.size % self.block_size;
+        self.interface.buffer = self.frag_data.?[self.frag_offset..][0..size];
+        self.interface.end = size;
+        return;
+    }
+
+    const block = self.blocks[self.idx];
+
+    const size = if (self.idx == self.blocks.len - 1 and self.frag_data == null)
+        self.size % self.block_size
+    else
+        self.block_size;
+
+    if (block.size == 0) {
+        self.interface.buffer = &[0]u8{};
+        self.cur_block_sparse = true;
+        self.interface.end = size;
+        return;
+    } else {
+        self.cur_block_sparse = false;
+    }
+
+    self.cur_offset = self.next_offset;
+    self.next_offset = self.cur_offset + block.size;
+
+    if (block.uncompressed) {
+        self.interface.buffer = self.cache.map.memory[self.cur_offset..][0..size];
+        self.interface.end = size;
+        return;
+    }
+    const data = self.cache.get(self.io, self.cur_offset, block.size, size);
+    if (data.len != size) {
+        std.debug.print("Size of decompression at {} is {} and should be {}\n", .{ self.cur_offset, data.len, size });
+        return Io.Reader.Error.ReadFailed;
+    }
+    self.interface.buffer = data;
+    self.interface.end = size;
+}
+
+fn stream(r: *Io.Reader, w: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!usize {
+    const self: *Reader = @fieldParentPtr("interface", r);
+    if (r.seek >= r.end) {
+        try self.advance();
+    }
+    const to_write = @min(@intFromEnum(limit), r.end - r.seek);
+    const wrote = try if (self.cur_block_sparse)
+        w.splatByte(0, to_write)
+    else
+        w.write(r.buffer[r.seek..][0..to_write]);
+    r.seek += wrote;
+    return wrote;
+}
+fn discard(r: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
+    if (r.seek >= r.end) {
+        const self: *Reader = @fieldParentPtr("interface", r);
+        try self.advance();
+    }
+    const to_discard = @min(@intFromEnum(limit), r.end - r.seek);
+    r.seek += to_discard;
+    return to_discard;
+}
+fn readVec(r: *Io.Reader, vec: [][]u8) Io.Reader.Error!usize {
+    const self: *Reader = @fieldParentPtr("interface", r);
+    if (r.seek >= r.end) {
+        try self.advance();
+    }
+    var total: usize = 0;
+    for (vec) |v| {
+        const to_copy = @min(v.len, r.end - r.seek);
+        if (self.cur_block_sparse) {
+            @memset(v[0..to_copy], 0);
+        } else {
+            @memcpy(v[0..to_copy], r.buffer[r.seek..][0..to_copy]);
+        }
+        total += to_copy;
+        r.seek += to_copy;
+
+        if (r.seek >= r.end) break;
+    }
+    return total;
+}
@@ -0,0 +1,41 @@
+const std = @import("std");
+
+const options = @import("options");
+
+const c_decomp = @import("c_decomp.zig");
+const zig_decomp = @import("zig_decomp.zig");
+
+pub const Error = error{} || std.Io.Reader.UnlimitedAllocError;
+
+pub const Enum = enum(u16) {
+    zlib = 1,
+    lzma,
+    lzo,
+    xz,
+    lz4,
+    zstd,
+};
+
+pub const Fn = *const fn (std.mem.Allocator, in: []u8, out: []u8) Error!usize;
+
+pub fn DecompFn(comp: Enum) !Fn {
+    return if (options.use_zig_decomp)
+        switch (comp) {
+            .zlib => zig_decomp.zlibDecompress,
+            .lzma => zig_decomp.lzmaDecompress,
+            .xz => zig_decomp.xzDecompress,
+            .zstd => zig_decomp.zstdDecompress,
+            .lz4 => error.Lz4Unsupported,
+            .lzo => error.LzoUnsupported,
+        }
+    else switch (comp) {
+        .zlib => c_decomp.zlibDecompress,
+        .lzma, .xz => c_decomp.lzmaDecompress,
+        .zstd => c_decomp.zstdDecompress,
+        .lz4 => c_decomp.lz4Decompress,
+        .lzo => if (options.allow_lzo)
+            c_decomp.zstdDecompress
+        else
+            error.LzoUnsupported,
+    };
+}
@@ -0,0 +1,116 @@
+const std = @import("std");
+const Io = std.Io;
+const File = Io.File;
+const MemoryMap = File.MemoryMap;
+const Atomic = std.atomic.Value;
+
+const Decomp = @import("decomp.zig");
+
+const DecompCache = @This();
+
+alloc: std.mem.Allocator,
+map: MemoryMap,
+decomp_fn: Decomp.Fn,
+
+cache: std.AutoHashMap(u64, Cache),
+mut: std.Io.RwLock = .init,
+cond: std.Io.Condition = .init,
+
+max_mem: u64,
+cur_mem: u64 = 0,
+
+pub fn init(alloc: std.mem.Allocator, map: MemoryMap, compression: Decomp.Enum, max_mem: u64) !DecompCache {
+    return .{
+        .alloc = alloc,
+        .map = map,
+        .decomp_fn = try Decomp.DecompFn(compression),
+
+        .cache = .init(alloc),
+
+        .max_mem = max_mem,
+    };
+}
+pub fn deinit(self: *DecompCache, io: Io) void {
+    self.mut.lockUncancelable(io);
+
+    var iter = self.cache.valueIterator();
+    while (iter.next()) |v|
+        self.alloc.free(v.data);
+    self.cache.deinit();
+}
+
+pub fn get(self: *DecompCache, io: Io, offset: u64, compressed_size: u32, max_size: u32) ![]u8 {
+    {
+        try self.mut.lockShared(io);
+        defer self.mut.unlockShared(io);
+
+        const cache = self.cache.getPtr(offset);
+        if (cache != null) {
+            _ = cache.?.usage.fetchAdd(1, .acquire);
+            return cache.?.data;
+        }
+    }
+    try self.mut.lock(io);
+    defer self.mut.unlock(io);
+
+    const cache = try self.cache.getOrPut(offset);
+    if (cache.found_existing) {
+        _ = cache.value_ptr.usage.fetchAdd(1, .acquire);
+        return cache.value_ptr.data;
+    }
+    errdefer self.cache.removeByPtr(cache.key_ptr);
+
+    try self.ensureSpace(io, max_size);
+
+    var out = try self.alloc.alloc(u8, max_size);
+    errdefer self.alloc.free(out);
+
+    const decomp_size = try self.decomp_fn(self.alloc, self.map.memory[offset..][0..compressed_size], out);
+    if (decomp_size != max_size) {
+        if (!self.alloc.resize(out, decomp_size)) {
+            const new_out = try self.alloc.alloc(u8, decomp_size);
+            @memcpy(new_out, out[0..decomp_size]);
+            out = new_out;
+        } else {
+            out.len = decomp_size;
+        }
+    }
+    self.cur_mem += decomp_size;
+
+    cache.value_ptr.data = out;
+    _ = cache.value_ptr.usage.fetchAdd(1, .acquire);
+    return out;
+}
+pub fn finished(self: *DecompCache, io: Io, offset: u64) void {
+    const cache = self.cache.getPtr(offset);
+    if (cache == null) {
+        std.debug.print("Finished using cache, but cache does not exist: {}\n", .{offset});
+        return;
+    }
+    const use = cache.?.usage.fetchSub(1, .acquire);
+    if (use == 0)
+        self.cond.broadcast(io);
+}
+
+fn ensureSpace(self: *DecompCache, io: Io, size: u64) !void {
+    while (self.cur_mem + size > self.max_mem) {
+        var iter = self.cache.valueIterator();
+        while (iter.next()) |cache| {
+            if (cache.usage.load(.unordered) == 0) {
+                self.alloc.free(cache.data);
+                self.cur_mem -= cache.data.len;
+
+                if (self.cur_mem + size <= self.max_mem) return;
+            }
+        }
+        if (self.cur_mem + size <= self.max_mem) return;
+        try self.cond.wait(io, &self.mut.mutex);
+    }
+}
+
+// Types
+
+const Cache = struct {
+    data: []u8,
+    usage: Atomic(u32),
+};
@@ -1,42 +1,68 @@
 const std = @import("std");
+const Io = std.Io;
+const Reader = Io.Reader;

-const InodeType = @import("inode.zig").Type;
-const Compression = @import("superblock.zig").Compression;
+const Inode = @import("inode.zig");

-const Header = extern struct { //use extern instead of packed, due to bit alignment
-    count: u32,
-    block: u32,
-    num: u32,
-};
+const Directory = @This();

-const RawEntry = struct {
-    offset: u16,
-    num_offset: i16,
-    type: InodeType,
-    size: u16,
-    name: []const u8,
+entries: []Entry,

-    pub fn init(alloc: std.mem.Allocator, rdr: anytype) !RawEntry {
-        var fixed: [8]u8 = undefined;
-        _ = try rdr.read(&fixed);
-        const size = std.mem.readInt(u16, fixed[6..8], .little);
-        const name = try alloc.alloc(u8, size + 1);
-        _ = try rdr.read(name);
-        return .{
-            .offset = std.mem.readInt(u16, fixed[0..2], .little),
-            .num_offset = std.mem.readInt(i16, fixed[2..4], .little),
-            .type = @enumFromInt(std.mem.readInt(u16, fixed[4..6], .little)),
-            .size = size,
-            .name = name,
-        };
+pub fn init(alloc: std.mem.Allocator, rdr: *Reader, size: u32) Error!Directory {
+    if (size <= 3) return .{ .entries = &[0]Entry{} };
+
+    var entries: std.ArrayList(Entry) = try .initCapacity(alloc, 50);
+    errdefer {
+        for (entries.items) |ent|
+            ent.deinit(alloc);
+        entries.deinit(alloc);
    }
-};
+
+    var read: u32 = 3;
+    while (read < size) {
+        var hdr: Header = undefined;
+        try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
+        read += @sizeOf(Header);
+
+        try entries.ensureUnusedCapacity(alloc, hdr.count + 1);
+        for (0..hdr.count + 1) |_| {
+            var raw: RawEntry = undefined;
+            try rdr.readSliceEndian(RawEntry, @ptrCast(&raw), .little);
+
+            const name = try alloc.alloc(u8, raw.name_size + 1);
+            errdefer alloc.free(name);
+            try rdr.readSliceEndian(u8, name, .little);
+
+            entries.appendAssumeCapacity(.{
+                .inode_num = if (raw.inode_num_offset > 0)
+                    hdr.inode_num + @abs(raw.inode_num_offset)
+                else
+                    hdr.inode_num - @abs(raw.inode_num_offset),
+                .block_start = hdr.block_start,
+                .block_offset = raw.block_offset,
+                .type = raw.type,
+                .name = name,
+            });
+        }
+    }
+
+    return .{ .entries = try entries.toOwnedSlice(alloc) };
+}
+pub fn deinit(self: Directory, alloc: std.mem.Allocator) void {
+    for (self.entries) |entry|
+        entry.deinit(alloc);
+    alloc.free(self.entries);
+}
+
+// Types
+
+pub const Error = Reader.Error || std.mem.Allocator.Error;

 pub const Entry = struct {
-    block: u32,
-    offset: u16,
-    num: u32,
-    type: InodeType,
+    inode_num: u32,
+    block_start: u32,
+    block_offset: u16,
+    type: Inode.Enum,
    name: []const u8,

    pub fn deinit(self: Entry, alloc: std.mem.Allocator) void {
@@ -44,27 +70,14 @@ pub const Entry = struct {
    }
 };

-pub fn readDirectory(alloc: std.mem.Allocator, rdr: anytype, size: u32) ![]Entry {
-    var entries: std.ArrayList(Entry) = .init(alloc);
-    errdefer entries.deinit();
-    var cur_red: u32 = 3; // dir size includes "." & "..", so its actual size is off by 3.
-    var hdr: Header = undefined;
-    while (cur_red < size) {
-        _ = try rdr.read(std.mem.asBytes(&hdr));
-        cur_red += 12;
-        try entries.ensureUnusedCapacity(hdr.count + 1);
-        for (0..hdr.count + 1) |_| {
-            const raw_ent: RawEntry = try .init(alloc, rdr);
-            cur_red += 9 + raw_ent.size;
-            errdefer alloc.free(raw_ent.name);
-            entries.appendAssumeCapacity(.{
-                .block = hdr.block,
-                .offset = raw_ent.offset,
-                .num = @truncate(@abs(@as(i64, hdr.num) + raw_ent.num_offset)),
-                .type = raw_ent.type,
-                .name = raw_ent.name,
-            });
-        }
-    }
-    return entries.toOwnedSlice();
-}
+const Header = extern struct {
+    count: u32,
+    block_start: u32,
+    inode_num: u32,
+};
+const RawEntry = extern struct {
+    block_offset: u16,
+    inode_num_offset: i16,
+    type: Inode.Enum,
+    name_size: u16,
+};
@@ -0,0 +1,283 @@
+const std = @import("std");
+const Io = std.Io;
+
+const Atomic = std.atomic.Value;
+
+const DecompCache = @import("decomp_cache.zig");
+const ExtractionOptions = @import("options.zig");
+const Inode = @import("inode.zig");
+const Superblock = @import("archive.zig").Superblock;
+const Directory = @import("directory.zig");
+const DataExtractor = @import("data/extractor.zig");
+const DataReader = @import("data/reader.zig");
+const Lookup = @import("lookup.zig");
+
+pub fn extract(alloc: std.mem.Allocator, io: Io, inode: Inode, cache: *DecompCache, super: Superblock, ext_loc: []const u8, options: ExtractionOptions) !void {
+    const path = std.mem.trim(u8, ext_loc, "/");
+
+    var buf: [50]ReturnUnion = undefined;
+    var sel: Io.Select(ReturnUnion) = .init(io, &buf);
+
+    defer {
+        while (sel.cancel()) |ret| {
+            switch (ret) {
+                .dir_ret => |d| {
+                    const res = d catch continue;
+                    alloc.free(res.path);
+                },
+                .file_ret => |f| {
+                    const res = f catch continue;
+                    alloc.free(res.path);
+                },
+                else => {},
+            }
+        }
+    }
+
+    var frag_table: Lookup.Table(Lookup.FragmentEntry) = .init(alloc, cache, super.frag_start, super.frag_count);
+    defer frag_table.deinit();
+
+    var ret_loop = io.async(returnLoop, .{ alloc, &sel, options });
+
+    try extractReal(alloc, io, cache, super, &sel, &frag_table, path, inode, null, false);
+
+    ret_loop.await(io) catch |err| {
+        // TODO: Drain sel
+        return err;
+    };
+}
+
+fn extractReal(
+    alloc: std.mem.Allocator,
+    io: Io,
+    cache: *DecompCache,
+    super: Superblock,
+    sel: *Io.Select(ReturnUnion),
+    frag_table: *Lookup.Table(Lookup.FragmentEntry),
+    path: []const u8,
+    inode: Inode,
+    parent: ?*Atomic(usize),
+    origin: bool,
+) Error!void {
+    try io.checkCancel();
+
+    switch (inode.data) {
+        .dir, .ext_dir => sel.async(
+            .dir_ret,
+            extractDir,
+            .{ alloc, io, cache, super, sel, frag_table, path, inode, parent, origin },
+        ),
+        .file, .ext_file => sel.async(
+            .file_ret,
+            extractFile,
+            .{ alloc, io, cache, super.block_size, frag_table, path, inode, parent, origin },
+        ),
+        else => return error.Canceled,
+    }
+}
+
+fn extractDir(
+    alloc: std.mem.Allocator,
+    io: Io,
+    cache: *DecompCache,
+    super: Superblock,
+    sel: *Io.Select(ReturnUnion),
+    frag_table: *Lookup.Table(Lookup.FragmentEntry),
+    path: []const u8,
+    inode: Inode,
+    parent: ?*Atomic(usize),
+    origin: bool,
+) Error!DirReturn {
+    defer {
+        if (parent != null)
+            _ = parent.?.fetchSub(1, .acquire);
+        if (!origin) inode.deinit(alloc);
+    }
+    errdefer if (!origin) alloc.free(path);
+
+    const dir = inode.directory(alloc, io, cache, super.dir_start) catch |err| switch (err) {
+        error.NotDirectory => unreachable,
+        else => |e| return e,
+    };
+    defer dir.deinit(alloc);
+
+    const sub_files = try alloc.create(Atomic(usize));
+    sub_files.* = .init(dir.entries.len);
+
+    const ret: DirReturn = .{
+        .path = path,
+        .sub_files = sub_files,
+        .origin = origin,
+
+        .uid_idx = inode.hdr.uid_idx,
+        .gid_idx = inode.hdr.gid_idx,
+        .mod_time = inode.hdr.mod_time,
+        .permissions = inode.hdr.permission,
+
+        .xattr_idx = switch (inode.data) {
+            .ext_dir => |d| if (d.xattr_idx != 0xFFFFFFFF) d.xattr_idx else null,
+            else => null,
+        },
+    };
+
+    for (dir.entries) |entry| {
+        const new_inode: Inode = try .initDirEntry(alloc, io, cache, super.inode_start, super.block_size, entry);
+        errdefer new_inode.deinit(alloc);
+
+        const new_path = try std.mem.concat(alloc, u8, &.{ path, "/", entry.name });
+
+        try extractReal(
+            alloc,
+            io,
+            cache,
+            super,
+            sel,
+            frag_table,
+            new_path,
+            new_inode,
+            sub_files,
+            false,
+        );
+    }
+    return ret;
+}
+fn extractFile(
+    alloc: std.mem.Allocator,
+    io: Io,
+    cache: *DecompCache,
+    block_size: u32,
+    frag_table: *Lookup.Table(Lookup.FragmentEntry),
+    path: []const u8,
+    inode: Inode,
+    parent: ?*Atomic(usize),
+    origin: bool,
+) Error!FileReturn {
+    defer {
+        if (parent != null)
+            _ = parent.?.fetchSub(1, .acquire);
+        if (!origin) inode.deinit(alloc);
+    }
+    errdefer if (!origin) alloc.free(path);
+
+    var atomic = try Io.Dir.cwd().createFileAtomic(io, path, .{});
+    defer atomic.deinit(io);
+
+    var ret: FileReturn = .{
+        .path = path,
+        .origin = origin,
+
+        .uid_idx = inode.hdr.uid_idx,
+        .gid_idx = inode.hdr.gid_idx,
+        .permissions = inode.hdr.permission,
+        .mod_time = inode.hdr.mod_time,
+    };
+
+    const data: DataExtractor = switch (inode.data) {
+        .file => |f| blk: {
+            var data: DataExtractor = .init(cache, block_size, f.size, f.data_start, f.blocks);
+            if (f.frag_idx != 0xFFFFFFFF) {
+                const entry: Lookup.FragmentEntry = try frag_table.get(io, f.frag_idx);
+                if (entry.size.uncompressed) {
+                    data.addFragment(cache.map.memory[entry.start..][0..entry.size.size], f.frag_offset);
+                } else {
+                    const block = try cache.get(io, entry.start, entry.size.size, block_size);
+                    data.addFragment(block, f.frag_offset);
+                }
+            }
+            break :blk data;
+        },
+        .ext_file => |f| blk: {
+            var data: DataExtractor = .init(cache, block_size, f.size, f.data_start, f.blocks);
+            if (f.frag_idx != 0xFFFFFFFF) {
+                const entry: Lookup.FragmentEntry = try frag_table.get(io, f.frag_idx);
+                if (entry.size.uncompressed) {
+                    data.addFragment(cache.map.memory[entry.start..][0..entry.size.size], f.frag_offset);
+                } else {
+                    const block = try cache.get(io, entry.start, entry.size.size, block_size);
+                    data.addFragment(block, f.frag_offset);
+                }
+            }
+            if (f.xattr_idx != 0xFFFFFFFF)
+                ret.xattr_idx = f.xattr_idx;
+            break :blk data;
+        },
+        else => unreachable,
+    };
+    try data.asyncExtract(io, atomic.file);
+
+    try atomic.link(io);
+
+    return ret;
+}
+
+// Loop
+
+fn returnLoop(alloc: std.mem.Allocator, sel: *Io.Select(ReturnUnion), options: ExtractionOptions) !void {
+    while (true) {
+        const finished = try sel.await();
+
+        switch (finished) {
+            .dir_ret => |d| {
+                const ret = try d;
+                if (ret.sub_files.load(.unordered) != 0) {
+                    sel.queue.putOne(sel.io, .{ .dir_ret = ret }) catch |err| {
+                        if (!ret.origin) alloc.free(ret.path);
+                        return err;
+                    };
+                    continue;
+                }
+                if (!ret.origin) alloc.free(ret.path);
+                alloc.destroy(ret.sub_files);
+
+                if (!options.ignore_permissions and !options.ignore_xattr) {
+                    // TODO: set permissions & xattr.
+                }
+            },
+            .file_ret => |f| {
+                const ret = try f;
+                if (!ret.origin) alloc.free(ret.path);
+
+                if (!options.ignore_permissions and !options.ignore_xattr) {
+                    // TODO: set permissions & xattr.
+                }
+            },
+            .void_ret => |v| try v,
+        }
+
+        if (sel.group.token.load(.unordered) == null) break;
+    }
+}
+
+// Utility types
+
+const ReturnUnion = union(enum) {
+    file_ret: Error!FileReturn,
+    dir_ret: Error!DirReturn,
+    void_ret: Error!void,
+};
+
+const Error = error{Canceled} || Directory.Error || Io.Dir.CreateFileAtomicError || Io.File.Atomic.LinkError || DataExtractor.Error;
+
+const FileReturn = struct {
+    path: []const u8,
+    origin: bool,
+
+    uid_idx: u32,
+    gid_idx: u32,
+    mod_time: u32,
+    permissions: u16,
+
+    xattr_idx: ?u32 = null,
+};
+const DirReturn = struct {
+    path: []const u8,
+    sub_files: *Atomic(usize),
+    origin: bool,
+
+    uid_idx: u32,
+    gid_idx: u32,
+    mod_time: u32,
+    permissions: u16,
+
+    xattr_idx: ?u32 = null,
+};
@@ -1,23 +0,0 @@
-const std = @import("std");
-
-const Self = @This();
-
-/// Replace symlinks with their targets
-dereference_symlinks: bool = false,
-/// Always extract a symlink's target if it's part of the archive.
-/// May result in the symlink's target being changed.
-unbreak_symlinks: bool = false,
-/// Do not set file's permissions & owner when extracted.
-ignore_permissions: bool = false,
-/// Verbose logging
-verbose: bool = false,
-/// Verbose logging writer. If not set, stdout is used.
-verbose_logger: std.io.AnyWriter = std.io.getStdOut().writer().any(),
-/// Number of threads used during extraction. Defualts to std.Thread.getCpuCount().
-thread_count: usize,
-
-pub fn init() !Self {
-    return .{
-        .thread_count = try std.Thread.getCpuCount(),
-    };
-}
@@ -1,355 +1,102 @@
 const std = @import("std");
-const builtin = @import("builtin");
+const Io = std.Io;

-const dir = @import("directory.zig");
-
-const DirEntry = dir.Entry;
+const Archive = @import("archive.zig");
+const Directory = @import("directory.zig");
+const ExtractionOptions = @import("options.zig");
 const Inode = @import("inode.zig");
-const SfsReader = @import("reader.zig").SfsReader;
-const ToReader = @import("reader/to_read.zig").ToRead;
-const ExtractionOptions = @import("extract_options.zig");
-const DataReader = @import("reader/data.zig").DataReader;
-const Compression = @import("superblock.zig").Compression;
-const MetadataReader = @import("reader/metadata.zig").MetadataReader;

-pub fn File(comptime T: type) type {
-    return struct {
-        pub const FileError = error{
-            NotRegular,
-            NotDirectory,
-            NotFound,
-        };
+const SfsFile = @This();

-        const Self = @This();
+alloc: std.mem.Allocator,
+archive: *Archive,

-        rdr: *SfsReader(T),
-        // parent: *File(T),
+inode: Inode,
+name: []const u8,

-        inode: Inode,
-        name: []const u8,
+/// The given allocator must have been used to create the Inode and name.
+pub fn init(alloc: std.mem.Allocator, archive: *Archive, inode: Inode, name: []const u8) SfsFile {
+    return .{
+        .alloc = alloc,
+        .archive = archive,

-        /// Directory entries. Only populated on directories.
-        entries: ?[]DirEntry = null,
-        /// File reader. Only populated on regular files.
-        data_reader: ?DataReader(T) = null,
-
-        pub fn init(rdr: *SfsReader(T), inode: Inode, name: []const u8) !Self {
-            const name_cpy: []u8 = try rdr.alloc.alloc(u8, name.len);
-            @memcpy(name_cpy, name);
-            var out = Self{
-                .rdr = rdr,
-                .inode = inode,
-                .name = name_cpy,
-            };
-            switch (inode.data) {
-                .dir => |d| {
-                    var meta = MetadataReader(T).init(
-                        rdr.alloc,
-                        rdr.super.comp,
-                        rdr.rdr,
-                        d.block + rdr.super.dir_start,
-                    );
-                    try meta.skip(d.offset);
-                    out.entries = try dir.readDirectory(rdr.alloc, &meta, d.size);
-                },
-                .ext_dir => |d| {
-                    var meta = MetadataReader(T).init(
-                        rdr.alloc,
-                        rdr.super.comp,
-                        rdr.rdr,
-                        d.block + rdr.super.dir_start,
-                    );
-                    try meta.skip(d.offset);
-                    out.entries = try dir.readDirectory(rdr.alloc, &meta, d.size);
-                },
-                .file => |f| {
-                    out.data_reader = try .init(rdr, inode);
-                    _ = f;
-                    //TODO: fragments
-                    // if (f.hasFragment()) {
-                    //     try out.data_reader.?.addFragment(
-                    //         try rdr.frag_table.get(f.frag_idx),
-                    //         f.frag_offset,
-                    //     );
-                    // }
-                },
-                .ext_file => |f| {
-                    out.data_reader = try .init(rdr, inode);
-                    _ = f;
-                    //TODO: Fragments
-                    // if (f.hasFragment()) {
-                    //     try out.data_reader.?.addFragment(
-                    //         try rdr.frag_table.get(f.frag_idx),
-                    //         f.frag_offset,
-                    //     );
-                    // }
-                },
-                else => {},
-            }
-            return out;
-        }
-        pub fn initFromRef(rdr: *SfsReader(T), ref: Inode.Ref, name: []const u8) !Self {
-            var meta: MetadataReader(T) = .init(rdr.alloc, rdr.super.comp, rdr.rdr, ref.block + rdr.super.inode_start);
-            try meta.skip(ref.offset);
-            const inode: Inode = try .init(&meta, rdr.alloc, rdr.super.block_size);
-            return .init(rdr, inode, name);
-        }
-        pub fn initFromEntry(rdr: *SfsReader(T), ent: DirEntry) !Self {
-            var meta: MetadataReader(T) = .init(rdr.alloc, rdr.super.comp, rdr.rdr, ent.block + rdr.super.inode_start);
-            try meta.skip(ent.offset);
-            const inode: Inode = try .init(&meta, rdr.alloc, rdr.super.block_size);
-            return .init(rdr, inode, ent.name);
-        }
-        pub fn deinit(self: *Self) void {
-            self.rdr.alloc.free(self.name);
-            self.inode.deinit(self.rdr.alloc);
-            if (self.entries != null) {
-                for (self.entries.?) |e| {
-                    e.deinit(self.rdr.alloc);
-                }
-                self.rdr.alloc.free(self.entries.?);
-            }
-            if (self.data_reader != null) {
-                self.data_reader.?.deinit();
-            }
-        }
-
-        pub fn uid(self: Self) !u32 {
-            return self.rdr.id_table.get(self.inode.hdr.uid_idx);
-        }
-        pub fn gid(self: Self) !u32 {
-            return self.rdr.id_table.get(self.inode.hdr.uid_idx);
-        }
-
-        const Reader = std.io.GenericReader(*DataReader(T), anyerror, DataReader(T).read);
-
-        pub fn read(self: *Self, buf: []u8) !usize {
-            if (self.data_reader == null) return FileError.NotRegular;
-            return self.data_reader.?.read(buf);
-        }
-        pub fn reader(self: *Self) !Reader {
-            if (self.data_reader == null) return FileError.NotRegular;
-            return self.data_reader.?.reader();
-        }
-
-        pub fn open(self: Self, path: []const u8) !Self {
-            if (self.entries == null) return FileError.NotDirectory;
-            if (path.len == 0) return self;
-            const idx = std.mem.indexOf(u8, path, "/") orelse path.len;
-            if (idx == 0) return self.open(path[1..]);
-            const name = path[0..idx];
-            for (self.entries.?) |e| {
-                if (std.mem.eql(u8, e.name, name)) {
-                    var fil: Self = try .initFromEntry(self.rdr, e);
-                    if (idx >= path.len - 1) return fil;
-                    defer fil.deinit();
-                    return fil.open(path[idx + 1 ..]);
-                }
-            }
-            return FileError.NotFound;
-        }
-        pub fn iterate(self: Self) Iterator {
-            return .{
-                .rdr = self.rdr,
-                .entries = self.entries.?,
-            };
-        }
-
-        const Iterator = struct {
-            rdr: *SfsReader(T),
-            entries: []DirEntry,
-
-            idx: u32 = 0,
-
-            pub fn next(self: *Iterator) !?File(T) {
-                if (self.idx >= self.entries.len) return null;
-                const out = try Self.initFromEntry(self.rdr, self.entries[self.idx]);
-                self.idx += 1;
-                return out;
-            }
-            pub fn reset(self: *Iterator) void {
-                self.idx = 0;
-            }
-        };
-
-        const WaitGroup = std.Thread.WaitGroup;
-        const Pool = std.Thread.Pool;
-        const Mutex = std.Thread.Mutex;
-
-        pub const ExtractError = error{FileExists};
-
-        pub fn extract(self: *Self, op: ExtractionOptions, path: []const u8) !void {
-            var wg: WaitGroup = .{};
-            var pol: Pool = undefined;
-            try pol.init(.{
-                .n_jobs = op.thread_count,
-                .allocator = self.rdr.alloc,
-            });
-            defer pol.deinit();
-            var errs: std.ArrayList(anyerror) = .init(self.rdr.alloc);
-            defer errs.deinit();
-            try self.extractInode(op, &wg, &errs, &pol, self.inode, path);
-            wg.wait();
-            if (errs.items.len > 0) return errs.items[0];
-        }
-        fn extractInode(
-            self: *Self,
-            op: ExtractionOptions,
-            wg: *WaitGroup,
-            errs: *std.ArrayList(anyerror),
-            pol: *Pool,
-            inode: Inode,
-            path: []const u8,
-        ) !void {
-            wg.start();
-            defer wg.finish(); //TODO: When everthing is threaded, this will need to be handled by the threads, not here.
-            switch (inode.hdr.type) {
-                .file, .ext_file => {
-                    var fil = try std.fs.cwd().createFile(path, .{});
-                    defer fil.close();
-                    var data: DataReader(T) = try .init(self.rdr, inode);
-                    defer data.deinit();
-                    try data.writeTo(fil); // TODO: Thread
-                    const fil_uid = self.rdr.id_table.get(inode.hdr.uid_idx) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error getting uid {} from table: {}\n", .{ inode.hdr.uid_idx, err }) catch {};
-                        }
-                        return;
-                    };
-                    const fil_gid = self.rdr.id_table.get(inode.hdr.gid_idx) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error getting gid {} from table: {}\n", .{ inode.hdr.gid_idx, err }) catch {};
-                        }
-                        return;
-                    };
-                    fil.chmod(inode.hdr.perm) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error chmod {s}: {}\n", .{ path, err }) catch {};
-                        }
-                        return;
-                    };
-                    fil.chown(fil_uid, fil_gid) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error chmod {s}: {}\n", .{ path, err }) catch {};
-                        }
-                        return;
-                    };
-                    //TODO: update mtime.
-                },
-                .dir, .ext_dir => {
-                    std.fs.cwd().makeDir(path) catch |err| {
-                        if (err != std.fs.Dir.MakeError.PathAlreadyExists) {
-                            return err;
-                        }
-                    };
-                    var dir_block: u32 = 0;
-                    var dir_offset: u16 = 0;
-                    var dir_size: u32 = 0;
-                    switch (inode.data) {
-                        .dir => |d| {
-                            dir_block = d.block;
-                            dir_offset = d.offset;
-                            dir_size = d.size;
-                        },
-                        .ext_dir => |d| {
-                            dir_block = d.block;
-                            dir_offset = d.offset;
-                            dir_size = d.size;
-                        },
-                        else => unreachable,
-                    }
-                    var meta: MetadataReader(T) = .init(self.rdr.alloc, self.rdr.super.comp, self.rdr.rdr, dir_block + self.rdr.super.dir_start);
-                    try meta.skip(dir_offset);
-                    const entries = try dir.readDirectory(self.rdr.alloc, &meta, dir_size);
-                    defer self.rdr.alloc.free(entries);
-                    for (entries) |ent| {
-                        defer ent.deinit(self.rdr.alloc);
-                        var new_path: []u8 = undefined;
-                        if (path[path.len - 1] == '/') {
-                            new_path = self.rdr.alloc.alloc(u8, path.len + ent.name.len) catch |err| {
-                                if (op.verbose) {
-                                    std.fmt.format(op.verbose_logger, "error allocating memory: {}\n", .{err}) catch {};
-                                }
-                                errs.append(err) catch {};
-                                continue;
-                            };
-                            @memcpy(new_path[0..path.len], path);
-                            @memcpy(new_path[path.len..], ent.name);
-                        } else {
-                            new_path = self.rdr.alloc.alloc(u8, path.len + ent.name.len + 1) catch |err| {
-                                if (op.verbose) {
-                                    std.fmt.format(op.verbose_logger, "error allocating memory: {}\n", .{err}) catch {};
-                                }
-                                errs.append(err) catch {};
-                                continue;
-                            };
-                            @memcpy(new_path[0..path.len], path);
-                            new_path[path.len] = '/';
-                            @memcpy(new_path[path.len + 1 ..], ent.name);
-                        }
-                        defer self.rdr.alloc.free(new_path);
-
-                        meta = .init(self.rdr.alloc, self.rdr.super.comp, self.rdr.rdr, ent.block + self.rdr.super.inode_start);
-                        meta.skip(ent.offset) catch |err| {
-                            if (op.verbose) {
-                                std.fmt.format(op.verbose_logger, "error reading inode: {}\n", .{err}) catch {};
-                            }
-                            errs.append(err) catch {};
-                            continue;
-                        };
-                        const new_inode = Inode.init(&meta, self.rdr.alloc, self.rdr.super.block_size) catch |err| {
-                            if (op.verbose) {
-                                std.fmt.format(op.verbose_logger, "error reading inode: {}\n", .{err}) catch {};
-                            }
-                            errs.append(err) catch {};
-                            continue;
-                        };
-                        defer new_inode.deinit(self.rdr.alloc);
-                        self.extractInode(op, wg, errs, pol, new_inode, new_path) catch |err| {
-                            if (op.verbose) {
-                                std.fmt.format(op.verbose_logger, "error extracting {s}: {}\n", .{ new_path, err }) catch {};
-                            }
-                            errs.append(err) catch {};
-                            continue;
-                        };
-                    }
-
-                    var fil = std.fs.cwd().openDir(path, .{ .iterate = true }) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error openning {s} to set permissions: {}\n", .{ path, err }) catch {};
-                        }
-                        return;
-                    };
-                    const fil_uid = self.rdr.id_table.get(inode.hdr.uid_idx) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error getting uid {} from table: {}\n", .{ inode.hdr.uid_idx, err }) catch {};
-                        }
-                        return;
-                    };
-                    const fil_gid = self.rdr.id_table.get(inode.hdr.gid_idx) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error getting gid {} from table: {}\n", .{ inode.hdr.gid_idx, err }) catch {};
-                        }
-                        return;
-                    };
-                    fil.chmod(inode.hdr.perm) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error chmod {s}: {}\n", .{ path, err }) catch {};
-                        }
-                        return;
-                    };
-                    fil.chown(fil_uid, fil_gid) catch |err| {
-                        if (op.verbose) {
-                            std.fmt.format(op.verbose_logger, "error chmod {s}: {}\n", .{ path, err }) catch {};
-                        }
-                        return;
-                    };
-                },
-                // .symlink, .ext_symlink => {},
-                else => {
-                    std.debug.print("TODO: {}\n", .{inode.hdr.type});
-                },
-            }
-        }
+        .inode = inode,
+        .name = name,
    };
 }
+pub fn initDirEntry(alloc: std.mem.Allocator, io: Io, archive: *Archive, entry: Directory.Entry) !SfsFile {
+    const new_name = try alloc.alloc(u8, entry.name.len);
+    defer alloc.free(new_name);
+    @memcpy(new_name, entry.name);
+
+    return .{
+        .alloc = alloc,
+        .archive = archive,
+
+        .inode = try .initDirEntry(
+            alloc,
+            io,
+            &archive.cache,
+            archive.super.inode_start,
+            archive.super.block_size,
+            entry,
+        ),
+        .name = new_name,
+    };
+}
+/// Creates a new copy of the given SfsFile using the given allocator
+pub fn copy(self: SfsFile, alloc: std.mem.Allocator) !SfsFile {
+    const new_name = try alloc(u8, self.name.len);
+    errdefer alloc.free(new_name);
+
+    return .{
+        .alloc = alloc,
+        .archive = self.archive,
+
+        .inode = try self.inode.copy(alloc),
+        .name = new_name,
+    };
+}
+pub fn deinit(self: SfsFile) void {
+    self.inode.deinit(self.alloc);
+    self.alloc.free(self.name);
+}
+
+/// Attempts to open the filepath if the SfsFile is a directory.
+/// If the given path refers to itself (such as "" or "."), a copied SfsFile is returned.
+pub fn open(self: SfsFile, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !SfsFile {
+    const path = std.mem.trim(u8, filepath, "/");
+
+    const first_element: []const u8 = std.mem.sliceTo(path, '/');
+
+    const dir: Directory = try self.inode.directory(alloc, io, &self.archive.cache, self.archive.super.dir_start);
+    defer dir.deinit(alloc);
+
+    var cur_slice = dir.entries;
+    var idx: usize = undefined;
+    while (cur_slice.len > 0) {
+        idx = cur_slice.len / 2;
+        switch (std.mem.order(u8, first_element, cur_slice[idx].name)) {
+            .eq => break,
+            .lt => cur_slice = cur_slice[0..idx],
+            .gt => cur_slice = cur_slice[idx..],
+        }
+    } else {
+        return error.NotFound;
+    }
+    if (first_element.len == path.len) return .initDirEntry(alloc, io, self.archive, cur_slice[idx]);
+    if (cur_slice[idx].type != .dir) return error.NotFound;
+    const tmp_file: SfsFile = try .initDirEntry(alloc, io, self.archive, cur_slice[idx]);
+    defer tmp_file.deinit();
+
+    return tmp_file.open(alloc, io, path[first_element.len..]);
+}
+
+pub fn extract(self: SfsFile, alloc: std.mem.Allocator, io: Io, ext_dir: []const u8, options: ExtractionOptions) !void {
+    _ = self;
+    _ = alloc;
+    _ = io;
+    _ = ext_dir;
+    _ = options;
+    return error.TODO;
+}
@@ -1,7 +0,0 @@
-const BlockSize = @import("inode/file.zig").BlockSize;
-
-pub const FragEntry = packed struct {
-    block: u64,
-    size: BlockSize,
-    _: u32,
-};
@@ -1,16 +1,118 @@
 const std = @import("std");
+const Io = std.Io;
+const Reader = Io.Reader;

-const dir = @import("inode/dir.zig");
-const file = @import("inode/file.zig");
-const misc = @import("inode/misc.zig");
+const DecompCache = @import("decomp_cache.zig");
+const Directory = @import("directory.zig");
+const MetadataReader = @import("meta_rdr.zig");

-pub const Ref = packed struct {
-    offset: u16,
-    block: u32,
+const Inode = @This();
+
+hdr: Header,
+data: Data,
+
+/// Read an inode given an inode Ref.
+pub fn initRef(alloc: std.mem.Allocator, io: Io, cache: *DecompCache, inode_start: u64, block_size: u32, ref: Ref) !Inode {
+    var meta: MetadataReader = .init(io, cache, inode_start + ref.block_start);
+    defer meta.deinit(io);
+    try meta.interface.discardAll(ref.block_offset);
+
+    return .init(alloc, &meta.interface, block_size);
+}
+pub fn initDirEntry(alloc: std.mem.Allocator, io: Io, cache: *DecompCache, inode_start: u64, block_size: u32, entry: Directory.Entry) !Inode {
+    var meta: MetadataReader = .init(io, cache, inode_start + entry.block_start);
+    defer meta.deinit(io);
+    try meta.interface.discardAll(entry.block_offset);
+
+    return .init(alloc, &meta.interface, block_size);
+}
+/// Read the inode from the given Reader.
+pub fn init(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
+    var hdr: Header = undefined;
+    try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
+    const data: Data = switch (hdr.type) {
+        .dir => .{ .dir = try .init(rdr) },
+        .file => .{ .file = try .init(alloc, rdr, block_size) },
+        .symlink => .{ .symlink = try .init(alloc, rdr) },
+        .block_dev => .{ .block_dev = try .init(rdr) },
+        .char_dev => .{ .char_dev = try .init(rdr) },
+        .fifo => .{ .fifo = try .init(rdr) },
+        .socket => .{ .socket = try .init(rdr) },
+        .ext_dir => .{ .ext_dir = try .init(rdr) },
+        .ext_file => .{ .ext_file = try .init(alloc, rdr, block_size) },
+        .ext_symlink => .{ .ext_symlink = try .init(alloc, rdr) },
+        .ext_block_dev => .{ .ext_block_dev = try .init(rdr) },
+        .ext_char_dev => .{ .ext_char_dev = try .init(rdr) },
+        .ext_fifo => .{ .ext_fifo = try .init(rdr) },
+        .ext_socket => .{ .ext_socket = try .init(rdr) },
+    };
+    return .{
+        .hdr = hdr,
+        .data = data,
+    };
+}
+pub fn copy(self: Inode, alloc: std.mem.Allocator) !Inode {
+    var new_inode = self;
+    switch (new_inode.data) {
+        .file => |*f| {
+            if (f.blocks.len > 0) {
+                f.blocks = try alloc.alloc(DataBlock, f.blocks.len);
+                @memcpy(f.blocks, self.data.file.blocks);
+            }
+        },
+        .ext_file => |*f| {
+            if (f.blocks.len > 0) {
+                f.blocks = try alloc.alloc(DataBlock, f.blocks.len);
+                @memcpy(f.blocks, self.data.ext_file.blocks);
+            }
+        },
+        .symlink => |*s| {
+            s.target = try alloc.alloc(u8, s.target.len);
+            @memcpy(s.target, self.data.symlink.target);
+        },
+        .ext_symlink => |*s| {
+            s.target = try alloc.alloc(u8, s.target.len);
+            @memcpy(s.target, self.data.ext_symlink.target);
+        },
+    }
+    return new_inode;
+}
+pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
+    switch (self.data) {
+        .file => |f| f.deinit(alloc),
+        .ext_file => |f| f.deinit(alloc),
+        .symlink => |s| s.deinit(alloc),
+        .ext_symlink => |s| s.deinit(alloc),
+        else => {},
+    }
+}
+
+// Utility functions
+
+pub fn directory(self: Inode, alloc: std.mem.Allocator, io: Io, cache: *DecompCache, dir_start: u64) !Directory {
+    return switch (self.data) {
+        .dir => |d| readDirectory(alloc, io, cache, dir_start, d),
+        .ext_dir => |d| readDirectory(alloc, io, cache, dir_start, d),
+        else => error.NotDirectory,
+    };
+}
+fn readDirectory(alloc: std.mem.Allocator, io: Io, cache: *DecompCache, dir_start: u64, d: anytype) !Directory {
+    var meta: MetadataReader = .init(io, cache, dir_start + d.block_start);
+    defer meta.deinit(io);
+    try meta.interface.discardAll(d.block_offset);
+
+    return .init(alloc, &meta.interface, d.size);
+}
+
+// Types
+
+pub const Ref = packed struct(u64) {
+    block_offset: u16,
+    block_start: u32,
    _: u16,
 };

-pub const Type = enum(u16) {
+pub const Enum = enum(u16) {
    dir = 1,
    file,
    symlink,
@@ -27,67 +129,270 @@ pub const Type = enum(u16) {
    ext_socket,
 };

-pub const Header = packed struct {
-    type: Type,
-    perm: u16,
+pub const Header = extern struct {
+    type: Enum,
+    permission: u16,
    uid_idx: u16,
    gid_idx: u16,
    mod_time: u32,
    num: u32,
 };

-pub const Data = union(enum) {
-    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 Data = union(Enum) {
+    dir: Dir,
+    file: File,
+    symlink: Symlink,
+    block_dev: Device,
+    char_dev: Device,
+    fifo: IPC,
+    socket: IPC,
+    ext_dir: ExtDir,
+    ext_file: ExtFile,
+    ext_symlink: ExtSymlink,
+    ext_block_dev: ExtDevice,
+    ext_char_dev: ExtDevice,
+    ext_fifo: ExtIPC,
+    ext_socket: ExtIPC,
 };

-const Self = @This();
+pub const DataBlock = packed struct(u32) {
+    size: u24,
+    uncompressed: bool,
+    _: u7,
+};

-hdr: Header,
-data: Data,
+const Dir = extern struct {
+    block_start: u32,
+    hard_links: u32,
+    size: u16,
+    block_offset: u16,
+    parent: u32,

-pub fn init(rdr: anytype, alloc: std.mem.Allocator, block_size: u32) !Self {
-    var hdr: Header = undefined;
-    _ = try rdr.read(std.mem.asBytes(&hdr));
-    const data: Data = switch (hdr.type) {
-        .dir => .{ .dir = try .init(rdr) },
-        .file => .{ .file = try .init(rdr, alloc, block_size) },
-        .symlink => .{ .symlink = try .init(rdr, alloc) },
-        .block_dev => .{ .block_dev = try .init(rdr) },
-        .char_dev => .{ .char_dev = try .init(rdr) },
-        .fifo => .{ .fifo = try .init(rdr) },
-        .socket => .{ .socket = try .init(rdr) },
-        .ext_dir => .{ .ext_dir = try .init(rdr) },
-        .ext_file => .{ .ext_file = try .init(rdr, alloc, block_size) },
-        .ext_symlink => .{ .ext_symlink = try .init(rdr, alloc) },
-        .ext_block_dev => .{ .ext_block_dev = try .init(rdr) },
-        .ext_char_dev => .{ .ext_char_dev = try .init(rdr) },
-        .ext_fifo => .{ .ext_fifo = try .init(rdr) },
-        .ext_socket => .{ .ext_socket = try .init(rdr) },
-    };
-    return .{
-        .hdr = hdr,
-        .data = data,
-    };
-}
-pub fn deinit(self: Self, alloc: std.mem.Allocator) void {
-    switch (self.data) {
-        .file => |f| alloc.free(f.block_sizes),
-        .ext_file => |f| alloc.free(f.block_sizes),
-        .symlink => |s| alloc.free(s.target),
-        .ext_symlink => |s| alloc.free(s.target),
-        else => {},
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
    }
-}
+};
+const ExtDir = extern struct {
+    hard_links: u32,
+    size: u32,
+    block_start: u32,
+    parent: u32,
+    idx_count: u16,
+    block_offset: u16,
+    xattr_idx: u32,
+    // []DirIndex
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+
+const File = struct {
+    data_start: u32,
+    frag_idx: u32,
+    frag_offset: u32,
+    size: u32,
+    blocks: []DataBlock,
+
+    const Raw = extern struct {
+        data_start: u32,
+        frag_idx: u32,
+        frag_offset: u32,
+        size: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        var blocks_num = raw.size / block_size;
+        if (raw.frag_idx == 0xFFFFFFFF and raw.size % block_size > 0)
+            blocks_num += 1;
+
+        const blocks: []DataBlock = try alloc.alloc(DataBlock, blocks_num);
+        errdefer alloc.free(blocks);
+
+        try rdr.readSliceEndian(DataBlock, blocks, .little);
+        return .{
+            .data_start = raw.data_start,
+            .frag_idx = raw.frag_idx,
+            .frag_offset = raw.frag_offset,
+            .size = raw.size,
+            .blocks = blocks,
+        };
+    }
+    pub fn deinit(self: File, alloc: std.mem.Allocator) void {
+        alloc.free(self.blocks);
+    }
+};
+const ExtFile = struct {
+    data_start: u64,
+    size: u64,
+    sparse: u64,
+    hard_links: u32,
+    frag_idx: u32,
+    frag_offset: u32,
+    xattr_idx: u32,
+    blocks: []DataBlock,
+
+    const Raw = extern struct {
+        data_start: u64,
+        size: u64,
+        sparse: u64,
+        hard_links: u32,
+        frag_idx: u32,
+        frag_offset: u32,
+        xattr_idx: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        var blocks_num = raw.size / block_size;
+        if (raw.frag_idx == 0xFFFFFFFF and raw.size % block_size > 0)
+            blocks_num += 1;
+
+        const blocks: []DataBlock = try alloc.alloc(DataBlock, blocks_num);
+        errdefer alloc.free(blocks);
+
+        try rdr.readSliceEndian(DataBlock, blocks, .little);
+        return .{
+            .data_start = raw.data_start,
+            .size = raw.size,
+            .sparse = raw.sparse,
+            .hard_links = raw.hard_links,
+            .frag_idx = raw.frag_idx,
+            .frag_offset = raw.frag_offset,
+            .xattr_idx = raw.xattr_idx,
+            .blocks = blocks,
+        };
+    }
+    pub fn deinit(self: ExtFile, alloc: std.mem.Allocator) void {
+        alloc.free(self.blocks);
+    }
+};
+
+const Symlink = struct {
+    hard_links: u32,
+    target: []const u8,
+
+    const Raw = extern struct {
+        hard_links: u32,
+        target_size: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        const target = try alloc.alloc(u8, raw.target_size);
+        try rdr.readSliceEndian(u8, target, .little);
+
+        return .{
+            .hard_links = raw.hard_links,
+            .target = target,
+        };
+    }
+    pub fn deinit(self: Symlink, alloc: std.mem.Allocator) void {
+        alloc.free(self.target);
+    }
+};
+const ExtSymlink = struct {
+    hard_links: u32,
+    xattr_idx: u32,
+    target: []const u8,
+
+    const Raw = extern struct {
+        hard_links: u32,
+        target_size: u32,
+    };
+
+    const Self = @This();
+
+    pub fn init(alloc: std.mem.Allocator, rdr: *Reader) !Self {
+        var raw: Raw = undefined;
+        try rdr.readSliceEndian(Raw, @ptrCast(&raw), .little);
+
+        const target = try alloc.alloc(u8, raw.target_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 = raw.hard_links,
+            .target = target,
+            .xattr_idx = xattr_idx,
+        };
+    }
+
+    pub fn deinit(self: ExtSymlink, alloc: std.mem.Allocator) void {
+        alloc.free(self.target);
+    }
+};
+
+const Device = extern struct {
+    hard_links: u32,
+    device: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+const ExtDevice = extern struct {
+    hard_links: u32,
+    device: u32,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+
+const IPC = extern struct {
+    hard_links: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
+const ExtIPC = extern struct {
+    hard_links: u32,
+    xattr_idx: u32,
+
+    const Self = @This();
+
+    fn init(rdr: *Reader) !Self {
+        var dir: Self = undefined;
+        try rdr.readSliceEndian(Self, @ptrCast(&dir), .little);
+        return dir;
+    }
+};
@@ -1,31 +0,0 @@
-const std = @import("std");
-
-pub const Dir = packed struct {
-    block: u32,
-    hard_link: u32,
-    size: u16,
-    offset: u16,
-    parent_num: u32,
-
-    pub fn init(rdr: anytype) !Dir {
-        var out: Dir = undefined;
-        _ = try rdr.read(std.mem.asBytes(&out));
-        return out;
-    }
-};
-
-pub const ExtDir = packed struct {
-    hard_link: u32,
-    size: u32,
-    block: u32,
-    parent_num: u32,
-    idx_count: u16,
-    offset: u16,
-    xattr_idx: u32,
-
-    pub fn init(rdr: anytype) !ExtDir {
-        var out: ExtDir = undefined;
-        _ = try rdr.read(std.mem.asBytes(&out));
-        return out;
-    }
-};
@@ -1,77 +0,0 @@
-const std = @import("std");
-
-pub const BlockSize = packed struct {
-    size: u24,
-    uncompressed: bool,
-    _: u7,
-};
-
-pub const File = struct {
-    block: u32,
-    frag_idx: u32,
-    frag_offset: u32,
-    size: u32,
-    block_sizes: []BlockSize,
-
-    pub fn init(rdr: anytype, alloc: std.mem.Allocator, block_size: u32) !File {
-        var fixed: [16]u8 = undefined;
-        _ = try rdr.read(&fixed);
-        const frag_idx = std.mem.readInt(u32, fixed[4..8], .little);
-        const size = std.mem.readInt(u32, fixed[12..16], .little);
-        var blocks: u32 = size / block_size;
-        if (size % block_size > 0 and frag_idx == 0xffffffff) {
-            blocks += 1;
-        }
-        const block_sizes = try alloc.alloc(BlockSize, blocks);
-        errdefer alloc.free(block_sizes);
-        _ = try rdr.read(std.mem.sliceAsBytes(block_sizes));
-        return .{
-            .block = std.mem.readInt(u32, fixed[0..4], .little),
-            .frag_idx = frag_idx,
-            .frag_offset = std.mem.readInt(u32, fixed[8..12], .little),
-            .size = size,
-            .block_sizes = block_sizes,
-        };
-    }
-    pub fn hasFragment(self: File) bool {
-        return self.frag_idx != 0xffffffff;
-    }
-};
-
-pub const ExtFile = struct {
-    block: u64,
-    size: u64,
-    sparse: u64,
-    hard_link: u32,
-    frag_idx: u32,
-    frag_offset: u32,
-    xattr_idx: u32,
-    block_sizes: []BlockSize,
-
-    pub fn init(rdr: anytype, alloc: std.mem.Allocator, block_size: u32) !ExtFile {
-        var fixed: [40]u8 = undefined;
-        _ = try rdr.read(&fixed);
-        const size = std.mem.readInt(u64, fixed[8..16], .little);
-        const frag_idx = std.mem.readInt(u32, fixed[28..32], .little);
-        var blocks: u32 = @truncate(size / block_size);
-        if (size % block_size > 0 and frag_idx == 0xffffffff) {
-            blocks += 1;
-        }
-        const block_sizes = try alloc.alloc(BlockSize, blocks);
-        errdefer alloc.free(block_sizes);
-        _ = try rdr.read(std.mem.sliceAsBytes(block_sizes));
-        return .{
-            .block = std.mem.readInt(u64, fixed[0..8], .little),
-            .size = size,
-            .sparse = std.mem.readInt(u64, fixed[16..24], .little),
-            .hard_link = std.mem.readInt(u32, fixed[24..28], .little),
-            .frag_idx = frag_idx,
-            .frag_offset = std.mem.readInt(u32, fixed[32..36], .little),
-            .xattr_idx = std.mem.readInt(u32, fixed[36..40], .little),
-            .block_sizes = block_sizes,
-        };
-    }
-    pub fn hasFragment(self: ExtFile) bool {
-        return self.frag_idx != 0xffffffff;
-    }
-};
@@ -1,87 +0,0 @@
-const std = @import("std");
-
-pub const Symlink = struct {
-    hard_link: u32,
-    // size: u32,
-    target: []const u8,
-
-    pub fn init(rdr: anytype, alloc: std.mem.Allocator) !Symlink {
-        var fixed: [8]u8 = undefined;
-        _ = try rdr.read(&fixed);
-        const size = std.mem.readInt(u32, fixed[4..8], .little);
-        const target = try alloc.alloc(u8, size);
-        errdefer alloc.free(target);
-        _ = try rdr.read(target);
-        return .{
-            .hard_link = std.mem.readInt(u32, fixed[0..4], .little),
-            .target = target,
-        };
-    }
-};
-
-pub const ExtSymlink = struct {
-    hard_link: u32,
-    // size: u32,
-    target: []const u8,
-    xattr_idx: u32,
-
-    pub fn init(rdr: anytype, alloc: std.mem.Allocator) !ExtSymlink {
-        var fixed: [8]u8 = undefined;
-        _ = try rdr.read(&fixed);
-        const size = std.mem.readInt(u32, fixed[4..8], .little);
-        const target = try alloc.alloc(u8, size);
-        errdefer alloc.free(target);
-        _ = try rdr.read(target);
-        var xattr_idx: u32 = 0;
-        _ = try rdr.read(std.mem.asBytes(&xattr_idx));
-        return .{
-            .hard_link = std.mem.readInt(u32, fixed[0..4], .little),
-            .target = target,
-            .xattr_idx = xattr_idx,
-        };
-    }
-};
-
-pub const Dev = packed struct {
-    hard_link: u32,
-    device: u32,
-
-    pub fn init(rdr: anytype) !Dev {
-        var out: Dev = undefined;
-        _ = try rdr.read(std.mem.asBytes(&out));
-        return out;
-    }
-};
-
-pub const ExtDev = packed struct {
-    hard_link: u32,
-    device: u32,
-    xattr_idx: u32,
-
-    pub fn init(rdr: anytype) !ExtDev {
-        var out: ExtDev = undefined;
-        _ = try rdr.read(std.mem.asBytes(&out));
-        return out;
-    }
-};
-
-pub const IPC = packed struct {
-    hard_link: u32,
-
-    pub fn init(rdr: anytype) !IPC {
-        var out: IPC = undefined;
-        _ = try rdr.read(std.mem.asBytes(&out));
-        return out;
-    }
-};
-
-pub const ExtIPC = packed struct {
-    hard_link: u32,
-    xattr_idx: u32,
-
-    pub fn init(rdr: anytype) !ExtIPC {
-        var out: ExtIPC = undefined;
-        _ = try rdr.read(std.mem.asBytes(&out));
-        return out;
-    }
-};
@@ -0,0 +1,114 @@
+const std = @import("std");
+const Io = std.Io;
+
+const DataBlock = @import("inode.zig").DataBlock;
+const InodeRef = @import("inode.zig").Ref;
+const DecompCache = @import("decomp_cache.zig");
+const MetadataReader = @import("meta_rdr.zig");
+
+pub fn stateless(comptime T: anytype, io: Io, cache: *DecompCache, table_start: u64, idx: u32) !T {
+    const PER_BLOCK = 8192 / @sizeOf(T);
+
+    const block = idx / PER_BLOCK;
+    const block_idx = idx % PER_BLOCK;
+
+    const offset_offset = table_start + (block * 8);
+    const offset: u64 = std.mem.readInt(u64, cache.map.memory[offset_offset..][0..2], .little);
+
+    var meta: MetadataReader = .init(io, cache, offset);
+    defer meta.deinit(io);
+    try meta.discardAll(block_idx * @sizeOf(T));
+
+    var new: T = undefined;
+    try meta.interface.readSliceEndian(T, @ptrCast(&new), .little);
+    return new;
+}
+
+pub fn Table(comptime T: anytype) type {
+    return struct {
+        const PER_BLOCK = 8192 / @sizeOf(T);
+
+        const LookupTable = @This();
+
+        alloc: std.mem.Allocator,
+
+        cache: *DecompCache,
+        table_start: u64,
+
+        num: u32,
+        values: std.AutoHashMap(u32, []T),
+        mut: Io.RwLock = .init,
+
+        pub fn init(alloc: std.mem.Allocator, cache: *DecompCache, table_start: u64, num_values: u32) LookupTable {
+            return .{
+                .alloc = alloc,
+
+                .cache = cache,
+                .table_start = table_start,
+
+                .num = num_values,
+                .values = .init(alloc),
+            };
+        }
+        pub fn deinit(self: *LookupTable) void {
+            var iter = self.values.valueIterator();
+            while (iter.next()) |v|
+                self.alloc.free(v);
+            self.values.deinit();
+        }
+
+        pub fn get(self: *LookupTable, io: Io, idx: u32) Error!T {
+            const block = idx / PER_BLOCK;
+            const block_idx = idx % PER_BLOCK;
+            {
+                try self.mut.lockShared(io);
+                defer self.mut.unlockShared(io);
+
+                const val = self.values.get(block);
+                if (val != null) return val.*[block_idx];
+            }
+            try self.mut.lock(io);
+            defer self.mut.unlock(io);
+
+            const val = try self.values.getOrPut(block);
+            if (val.found_existing)
+                return val.value_ptr.*[block_idx];
+            errdefer self.values.removeByPtr(val.key_ptr);
+
+            const offset_offset = self.table_start + (block * 8);
+            const offset: u64 = std.mem.readInt(u64, self.cache.map.memory[offset_offset..][0..2], .little);
+
+            var meta: MetadataReader = .init(io, self.cache, offset);
+            defer meta.deinit(io);
+
+            const size = if (block == ((self.num - 1) / PER_BLOCK))
+                self.num % PER_BLOCK
+            else
+                PER_BLOCK;
+
+            const new_block = try self.alloc.alloc(T, size);
+            errdefer self.alloc.free(new_block);
+            try meta.interface.readSliceEndian(T, new_block, .little);
+
+            val.value_ptr.* = new_block;
+
+            return new_block[block_idx];
+        }
+    };
+}
+
+// Types
+
+pub const Error = error{} || std.mem.Allocator.Error;
+
+pub const FragmentEntry = extern struct {
+    start: u64,
+    size: DataBlock,
+    _: u32,
+};
+
+pub const XattrEntry = extern struct {
+    ref: InodeRef,
+    count: u32,
+    size: u32,
+};
@@ -0,0 +1,109 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = Io.Reader;
+const Writer = Io.Writer;
+const Limit = Io.Limit;
+
+const DecompCache = @import("decomp_cache.zig");
+
+const MetadataReader = @This();
+
+io: Io,
+cache: *DecompCache,
+
+cur_offset: u64 = 0,
+next_offset: u64,
+
+interface: Reader = .{
+    .buffer = &[0]u8{},
+    .end = 0,
+    .seek = 0,
+    .vtable = &.{
+        .stream = stream,
+        .discard = discard,
+        .readVec = readVec,
+    },
+},
+
+pub fn init(io: Io, cache: *DecompCache, start: u64) MetadataReader {
+    return .{
+        .io = io,
+        .cache = cache,
+
+        .next_offset = start,
+    };
+}
+pub fn deinit(self: *MetadataReader, io: Io) void {
+    self.cache.finished(io, self.cur_offset);
+}
+
+fn advance(self: *MetadataReader) !void {
+    self.cache.finished(self.io, self.cur_offset);
+
+    self.interface.seek = 0;
+    errdefer self.interface.end = 0;
+
+    const hdr: Header = @bitCast(std.mem.readInt(u16, self.cache.map.memory[self.next_offset..][0..2], .little));
+    self.cur_offset = self.next_offset + 2;
+    self.next_offset = self.cur_offset + hdr.size;
+
+    if (hdr.uncompressed) {
+        self.interface.buffer = self.cache.map.memory[self.cur_offset..][0..hdr.size];
+        self.interface.end = hdr.size;
+        return;
+    }
+    self.interface.buffer = try self.cache.get(self.io, self.cur_offset, hdr.size, 8192);
+    self.interface.end = self.interface.buffer.len;
+}
+
+fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize {
+    if (r.seek >= r.end) {
+        const self: *MetadataReader = @fieldParentPtr("interface", r);
+        self.advance() catch |err| {
+            std.debug.print("error advancing metadata reader: {}\n", .{err});
+            return Reader.Error.ReadFailed;
+        };
+    }
+    const to_write = @min(r.end - r.seek, @intFromEnum(limit));
+    const wrote = try w.write(r.buffer[r.seek..][0..to_write]);
+    r.seek += wrote;
+    return wrote;
+}
+fn discard(r: *Reader, limit: Limit) Reader.Error!usize {
+    if (r.seek >= r.end) {
+        const self: *MetadataReader = @fieldParentPtr("interface", r);
+        self.advance() catch |err| {
+            std.debug.print("error advancing metadata reader: {}\n", .{err});
+            return Reader.Error.ReadFailed;
+        };
+    }
+    const to_discard = @min(r.end - r.seek, @intFromEnum(limit));
+    r.seek += to_discard;
+    return to_discard;
+}
+fn readVec(r: *Reader, vec: [][]u8) Reader.Error!usize {
+    if (r.seek >= r.end) {
+        const self: *MetadataReader = @fieldParentPtr("interface", r);
+        self.advance() catch |err| {
+            std.debug.print("error advancing metadata reader: {}\n", .{err});
+            return Reader.Error.ReadFailed;
+        };
+    }
+    var total: usize = 0;
+    for (vec) |v| {
+        const to_copy = @min(r.end - r.seek, v.len);
+        @memcpy(v[0..to_copy], r.buffer[r.seek..][0..to_copy]);
+        r.seek += to_copy;
+        total += to_copy;
+        if (r.seek >= r.end)
+            break;
+    }
+    return total;
+}
+
+// Types
+
+const Header = packed struct(u16) {
+    size: u15,
+    uncompressed: bool,
+};
@@ -0,0 +1,25 @@
+//! Options for file/directory extraction.
+
+const std = @import("std");
+const Writer = std.Io.Writer;
+
+const ExtractionOptions = @This();
+
+/// Don't set the file's owner & permissions after extraction
+ignore_permissions: bool = false,
+/// Don't set xattr values. Currently xattrs are never set anyway.
+ignore_xattr: bool = false,
+/// Replace symlinks with their target.
+dereference_symlinks: bool = false,
+/// Verbose logging. If true, verbose_writer must be set
+verbose: bool = false,
+/// Where to print verbose log.
+verbose_writer: ?*Writer = null,
+
+pub const default: ExtractionOptions = .{};
+pub fn VerboseDefault(wrt: *Writer) !ExtractionOptions {
+    return .{
+        .verbose = true,
+        .verbose_writer = wrt,
+    };
+}
@@ -1,85 +0,0 @@
-const std = @import("std");
-
-const Inode = @import("inode.zig");
-const File = @import("file.zig").File;
-const Table = @import("table.zig").Table;
-const PRead = @import("reader/p_read.zig").PRead;
-const FragEntry = @import("fragment.zig").FragEntry;
-const Superblock = @import("superblock.zig").Superblock;
-const ExtractionOptions = @import("extract_options.zig");
-const MetadataReader = @import("reader/metadata.zig").MetadataReader;
-
-pub const SfsError = error{
-    NotExportable,
-};
-
-pub fn SfsReader(comptime T: type) type {
-    comptime std.debug.assert(std.meta.hasFn(T, "pread"));
-
-    return struct {
-        const Self = @This();
-
-        alloc: std.mem.Allocator,
-        rdr: PRead(T),
-
-        super: Superblock = undefined,
-        /// ID table. Can be accessed directly
-        id_table: Table(u32, T) = undefined,
-        /// Fragment table. Can be accessed directly
-        frag_table: Table(FragEntry, T) = undefined,
-        /// Export table. Each element is an inode referce.
-        /// If accessing directly, keep in mind, the table starts at inode 1, as such it's recommended to use the InodeAt function instead.
-        export_table: Table(Inode.Ref, T) = undefined,
-
-        pub fn init(alloc: std.mem.Allocator, rdr: T, offset: u64) !Self {
-            var out: Self = .{
-                .alloc = alloc,
-                .rdr = .init(rdr, offset),
-            };
-            _ = try rdr.pread(std.mem.asBytes(&out.super), 0);
-            out.frag_table = .init(alloc, out.rdr, out.super.comp, out.super.frag_start, out.super.frag_count);
-            out.id_table = .init(alloc, out.rdr, out.super.comp, out.super.id_start, out.super.id_count);
-            out.export_table = .init(alloc, out.rdr, out.super.comp, out.super.export_start, out.super.inode_count);
-            return out;
-        }
-        pub fn deinit(self: *Self) void {
-            self.id_table.deinit();
-            self.frag_table.deinit();
-            self.export_table.deinit();
-        }
-
-        /// A representation of the archives root folder.
-        pub fn root(self: *Self) !File(T) {
-            return .initFromRef(self, self.super.root_ref, "");
-        }
-        /// Get the file at path. Equivelent to calling open on the root File.
-        pub fn open(self: *Self, path: []const u8) !File(T) {
-            var rt = try self.root();
-            if (path.len == 0 or (path.len == 1 and path[0] == '/') or path.len == 1 and path[0] == '.') return rt;
-            defer rt.deinit();
-            return rt.open(path);
-        }
-        /// Extract the entire archive to the given path & with the given options.
-        /// Equivelent to calling extract on the root File.
-        pub fn extract(self: *Self, op: ExtractionOptions, path: []const u8) !void {
-            var rt = try self.root();
-            defer rt.deinit();
-            return rt.extract(op, path);
-        }
-
-        /// Returns the Inode with the given Inode Number.
-        /// Requires the archive to have an export table.
-        pub fn inodeAt(self: Self, num: u32) !Inode {
-            if (!self.super.flags.has_export) return SfsError.NotExportable;
-            const ref = try self.export_table.get(num - 1);
-            var meta = MetadataReader(T).init(
-                self.alloc,
-                self.super.comp,
-                self.rdr,
-                self.super.inode_start + ref.block,
-            );
-            try meta.skip(ref.offset);
-            return .init(meta, self.alloc, self.super.block_size);
-        }
-    };
-}
@@ -1,271 +0,0 @@
-const std = @import("std");
-
-const Inode = @import("../inode.zig");
-const PRead = @import("p_read.zig").PRead;
-const SfsReader = @import("../reader.zig").SfsReader;
-const FragEntry = @import("../fragment.zig").FragEntry;
-const BlockSize = @import("../inode/file.zig").BlockSize;
-const Compression = @import("../superblock.zig").Compression;
-
-const DataReaderError = error{
-    EOF,
-    InvalidIndex,
-    ExtractionActive,
-};
-
-const DecompCompletion = struct {
-    errs: std.ArrayList(anyerror),
-    map: std.AutoArrayHashMap(usize, []u8),
-    mut: std.Thread.Mutex = .{},
-    cond: std.Thread.Condition = .{},
-
-    fn init(alloc: std.mem.Allocator) DecompCompletion {
-        return .{
-            .errs = .init(alloc),
-            .map = .init(alloc),
-        };
-    }
-    fn deinit(self: *DecompCompletion) void {
-        self.errs.deinit();
-        self.map.deinit();
-    }
-
-    fn clear(self: *DecompCompletion) void {
-        self.mut.lock();
-        defer self.mut.unlock();
-        self.errs.clearAndFree();
-        self.map.clearAndFree();
-    }
-
-    fn add(self: *DecompCompletion, idx: usize, data: []u8) !void {
-        self.mut.lock();
-        defer self.mut.unlock();
-        defer self.cond.signal();
-        try self.map.put(idx, data);
-    }
-    fn addErr(self: *DecompCompletion, err: anyerror) void {
-        self.mut.lock();
-        defer self.mut.unlock();
-        defer self.cond.signal();
-        self.errs.append(err) catch {};
-    }
-
-    fn getBlock(self: *DecompCompletion, idx: usize) ?[]u8 {
-        const res = self.map.fetchSwapRemove(idx);
-        if (res == null) return null;
-        return res.?.value;
-    }
-    fn hasErrs(self: DecompCompletion) bool {
-        return self.errs.items.len > 0;
-    }
-    fn condWait(self: *DecompCompletion) void {
-        self.cond.wait(&self.mut);
-    }
-};
-
-pub fn DataReader(comptime T: type) type {
-    return struct {
-        const Self = @This();
-
-        alloc: std.mem.Allocator,
-        rdr: PRead(T),
-        comp: Compression,
-        block_size: u32,
-
-        sizes: []BlockSize,
-        offsets: []u64,
-        file_size: u64,
-
-        frag: ?[]u8 = null,
-
-        completion: DecompCompletion,
-
-        pub fn init(rdr: *SfsReader(T), inode: Inode) !Self {
-            var sizes: []BlockSize = undefined;
-            var file_size: u64 = 0;
-            var offsets: []u64 = undefined;
-            switch (inode.data) {
-                .file => |f| {
-                    sizes = f.block_sizes;
-                    file_size = f.size;
-                    offsets = try rdr.alloc.alloc(u64, sizes.len);
-                    if (sizes.len > 0) offsets[0] = f.block;
-                },
-                .ext_file => |f| {
-                    sizes = f.block_sizes;
-                    file_size = f.size;
-                    offsets = try rdr.alloc.alloc(u64, sizes.len);
-                    if (sizes.len > 0) offsets[0] = f.block;
-                },
-                else => unreachable,
-            }
-            if (offsets.len > 1) {
-                for (1..offsets.len) |i| {
-                    offsets[i] = offsets[i - 1] + sizes[i - 1].size;
-                }
-            }
-            return .{
-                .alloc = rdr.alloc,
-                .rdr = rdr.rdr,
-                .comp = rdr.super.comp,
-                .block_size = rdr.super.block_size,
-                .sizes = sizes,
-                .offsets = offsets,
-                .file_size = file_size,
-                .completion = .init(rdr.alloc),
-            };
-        }
-        pub fn deinit(self: *Self) void {
-            self.alloc.free(self.offsets);
-            self.completion.deinit();
-        }
-
-        pub fn addFragment(self: *Self, data: []u8) void {
-            self.frag = data;
-        }
-
-        pub fn writeTo(self: *Self, wrt: anytype) !void {
-            comptime std.debug.assert(std.meta.hasFn(@TypeOf(wrt), "write") or std.meta.hasFn(@TypeOf(wrt), "pwrite"));
-            var write_thr = try std.Thread.spawn(
-                .{ .allocator = self.alloc },
-                writeThread,
-                .{ self, wrt, null, null },
-            );
-            defer self.completion.clear();
-            for (0..self.numBlocks()) |i| {
-                var thr = std.Thread.spawn(
-                    .{ .allocator = self.alloc },
-                    decompThread,
-                    .{ self, i },
-                ) catch |err| {
-                    self.completion.addErr(err);
-                    continue;
-                };
-                thr.detach();
-            }
-            write_thr.join();
-            if (self.completion.hasErrs()) return self.completion.errs.items[0];
-        }
-
-        pub fn writeToNoBlock(self: *Self, wrt: anytype, comptime finish: anytype, finish_args: anytype) !void {
-            comptime std.debug.assert(std.meta.hasFn(@TypeOf(wrt), "write") or std.meta.hasFn(@TypeOf(wrt), "pwrite"));
-            errdefer self.completion.clear();
-            var write_thr = try std.Thread.spawn(
-                .{ .allocator = self.alloc },
-                writeThread,
-                .{ self, wrt, finish, finish_args },
-            );
-            write_thr.detach();
-            for (0..self.numBlocks()) |i| {
-                var thr = std.Thread.spawn(
-                    .{ .allocator = self.alloc },
-                    decompThread,
-                    .{ self, i },
-                ) catch |err| {
-                    self.completion.addErr(err);
-                    continue;
-                };
-                thr.detach();
-            }
-        }
-
-        fn numBlocks(self: Self) usize {
-            var out = self.sizes.len;
-            if (self.frag != null) out += 1;
-            return out;
-        }
-        /// Returns the decompressed data block at the given idx.
-        /// If the block is sparse (filled with 0s), a zero length slice is returned.
-        fn blockAt(self: Self, idx: usize) ![]u8 {
-            if (idx >= self.numBlocks()) return DataReaderError.InvalidIndex;
-            const size = self.sizes[idx];
-            if (size.size == 0) return &[0]u8{};
-            const block = try self.alloc.alloc(u8, blk: {
-                if (idx == self.numBlocks() - 1) break :blk self.file_size % self.block_size;
-                break :blk self.block_size;
-            });
-            if (idx == self.sizes.len and self.frag != null) {
-                @memcpy(block, self.frag.?);
-                return block;
-            }
-            if (size.uncompressed) {
-                _ = try self.rdr.pread(block, self.offsets[idx]);
-                return block;
-            }
-            _ = try self.comp.decompress(
-                1024 * 1024,
-                self.alloc,
-                self.rdr.readerAt(self.offsets[idx]).reader(),
-                block,
-            );
-            return block;
-        }
-
-        fn writeThread(
-            self: *Self,
-            wrt: anytype,
-            comptime finish: anytype,
-            finish_args: anytype,
-        ) void {
-            var cur_idx: usize = 0;
-            self.completion.mut.lock();
-            defer self.completion.mut.unlock();
-            while (cur_idx < self.numBlocks() and !self.completion.hasErrs()) {
-                self.completion.condWait();
-                if (self.completion.hasErrs()) break;
-                if (comptime std.meta.hasFn(@TypeOf(wrt), "pwrite")) {
-                    for (self.completion.map.keys()) |_| {
-                        const k = self.completion.map.keys()[0];
-                        const blk = self.completion.getBlock(k).?;
-                        defer self.alloc.free(blk);
-                        if (blk.len > 0) {
-                            _ = wrt.pwrite(blk, self.block_size * k) catch |err| {
-                                self.completion.addErr(err);
-                                break;
-                            };
-                        } else {
-                            _ = wrt.pwrite(&[1]u8{0}, (self.block_size * (k + 1)) - 1) catch |err| {
-                                self.completion.addErr(err);
-                                break;
-                            };
-                        }
-                        cur_idx += 1;
-                    }
-                    continue;
-                } else {
-                    while (self.completion.getBlock(cur_idx)) |blk| {
-                        defer self.alloc.free(blk);
-                        if (blk.len > 0) {
-                            _ = wrt.write(blk) catch |err| {
-                                self.completion.addErr(err);
-                                break;
-                            };
-                        } else {
-                            const blank: [1024 * 1024]u8 = [1]u8{0} ** (1024 * 1024);
-                            _ = wrt.write(blank[0..self.block_size]) catch |err| {
-                                self.completion.addErr(err);
-                                break;
-                            };
-                        }
-                        cur_idx += 1;
-                    }
-                }
-            }
-            if (comptime @TypeOf(finish) != @TypeOf(null) and @TypeOf(finish_args) != @TypeOf(null)) @call(.auto, finish, finish_args);
-        }
-        fn decompThread(
-            self: *Self,
-            idx: usize,
-        ) void {
-            if (self.completion.hasErrs()) return;
-            defer self.completion.cond.signal();
-            const block = self.blockAt(idx) catch |err| {
-                self.completion.addErr(err);
-                return;
-            };
-            self.completion.add(idx, block) catch |err| {
-                self.completion.addErr(err);
-            };
-        }
-    };
-}
@@ -1,82 +0,0 @@
-const std = @import("std");
-
-const PRead = @import("p_read.zig").PRead;
-const Compression = @import("../superblock.zig").Compression;
-
-const MetaHeader = packed struct {
-    size: u15,
-    uncompressed: bool,
-};
-
-pub fn MetadataReader(comptime T: type) type {
-    comptime std.debug.assert(std.meta.hasFn(T, "read"));
-    return struct {
-        const Self = @This();
-
-        alloc: std.mem.Allocator,
-        comp: Compression,
-        rdr: PRead(T),
-        offset: u64,
-
-        block: [8192]u8 = undefined,
-        block_size: usize = 0,
-        block_offset: u32 = 0,
-
-        pub fn init(alloc: std.mem.Allocator, comp: Compression, rdr: PRead(T), offset: u64) Self {
-            return .{
-                .alloc = alloc,
-                .comp = comp,
-                .rdr = rdr,
-                .offset = offset,
-            };
-        }
-
-        fn readNextBlock(self: *Self) !void {
-            var hdr: MetaHeader = undefined;
-            _ = try self.rdr.pread(std.mem.asBytes(&hdr), self.offset);
-            self.offset += 2;
-            if (hdr.uncompressed) {
-                self.block_size = try self.rdr.pread(self.block[0..hdr.size], self.offset);
-            } else {
-                self.block_size = try self.comp.decompress(
-                    8192,
-                    self.alloc,
-                    self.rdr.readerAt(self.offset).reader(),
-                    &self.block,
-                );
-            }
-            self.offset += hdr.size;
-            self.block_offset = 0;
-        }
-
-        pub fn skip(self: *Self, offset: u32) !void {
-            var skipped: u32 = 0;
-            var hdr: MetaHeader = undefined;
-            while (offset - skipped >= 8192) {
-                _ = try self.rdr.pread(std.mem.asBytes(&hdr), self.offset);
-                self.offset += 2 + hdr.size;
-                skipped += 8192;
-            }
-            var to_skip: u32 = 0;
-            while (skipped < offset) {
-                if (self.block_offset >= self.block_size) try self.readNextBlock();
-                to_skip = @min(self.block_size - self.block_offset, offset - skipped);
-                self.block_offset += to_skip;
-                skipped += to_skip;
-            }
-        }
-
-        pub fn read(self: *Self, buf: []u8) !usize {
-            var cur_red: usize = 0;
-            var to_read: usize = 0;
-            while (cur_red < buf.len) {
-                if (self.block_offset >= self.block_size) try self.readNextBlock();
-                to_read = @min(buf.len - cur_red, self.block_size - self.block_offset);
-                @memcpy(buf[cur_red .. cur_red + to_read], self.block[self.block_offset .. self.block_offset + to_read]);
-                cur_red += to_read;
-                self.block_offset += @truncate(to_read);
-            }
-            return cur_red;
-        }
-    };
-}
@@ -1,29 +0,0 @@
-const std = @import("std");
-
-const ToRead = @import("to_read.zig").ToRead;
-
-/// A simple wrapper around a type with the pread([]u8, u64) function.
-/// Provides a couple useful utility functions.
-pub fn PRead(comptime T: type) type {
-    comptime std.debug.assert(std.meta.hasFn(T, "pread"));
-    return struct {
-        const Self = @This();
-
-        rdr: T,
-        offset: u64,
-
-        pub fn init(rdr: T, offset: u64) Self {
-            return .{
-                .rdr = rdr,
-                .offset = offset,
-            };
-        }
-
-        pub fn pread(self: Self, buf: []u8, offset: u64) !usize {
-            return self.rdr.pread(buf, self.offset + offset);
-        }
-        pub fn readerAt(self: Self, offset: u64) ToRead(T) {
-            return .init(self.rdr, self.offset + offset);
-        }
-    };
-}
@@ -1,43 +0,0 @@
-const std = @import("std");
-
-pub fn ToRead(comptime T: type) type {
-    comptime std.debug.assert(std.meta.hasFn(T, "pread"));
-    return struct {
-        const Self = @This();
-
-        pub const Error = anyerror;
-
-        rdr: T,
-        offset: u64,
-
-        pub fn init(rdr: T, init_offset: u64) Self {
-            return .{
-                .rdr = rdr,
-                .offset = init_offset,
-            };
-        }
-
-        pub fn read(self: *Self, buf: []u8) !usize {
-            const red = try self.rdr.pread(buf, self.offset);
-            self.offset += red;
-            return red;
-        }
-        pub fn readAll(self: *Self, buf: []u8) !usize {
-            var cur_red = try self.read(buf);
-            if (cur_red == 0) return cur_red;
-            var res: usize = 0;
-            while (cur_red < buf.len) {
-                res = try self.read(buf[cur_red..]);
-                if (res == 0) break;
-                cur_red += res;
-            }
-            return cur_red;
-        }
-        const Reader = std.io.GenericReader(*Self, anyerror, read);
-        pub fn reader(self: anytype) Reader {
-            return .{
-                .context = @constCast(self),
-            };
-        }
-    };
-}
@@ -1,62 +1,8 @@
-const std = @import("std");
+pub const Archive = @import("archive.zig");
+pub const ExtractionOptions = @import("options.zig");

-pub const SfsReader = @import("reader.zig").SfsReader;
-pub const ExtractionOptions = @import("extract_options.zig");
+test {
+    const std = @import("std");

-pub const SfsFile = SfsReader(std.fs.File);
-
-const test_archive = "testing/LinuxPATest.sfs";
-
-test "OpenFile" {
-    const sfs_fil = try std.fs.cwd().openFile(test_archive, .{});
-    defer sfs_fil.close();
-    var rdr: SfsFile = try .init(std.testing.allocator, sfs_fil, 0);
-    defer rdr.deinit();
-    _ = try rdr.frag_table.get(rdr.super.frag_count - 1);
-    _ = try rdr.id_table.get(rdr.super.id_count - 1);
-    _ = try rdr.export_table.get(rdr.super.inode_count - 1);
-    std.debug.print("{}\n", .{rdr.super});
-    var root = try rdr.root();
-    defer root.deinit();
-    var iter = root.iterate();
-    while (true) {
-        var f = try iter.next();
-        if (f == null) break;
-        defer f.?.deinit();
-        std.debug.print("{s}\n", .{f.?.name});
-    }
-    std.debug.print("Finished OpenFile test\n", .{});
-}
-
-test "ExtractSingleFile" {
-    const single_file = "PortableApps/Notepad++Portable/App/Notepad++/doLocalConf.xml";
-    const single_file_extr_loc = "testing/doLocalConf.xml";
-
-    std.fs.cwd().deleteFile(single_file_extr_loc) catch {};
-    const sfs_fil = try std.fs.cwd().openFile(test_archive, .{});
-    defer sfs_fil.close();
-    var rdr: SfsFile = try .init(std.testing.allocator, sfs_fil, 0);
-    defer rdr.deinit();
-    var fil = try rdr.open(single_file);
-    defer fil.deinit();
-    var op: ExtractionOptions = try .init();
-    op.verbose = true;
-    try fil.extract(op, single_file_extr_loc);
-
-    std.debug.print("Finished ExtractSingleFile test\n", .{});
-}
-
-test "ExtractAll" {
-    const extr_dir = "testing/testExtract";
-
-    std.fs.cwd().deleteTree(extr_dir) catch {};
-    const sfs_fil = try std.fs.cwd().openFile(test_archive, .{});
-    defer sfs_fil.close();
-    var rdr: SfsFile = try .init(std.testing.allocator, sfs_fil, 0);
-    defer rdr.deinit();
-    const op: ExtractionOptions = try .init();
-    // op.verbose = true;
-    try rdr.extract(op, extr_dir);
-
-    std.debug.print("Finished ExtractAll test\n", .{});
+    std.testing.refAllDecls(Archive);
 }
@@ -1,79 +0,0 @@
-const std = @import("std");
-
-const InodeRef = @import("inode.zig").Ref;
-
-pub const Superblock = packed struct {
-    magic: u32,
-    inode_count: u32,
-    mod_time: u32,
-    block_size: u32,
-    frag_count: u32,
-    comp: Compression,
-    block_log: u16,
-    flags: packed struct {
-        _: u4,
-        id_uncomp: bool,
-        comp_options: bool,
-        no_xattr: bool,
-        xattr_uncomp: bool,
-        has_export: bool,
-        de_dupe: bool,
-        frag_always: bool,
-        no_frag: bool,
-        frag_uncomp: bool,
-        check: bool,
-        data_uncomp: bool,
-        inode_uncomp: bool,
-    },
-    id_count: u16,
-    ver_maj: u16,
-    ver_min: u16,
-    root_ref: InodeRef,
-    size: u64,
-    id_start: u64,
-    xattr_start: u64,
-    inode_start: u64,
-    dir_start: u64,
-    frag_start: u64,
-    export_start: u64,
-};
-
-pub const DecompressError = error{
-    LzoUnavailable,
-    Lz4Unavailable,
-};
-
-pub const Compression = enum(u16) {
-    gzip = 1,
-    lzma,
-    lzo,
-    xz,
-    lz4,
-    zstd,
-
-    pub fn decompress(self: Compression, comptime max_size: u32, alloc: std.mem.Allocator, source: anytype, dest: []u8) !usize {
-        switch (self) {
-            .gzip => {
-                var decomp = std.compress.zlib.decompressor(source);
-                return decomp.read(dest);
-            },
-            .lzma => {
-                var decomp = try std.compress.lzma.decompress(alloc, source);
-                defer decomp.deinit();
-                return decomp.read(dest);
-            },
-            .lzo => return DecompressError.LzoUnavailable,
-            .xz => {
-                var decomp = try std.compress.xz.decompress(alloc, source);
-                defer decomp.deinit();
-                return decomp.read(dest);
-            },
-            .lz4 => return DecompressError.Lz4Unavailable,
-            .zstd => {
-                var window: [max_size]u8 = undefined;
-                var decomp = std.compress.zstd.decompressor(source, .{ .window_buffer = &window });
-                return decomp.read(dest);
-            },
-        }
-    }
-};
@@ -1,75 +0,0 @@
-const std = @import("std");
-
-const PRead = @import("reader/p_read.zig").PRead;
-const Compression = @import("superblock.zig").Compression;
-const MetadataReader = @import("reader/metadata.zig").MetadataReader;
-
-pub const TableError = error{
-    InvalidIndex,
-};
-
-pub fn Table(comptime T: type, comptime R: type) type {
-    comptime std.debug.assert(std.meta.hasFn(R, "pread"));
-    return struct {
-        const Self = @This();
-
-        alloc: std.mem.Allocator,
-        rdr: PRead(R),
-        comp: Compression,
-
-        offset: u64,
-        table_count: u32,
-        mut: std.Thread.RwLock = .{},
-
-        table: []T = &[0]T{},
-
-        pub fn init(alloc: std.mem.Allocator, rdr: PRead(R), comp: Compression, offset: u64, table_count: u32) Self {
-            return .{
-                .alloc = alloc,
-                .rdr = rdr,
-                .comp = comp,
-                .offset = offset,
-                .table_count = table_count,
-            };
-        }
-        pub fn deinit(self: Self) void {
-            self.alloc.free(self.table);
-        }
-
-        fn resize(self: *Self, to_add: usize) !void {
-            if (!self.alloc.resize(self.table, self.table.len + to_add)) {
-                const new_table = try self.alloc.alloc(T, self.table.len + to_add);
-                @memcpy(new_table[0..self.table.len], self.table);
-                self.alloc.free(self.table);
-                self.table = new_table;
-            }
-        }
-
-        pub fn get(self: *Self, idx: u32) !T {
-            if (idx >= self.table_count) return TableError.InvalidIndex;
-            self.mut.lockShared();
-            defer self.mut.unlockShared();
-            if (idx >= self.table.len) {
-                return self.getAndFill(idx);
-            }
-            return self.table[idx];
-        }
-        fn getAndFill(self: *Self, idx: u32) !T {
-            self.mut.unlockShared();
-            defer self.mut.lockShared();
-            self.mut.lock();
-            defer self.mut.unlock();
-            var to_read: usize = 0;
-            var offset: u64 = 0;
-            while (idx >= self.table.len) {
-                to_read = @min(self.table_count - self.table.len, comptime 8192 / @sizeOf(T));
-                try self.resize(to_read);
-                _ = try self.rdr.pread(std.mem.asBytes(&offset), self.offset);
-                self.offset += 8;
-                var meta: MetadataReader(R) = .init(self.alloc, self.comp, self.rdr, offset);
-                _ = try meta.read(std.mem.sliceAsBytes(self.table[self.table.len - to_read ..]));
-            }
-            return self.table[idx];
-        }
-    };
-}
@@ -0,0 +1,84 @@
+const std = @import("std");
+const stuff = @import("builtin");
+
+const Archive = @import("archive.zig");
+const Superblock = @import("super.zig").Superblock;
+
+const TestArchive = "testing/LinuxPATest.sfs";
+
+test "Basics" {
+    var fil = try std.fs.cwd().openFile(TestArchive, .{});
+    defer fil.close();
+    var sfs: Archive = try .init(std.testing.allocator, fil);
+    defer sfs.deinit();
+    if (sfs.super != LinuxPATestCorrectSuperblock) {
+        std.debug.print("Superblock wrong\nShould be: {}\n\nis: {}\n", .{ LinuxPATestCorrectSuperblock, sfs.super });
+        return error.BadSuperblock;
+    }
+}
+
+const TestFile = "Start.exe";
+const TestFileExtractLocation = "testing/Start.exe";
+
+test "ExtractSingleFile" {
+    std.fs.cwd().deleteFile(TestFileExtractLocation) catch {};
+    var fil = try std.fs.cwd().openFile(TestArchive, .{});
+    defer fil.close();
+    var sfs: Archive = try .init(std.testing.allocator, fil);
+    defer sfs.deinit();
+    var test_fil = try sfs.open(TestFile);
+    defer test_fil.deinit();
+    try test_fil.extract(TestFileExtractLocation, .Default);
+    //TODO: validate extracted file.
+}
+
+const TestFullExtractLocation = "testing/TestExtract";
+
+test "ExtractCompleteArchive" {
+    std.fs.cwd().deleteTree(TestFullExtractLocation) catch {};
+    var fil = try std.fs.cwd().openFile(TestArchive, .{});
+    defer fil.close();
+    var sfs: Archive = try .init(std.testing.allocator, fil);
+    defer sfs.deinit();
+    try sfs.extract(TestFullExtractLocation, .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,
+};
@@ -0,0 +1,40 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+const flate = std.compress.flate;
+const zstd = std.compress.zstd;
+const xz = std.compress.xz;
+const lzma = std.compress.lzma;
+
+const Error = @import("decomp.zig").Error;
+
+pub fn zlibDecompress(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var buf: [flate.max_window_len]u8 = undefined;
+
+    var rdr: Reader = .fixed(in);
+    var decomp: flate.Decompress = .init(&rdr, .zlib, &buf);
+
+    return decomp.reader.readSliceShort(out);
+}
+pub fn zstdDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const buf = try alloc.alloc(u8, in.len + zstd.block_size_max);
+    defer alloc.free(buf);
+
+    var rdr: Reader = .fixed(in);
+    var decomp: zstd.Decompress = .init(&rdr, buf, .{ .window_len = in.len });
+
+    return decomp.reader.readSliceShort(out);
+}
+pub fn lzmaDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var rdr: Reader = .fixed(in);
+    var decomp: lzma.Decompress = .initOptions(&rdr, alloc, &[0]u8{}, .{}, 2 * out.len);
+    defer decomp.deinit();
+
+    return decomp.reader.readSliceShort(out);
+}
+pub fn xzDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var rdr: Reader = .fixed(in);
+    var decomp: xz.Decompress = .init(&rdr, alloc, &[0]u8{});
+    defer decomp.deinit();
+
+    return decomp.reader.readSliceShort(out);
+}
Author	SHA1	Message	Date
Caleb Gardner	c52fb15609	Finished (theoretically) file extraction.	2026-05-30 17:29:50 -05:00
Caleb Gardner	578911ba67	Work on extraction Created DataExtractor & DataReader Created Lookup tables	2026-05-30 06:22:26 -05:00
Caleb Gardner	56ad79ba94	Updated unsquashfs for zig 0.16.0 Fixed a couple bugs Added scaffold for extraction	2026-05-29 18:50:45 -05:00
Caleb Gardner	2cb0863cc1	A BUNCH OF STUFF Metadata reading Directory reading Decompile cache Actual SfsFile implementation Finished Inode implementation Actually build unsquashfs	2026-05-29 06:20:06 -05:00
Caleb Gardner	2c47c7492e	Reset for 0.16 (redux) Starting from scratch	2026-05-28 06:13:00 -05:00
Caleb J. Gardner	4b2b7021c7	Moved & organized decompression Fully implemented Decompressor vtable	2026-04-02 06:27:34 -05:00
Caleb J. Gardner	a1b9828578	Finished (?) decompression restructuring	2026-03-26 06:40:17 -05:00
Caleb J. Gardner	8e4661c4c6	Moving decompression to a vtable interface	2026-03-22 06:35:25 -05:00
Caleb J. Gardner	54aaf30ea5	Working on re-doing decompression	2026-03-21 02:13:36 -05:00
Caleb J. Gardner	df22cf6529	Started work on stateful decompression	2026-03-20 01:55:00 -05:00
Caleb J. Gardner	6b5c830234	Actually fix build	2026-03-18 06:17:07 -05:00
Caleb J. Gardner	116234cf9c	Fixed build	2026-03-18 06:15:52 -05:00
Caleb J. Gardner	4601e8f323	Updated build	2026-03-18 06:13:19 -05:00
Caleb J. Gardner	50cae8b63d	Use zig packed versions of zlib-ng, lz4, and zstd. Changed use_c_libs to use_zig_decomp so c libraries are now default	2026-03-18 05:24:58 -05:00
Caleb J. Gardner	8b8c9a772f	Added -Ddebug build option Re-added errors from settings xattr values	2026-03-09 00:16:19 -05:00
Caleb Gardner	f563648b20	Merge pull request #4 from CalebQ42/inode_finish Re-do much of extraction	2026-03-08 22:36:37 -05:00
Caleb Gardner	8d4f3d72f8	Merge branch 'main' into inode_finish	2026-03-08 22:34:50 -05:00
Caleb J. Gardner	0b6129f1ae	Switch to zlib-ng	2026-03-08 22:15:28 -05:00
Caleb J. Gardner	7308faad36	Moved kv free's in setMetadata	2026-03-05 12:54:25 -06:00
Caleb J. Gardner	c9499251f8	Moved lookup tables into separate struct to fix some race conditions Fixed lingering issues due to zero work size InodeFinish Fixed xattrs not applying due to the keys sometimes not being null-terminated. Updated performance numbers	2026-03-05 12:20:30 -06:00
Caleb J. Gardner	d470ca98e3	Added --force to unsquashfs Fixing race condition bugs (yay)	2026-03-05 07:04:24 -06:00
Caleb J. Gardner	a606f5e11a	Move extract logic to util/extract.zig to make it easier to read.	2026-03-05 03:03:37 -06:00
Caleb J. Gardner	a4e23a840d	Updated performance values in README. Added ability to ignore xattrs & permissions. Ignore setting xattr errors due to an unknown issues.	2026-03-05 03:03:34 -06:00
Caleb J. Gardner	3a10572953	Updated performance values in README. Added ability to ignore xattrs & permissions. Ignore setting xattr errors due to an unknown issues.	2026-03-04 13:28:29 -06:00
Caleb J. Gardner	edfe919c1b	Expirementation with a new way to finish threads. Currently not working.	2026-03-04 06:39:44 -06:00
Caleb J. Gardner	4515610082	Added xattr support (currently untested) Use stack fallback allocator on extraction for better performance.	2026-03-04 03:24:30 -06:00
Caleb J. Gardner	beca6a2ae6	Small tweaks	2026-03-01 02:27:54 -06:00
Caleb J. Gardner	760e11df0b	Fixed github workflow	2026-02-28 22:38:47 -06:00
Caleb J. Gardner	5f629df47c	alloc-ified many functions. Updated README	2026-02-28 22:33:57 -06:00
Caleb J. Gardner	b0160e005b	Some fixes	2026-02-17 05:54:32 -06:00
Caleb J. Gardner	b7b99325da	Slight improvement to how permissions are applied to folders unsquashfs Verbose flag	2026-02-13 01:35:20 -06:00
Caleb J. Gardner	b22e4d003d	Update times	2026-02-12 08:57:36 -06:00
Caleb J. Gardner	a41c37fef4	Updated unsquashfs version print out	2026-02-12 06:54:20 -06:00
Caleb J. Gardner	2d079d77f7	Exclusive file creation	2026-02-12 05:19:25 -06:00
Caleb J. Gardner	48f4235875	Fixed threads == 0 causing single threaded extraction. Set exclusive file creation	2026-02-12 05:08:16 -06:00
Caleb J. Gardner	567dea8a0b	Re-fix Action name	2026-02-12 04:28:32 -06:00
Caleb J. Gardner	f78e5c7386	Rever to previous Action	2026-02-12 04:27:06 -06:00
Caleb J. Gardner	81e975c0d9	Try doing upload in two separate steps	2026-02-12 04:22:20 -06:00
Caleb J. Gardner	fd274a8072	Different try to upload release files	2026-02-12 04:18:19 -06:00
Caleb J. Gardner	50ae79637e	Removed broken ZSTD error value	2026-02-12 04:06:18 -06:00
Caleb J. Gardner	ee41dc7278	Added import of zstd_errors.h	2026-02-12 03:58:08 -06:00
Caleb J. Gardner	c34acebf51	Only link lzo if allow_lzo	2026-02-12 03:46:36 -06:00
Caleb J. Gardner	bdbda29d39	Fixed wrong zig action line	2026-02-12 03:42:48 -06:00
Caleb J. Gardner	ca4e867ddc	Use setup zig Action	2026-02-12 03:39:05 -06:00
Caleb J. Gardner	b066835066	Update apt	2026-02-12 02:51:01 -06:00
Caleb J. Gardner	2363bd7d10	sudo apt Actions	2026-02-12 02:43:55 -06:00
Caleb J. Gardner	e619005b77	Fix action	2026-02-12 02:40:37 -06:00
Caleb J. Gardner	28b44891b3	Forgot Zig itself to the build	2026-02-12 02:32:34 -06:00
Caleb J. Gardner	4829c802a3	Clean version string	2026-02-12 02:32:06 -06:00
Caleb Gardner	570db9632a	GH Action to create a release when release tagged	2026-02-12 02:30:21 -06:00
Caleb J. Gardner	0076294675	Small fix to testing to check if libc is linked	2026-02-12 02:19:38 -06:00
Caleb J. Gardner	fd9e3d595b	A bit of README cleanup Added allow_lzo build option due to lzo build issues	2026-02-11 06:57:52 -06:00
Caleb J. Gardner	b8189490eb	Small change/fix when applying permissions	2026-02-09 13:50:56 -06:00
Caleb J. Gardner	6adc1d5c0c	Fixes for threaded extraction. Archive.extract now uses threaded extraction	2026-02-09 13:45:38 -06:00
Caleb J. Gardner	5ec12b5786	Finished adding multi-threaded extraction. Added option in unsquashfs to specify the number of threads used. Changed some functions to accept an allocator instead of just using Archive's Fixed run_tests.sh due to new c libraries	2026-02-08 15:14:35 -06:00
Caleb J. Gardner	b892adacd7	Some work for threaded extraction	2026-02-08 10:27:35 -06:00
Caleb J. Gardner	2760ad6ccb	Finished adding (untested) C decompression libraries.	2026-02-08 06:52:14 -06:00
Caleb J. Gardner	61311433b9	unsquashfs --help	2026-02-07 17:20:03 -06:00
Caleb J. Gardner	053d64a954	Some cleanup to build zon. Minor start on threaded extraction	2026-02-07 17:20:03 -06:00
Caleb Gardner	0e0222cd02	Fix formatting for build flags in README	2026-02-07 11:34:34 -06:00
Caleb Gardner	9c0dfbadc2	Merge pull request #2 from CalebQ42/extract_expirement Extract expirement	2026-02-07 11:31:51 -06:00
Caleb J. Gardner	db2fb4b9f2	Fixed compilation when using zig test. Remove option for static since -static should suffice in most situations	2026-02-07 11:24:58 -06:00
Caleb J. Gardner	067eaa87c2	You can now set when building to use c or zig libraries.	2026-02-07 10:58:32 -06:00
Caleb J. Gardner	b64a3ec44a	Archive.extract now directly uses Inode instead of File.	2026-02-07 06:57:55 -06:00
Caleb J. Gardner	704215e1a9	Remove updateTimes because I was running into integer overlow issues.	2026-02-07 06:42:34 -06:00
Caleb J. Gardner	bcfd983f8d	Fixed a handful of errors when extracting. Fixed issues with unsquashfs	2026-02-07 06:28:27 -06:00
Caleb J. Gardner	75502da1d0	Remove DecompMgr in favor of a much simpler fn ptr. Moved more functionality to Inode instead of File. Started doing some optimization around allocation. Slight rework of ExtractionOptions.	2026-02-07 05:09:17 -06:00
Caleb J. Gardner	a316ba569f	Renamed File.dev to File.devNum	2026-02-06 23:22:21 -06:00
Caleb J. Gardner	a0f3f45885	Unsquashfs	2026-02-06 09:51:27 -06:00
Caleb J. Gardner	f771ef7623	Work on extraction	2026-02-06 06:56:28 -06:00
Caleb J. Gardner	0d2576f5ee	Fixed tables getting re-created	2026-01-31 06:39:41 -06:00
Caleb J. Gardner	a76803aad1	Comments!	2026-01-31 05:14:00 -06:00
Caleb J. Gardner	1ff1e91d5e	Added ExtractCompleteArchive test	2026-01-29 22:23:46 -06:00
Caleb J. Gardner	2bcbc16613	Extraction Finished-ish	2026-01-29 06:46:52 -06:00
Caleb J. Gardner	3c98cf2cdb	EXTRACTION	2026-01-28 11:19:38 -06:00
Caleb J. Gardner	2c392cf250	Fixed a few bugs preventing basic functions Worked on extraction, including creating DataReader Added proper access to id, fragment, and export tables	2026-01-28 06:55:01 -06:00
Caleb J. Gardner	5d4e7b1435	Fixed things	2026-01-25 07:06:30 -06:00
Caleb J. Gardner	7aed59b5b1	Some fixes	2026-01-17 05:30:19 -06:00
Caleb J. Gardner	f3fb8a128f	Inodes! ExtractionOptions! Files! Directories!	2026-01-16 06:53:10 -06:00
Caleb J. Gardner	23bb19644b	Finished (?) decompression, metadata reader, and Table.	2026-01-15 11:22:02 -06:00
Caleb J. Gardner	ed14f13d9a	Some work on tests & metadata	2026-01-15 06:56:43 -06:00
Caleb J. Gardner	428f938c3a	Restart (once again)	2026-01-15 06:40:59 -06:00