Basic extraction complete

Reset 4

.github/workflows/release-build.yml

@@ -1,31 +0,0 @@
-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

.gitignore

@@ -2,4 +2,3 @@ testing/
 
 .zig-cache/
 zig-out/
-zig-pkg/

.zed/debug.json

@@ -1,25 +0,0 @@
-// 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",
-		],
-	},
-]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Caleb Gardner
+Copyright (c) 2025 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

README.md

@@ -1,77 +1,7 @@
 # zig-squashfs
 
-This is my experiments to learn Zig. Might amount to something. Might not.
+Messing around with zig via making a squashfs library. May amount to something. Or not.
 
-A library and application to decompress or view squashfs archives.
+## Current state
 
-## Current State
+Performance is reatively bad (when compared to the official [squashfs-tools](https://github.com/plougher/squashfs-tools), but the basics should fully work.
-
-Overall works, but currently is missing some features ([see below](#capabilities)) and has significantly slow performance compared to `unsquashfs` ([see below](#performance)).
-
-Currently things are still in flux after Zig 0.16's Io changes and the documentation below *might* not be up to date.
-
-## 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 `-Doptimize=ReleaseFast`.
-
-Currently, my only performance checks are checking execution time, nothing deeper.
-
-* Currently, using my test archive, performance matches `unsquashfs`.
-* Using Zig decompression libraries *significantly* increases decompression time by 5x. 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*: CURRENTLY UNTESTED
-* *C-libs, multi-threaded*: .16s
-* *Zig-libs, single-threaded*: CURRENTLY UNTESTED
-* *Zig-libs, multi-threaded*: .76s
-
-## 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;
-```

benchmark.sh

@@ -1,8 +0,0 @@
-#! /usr/bin/env bash
-
-ARCHIVE="testing/LinuxPATest.sfs"
-
-REF_EXT_LOC="testing/LinuxPAReference"
-PROG_EXT_LOC="testing/LinuxPABinTest"
-
-hyperfine --warmup 5 --prepare "rm -rf $REF_EXT_LOC && rm -rf $PROG_EXT_LOC" "unsquashfs -d $REF_EXT_LOC $ARCHIVE" "zig-out/bin/unsquashfs -d $PROG_EXT_LOC $ARCHIVE"

build.zig

@@ -1,111 +1,53 @@
 const std = @import("std");
 
+/// version if version isn't provided during build
+const def_version = "0.0.0+testing";
+
 pub fn build(b: *std.Build) !void {
-    const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
+    const opt = b.addOptions();
-    const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo support") orelse false;
+    const ver = b.option([]const u8, "version", "sematic version") orelse def_version;
-    var debug = b.option(bool, "debug", "Enable options to make debugging easier.");
+    const sem_ver = try std.SemanticVersion.parse(ver);
-    const version_string_option = b.option([]const u8, "version", "Version of the library/binary");
+    opt.addOption(std.SemanticVersion, "version", sem_ver);
-
-    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 target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
-
+    const lib_mod = b.createModule(.{
-    if (optimize == .Debug) debug = true;
+        .root_source_file = b.path("src/root.zig"),
-
-    const c = b.addTranslateC(.{
-        .optimize = optimize,
         .target = target,
-        .root_source_file = b.path("src/c.h"),
+        .optimize = optimize,
     });
-
     const lib = b.addLibrary(.{
-        .name = "squashfs",
+        .linkage = .static,
-        .root_module = b.createModule(.{
+        .name = "zig_squashfs",
-            .optimize = if (debug == true) .Debug else optimize,
+        .root_module = lib_mod,
-            .target = target,
+        .version = sem_ver,
-            .valgrind = debug,
-            .root_source_file = b.path("src/root.zig"),
-            // .link_libc = true,
-            .imports = &.{
-                .{ .name = "options", .module = zig_squashfs_options.createModule() },
-                .{ .name = "c", .module = c.createModule() },
-            },
-        }),
-        .use_llvm = debug,
     });
 
-    const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
+    const exe_mod = b.createModule(.{
-    lib.root_module.linkLibrary(zstd.artifact("zstd"));
+        .root_source_file = b.path("src/bin/unsquashfs.zig"),
-
+        .target = target,
-    const zng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
+        .optimize = optimize,
-    lib.root_module.linkLibrary(zng.artifact("zng"));
+    });
-
+    exe_mod.addImport("squashfs", lib_mod);
-    const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
+    exe_mod.addOptions("config", opt);
-    lib.root_module.linkLibrary(xz.artifact("lzma"));
-
-    const minilzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
-    lib.root_module.linkLibrary(minilzo.artifact("minilzo"));
-
-    const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
-    lib.root_module.linkLibrary(lz4.artifact("lz4"));
-
-    var version = version_string_option orelse "0.0.0-testing";
-    if (version[0] == 'v') version = version[1..];
-    const unsquashfs_options = b.addOptions();
-    unsquashfs_options.addOption(
-        std.SemanticVersion,
-        "version",
-        try std.SemanticVersion.parse(version),
-    );
     const exe = b.addExecutable(.{
+        .linkage = .static,
         .name = "unsquashfs",
-        .root_module = b.createModule(.{
+        .root_module = exe_mod,
-            .optimize = if (debug == true) .Debug else optimize,
+        .version = sem_ver,
-            .target = target,
-            .valgrind = debug,
-            .root_source_file = b.path("src/bin/unsquashfs.zig"),
-            .imports = &.{
-                .{ .name = "zig_squashfs", .module = lib.root_module },
-            },
-        }),
-        .use_llvm = debug,
     });
-    exe.root_module.addOptions("config", unsquashfs_options);
 
     b.installArtifact(lib);
     b.installArtifact(exe);
 
-    const mod_tests = b.addTest(.{
+    const lib_unit_tests = b.addTest(.{
-        .root_module = b.createModule(.{
+        .root_module = lib_mod,
-            .optimize = .Debug,
-            .target = target,
-            .root_source_file = b.path("src/test.zig"),
-            .imports = &.{
-                .{ .name = "c", .module = c.createModule() },
-            },
-            .valgrind = true,
-        }),
-        .use_llvm = true,
     });
-    mod_tests.root_module.linkLibrary(zstd.artifact("zstd"));
+    const exe_unit_test = b.addTest(.{
-
+        .root_module = exe_mod,
-    const run_mod_tests = b.addRunArtifact(mod_tests);
-    const test_step = b.step("test", "Run tests");
-    test_step.dependOn(&run_mod_tests.step);
-
-    // zls build check steps
-    const lib_check = b.addLibrary(.{
-        .name = "squashfs",
-        .root_module = exe.root_module,
     });
-    const exe_check = b.addExecutable(.{
+    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
-        .name = "unsquashfs",
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_test);
-        .root_module = lib.root_module,
+    const test_step = b.step("test", "Run unit tests");
-    });
+    test_step.dependOn(&run_lib_unit_tests.step);
-    const check = b.step("check", "Check if unsquashfs compiles");
+    test_step.dependOn(&run_exe_unit_tests.step);
-    check.dependOn(&lib_check.step);
-    check.dependOn(&exe_check.step);
 }

build.zig.zon

@@ -1,30 +1,55 @@
 .{
-    .name = .squashfs,
+    .name = .zig_squashfs,
-    .version = "0.0.6",
+    .version = "0.0.1",
-    .fingerprint = 0x37ba29474b87f145, // Changing this has security and trust implications.
+    .fingerprint = 0x527960c72c03ffe3, // Changing this has security and trust implications.
-    .minimum_zig_version = "0.15.2",
+
+    .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.
     .dependencies = .{
-        .zlib_ng = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
-            .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
+        //.example = .{
-            .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
+        //    // 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
-        .zstd = .{
+        //    // the new URL. If the contents of a URL change this will result in a hash mismatch
-            .url = "git+https://github.com/allyourcodebase/zstd.git?ref=1.5.7-1#e1a501be57f42c541e8a5597e4b59a074dfd09a3",
+        //    // which will prevent zig from using it.
-            .hash = "zstd-1.5.7-1-KEItkAMwAAD6OKY3m0OOmXG7aL-aLUfrDqbP5J5oYapU",
+        //    .url = "https://example.com/foo.tar.gz",
-        },
+        //
-        .lz4 = .{
+        //    // This is computed from the file contents of the directory of files that is
-            .url = "git+https://github.com/allyourcodebase/lz4.git?ref=1.10.0-6#41f52ab227caf9d48cf88c89a4d2946caa12b102",
+        //    // obtained after fetching `url` and applying the inclusion rules given by
-            .hash = "lz4-1.10.0-6-ewyzw-4NAAAWDpY4xpiqr4LQhZQAC0x_rGnW2iPh6jk2",
+        //    // `paths`.
-        },
+        //    //
-        .minilzo = .{
+        //    // This field is the source of truth; packages do not come from a `url`; they
-            .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
-            .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
+        //    // obtain a package matching this `hash`.
-        },
+        //    //
-        .xz = .{
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
-            .url = "git+https://github.com/akunaakwei/zig-xz.git#e2d389262c8291907e3e4c6fb119819141c16c0f",
+        //    .hash = "...",
-            .hash = "xz-5.8.2-6v47_JYeAABSL-jonprpL5-E_YaaGc4B5xrbe93WsJ3G",
+        //
-        },
+        //    // 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,
+        //},
     },
+
+    // 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",

src/archive.zig

@@ -1,171 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const Decomp = @import("decomp.zig");
-const ExtractionOptions = @import("options.zig");
-const File = @import("file.zig");
-const Inode = @import("inode.zig");
-const LookupTable = @import("lookup_table.zig");
-const Decompressor = @import("util/decompressor.zig");
-const MetadataReader = @import("util/metadata.zig");
-const Utils = @import("util/misc.zig");
-const OffsetFile = @import("util/offset_file.zig");
-
-const Archive = @This();
-
-file: OffsetFile,
-super: Superblock,
-
-stateless_decomp: *const Decompressor,
-
-pub fn init(io: Io, file: std.Io.File, offset: u64) !Archive {
-    var rdr = file.reader(io, &[0]u8{});
-    try rdr.seekTo(offset);
-    var super: Superblock = undefined;
-    try rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
-
-    return .{
-        .file = try .init(io, file, super.size, offset),
-        .super = super,
-
-        .stateless_decomp = try Decomp.StatelessDecomp(super.compression),
-    };
-}
-pub fn deinit(self: Archive, io: Io) void {
-    self.file.deinit(io);
-}
-
-/// The root folder of the Archive. Used to open other Files.
-pub fn root(self: Archive, alloc: std.mem.Allocator, io: Io) !File {
-    const root_inode = try Utils.inodeFromRef(
-        alloc,
-        io,
-        self.file,
-        self.stateless_decomp,
-        self.super.inode_start,
-        self.super.block_size,
-        self.super.root_ref,
-    );
-    return .init(alloc, self, root_inode, "");
-}
-/// Opens a File within the archive.
-pub fn open(self: Archive, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
-    const root_file = try self.root(alloc, io);
-    const path = std.mem.trim(u8, filepath, "/");
-    if (Utils.pathIsSelf(path))
-        return root_file;
-    defer root_file.deinit();
-    return root_file.open(alloc, io, filepath);
-}
-
-/// Returns the inode with the given inode number.
-/// Requires that the archive is exportable (has an export lookup table).
-pub fn inode(self: Archive, alloc: std.mem.Allocator, io: Io, num: u32) !Inode {
-    if (!self.super.flags.exportable)
-        return error.NotExportable;
-    const ref = try LookupTable.lookupValue(
-        Inode.Ref,
-        alloc,
-        io,
-        &self.stateless_decomp,
-        self.file,
-        self.super.export_start,
-        num + 1,
-    );
-    return Utils.inodeFromRef(
-        alloc,
-        io,
-        self.file,
-        &self.stateless_decomp,
-        self.super.inode_start,
-        self.super.block_size,
-        ref,
-    );
-}
-/// Returns a value at the given index from the Archive's id (uid/gid) table.
-pub fn idTable(self: Archive, alloc: std.mem.Allocator, io: Io, idx: u32) !u16 {
-    return LookupTable.lookupValue(
-        u16,
-        alloc,
-        io,
-        &self.stateless_decomp,
-        self.file,
-        self.super.id_start,
-        idx,
-    );
-}
-
-// Superblock
-
-const SQUASHFS_MAGIC: u32 = std.mem.readInt(u32, "hsqs", .little);
-
-const SuperblockError = error{
-    InvalidMagic,
-    InvalidBlockLog,
-    InvalidVersion,
-    InvalidCheck,
-};
-
-/// A squashfs Superblock
-pub const Superblock = extern struct {
-    magic: u32,
-    inode_count: u32,
-    mod_time: u32,
-    block_size: u32,
-    frag_count: u32,
-    compression: Decomp.Enum,
-    block_log: u16,
-    flags: packed struct(u16) {
-        inode_uncompressed: bool,
-        data_uncompressed: bool,
-        check: bool,
-        frag_uncompressed: bool,
-        fragment_never: bool,
-        fragment_always: bool,
-        duplicates: bool,
-        exportable: bool,
-        xattr_uncompressed: bool,
-        xattr_never: bool,
-        compression_options: bool,
-        ids_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,
-
-    /// Validate the Superblock. If an error is returned, it's likely the archive is corrupted or not a squashfs archive.
-    pub fn validate(self: Superblock) !void {
-        if (self.magic != SQUASHFS_MAGIC)
-            return SuperblockError.InvalidMagic;
-        if (self.flags.check)
-            return SuperblockError.InvalidCheck;
-        if (self.ver_maj != 4 or self.ver_min != 0)
-            return SuperblockError.InvalidVersion;
-        if (std.math.log2(self.block_size) != self.block_log)
-            return SuperblockError.InvalidBlockLog;
-    }
-};
-
-// Extraction
-
-/// Extract the entire archive contents to the given directory.
-pub fn extract(self: Archive, alloc: std.mem.Allocator, io: Io, extract_dir: []const u8, options: ExtractionOptions) !void {
-    const root_inode = try Utils.inodeFromRef(
-        alloc,
-        self.file,
-        self.stateless_decomp,
-        self.super.inode_start,
-        self.super.block_size,
-        self.super.root_ref,
-    );
-    return root_inode.extract(alloc, io, self.file, self.super, extract_dir, options);
-}

src/bin/unsquashfs.zig

@@ -1,139 +1,146 @@
 const std = @import("std");
-const Io = std.Io;
-const Writer = Io.Writer;
-const builtin = @import("builtin");
-
 const config = @import("config");
-const squashfs = @import("zig_squashfs");
+const squashfs = @import("squashfs");
 
-//TODO: Add more options
+const help_msg =
-const help_mgs =
+    \\Basic Usage: zig-unsquashfs [Options] SQUASHFS_FILE <EXTRACT_LOCATION>
     \\
-    \\Usage: unsquashfs [options] <archive>
+    \\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.
     \\
-    \\Options:
+    \\Extraction options:
-    \\  -d <location>   Extract to the given location instead of "squashfs-root"
+    \\  --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.
     \\
-    \\  -o <offset>     Start reading the archive at the given offset.
+    \\Listing Options:
-    \\  -dx             Don't set xattr values
+    \\  -l                  List files instead of extracting. When used, you do not need to specify an extraction location.
-    \\  -dp             Don't set permissions (includes setting uid & gid owner)
+    \\  -ll                 Similiar to -l, but with file attributes.
+    \\  -lln                Similiar to -ll, but with numeric uids and gids.
     \\
-    \\  -p <threads>    Specify how many threads to use. If not present or zero, the system's logical cores count is used.
+    \\Other:
-    \\  -v              Verbose
+    \\  --help              Prints this help message.
-    \\
+    \\  -h                  Same as --help
-    \\  --force         Force extraction. If the destination already exists, it will be deleted.
+    \\  --version           Print version number.
-    \\
-    \\  --help          Display this messages
-    \\  --version       Display the version
     \\
 ;
 
-const errors = error{InvalidArguments};
+const stdout = std.io.getStdOut();
 
-var archive: []const u8 = "";
+var extr_files: std.ArrayList([]const u8) = undefined;
-var extLoc: []const u8 = "squashfs-root";
 var offset: u64 = 0;
-var threads: u32 = 0;
 var verbose: bool = false;
-var ignore_xattrs: bool = false;
+var unbreak: bool = false;
-var ignore_permissions: bool = false;
+var deref: bool = false;
-var force: bool = false;
+var processors: u16 = 0;
+var list: ListTypes = .None;
 
-pub fn main(init: std.process.Init) !void {
+var filename: []const u8 = "";
-    const alloc = init.gpa;
+var extr_location: []const u8 = "";
-    const io = init.io;
 
-    var stdout = std.Io.File.stdout();
+const ListTypes = enum {
-    defer stdout.close(io);
+    None,
-    var out = stdout.writer(io, &[0]u8{});
+    List,
-    defer out.interface.flush() catch {};
+    ListAttr,
+    ListNumeric,
+};
 
-    try handleArgs(init.minimal.args, &out.interface);
+pub fn main() !void {
-    if (archive.len == 0) {
+    const alloc = std.heap.smp_allocator;
-        try out.interface.print("You must provide a squashfs archive\n", .{});
+    extr_files = .init(alloc);
-        try out.interface.print(help_mgs, .{});
+    defer extr_files.deinit();
+    var args = std.process.argsWithAllocator(alloc) catch {
+        _ = try stdout.writeAll("Unable to allocate memory");
         return;
-    }
-
-    var fil = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
-    defer fil.close(io);
-
-    var arc: squashfs.Archive = try .init(io, fil, offset); //TODO: Handle error gracefully.
-    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();
-    if (force)
+    _ = args.next();
-        try Io.Dir.cwd().deleteTree(io, extLoc);
+    while (args.next()) |arg| {
-    try arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
+        if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
-}
+            _ = try stdout.writeAll(help_msg);
-
+            return;
-fn handleArgs(args: std.process.Args, out: *Writer) !void {
+        } else if (std.mem.eql(u8, arg, "--version")) {
-    var arg_iter = args.iterate();
+            try config.version.format("", .{}, stdout.writer());
-    defer arg_iter.deinit();
+            _ = try stdout.write("\n");
-    _ = arg_iter.next(); // args[0] is the application launch command.
+            return;
-    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;
-            continue;
+        } else if (std.mem.eql(u8, arg, "--unbreak-symlinks") or std.mem.eql(u8, arg, "-us")) {
-        } else if (std.mem.eql(u8, arg, "-dx")) {
+            unbreak = true;
-            ignore_xattrs = true;
+        } else if (std.mem.eql(u8, arg, "--deref-symlinks") or std.mem.eql(u8, arg, "-ds")) {
-            continue;
+            deref = true;
-        } else if (std.mem.eql(u8, arg, "-dp")) {
+        } else if (std.mem.eql(u8, arg, "-l")) {
-            ignore_permissions = true;
+            list = .List;
-            continue;
+        } else if (std.mem.eql(u8, arg, "-ll")) {
-        } else if (std.mem.eql(u8, arg, "--force")) {
+            list = .ListAttr;
-            force = true;
+        } else if (std.mem.eql(u8, arg, "-lln")) {
-            continue;
+            list = .ListNumeric;
-        } else if (std.mem.eql(u8, arg, "--version")) {
+        } else if (std.mem.eql(u8, arg, "-e")) {
-            try out.print("zig-unsquashfs v", .{});
+            const next = args.next();
-            try config.version.format(out);
+            if (next == null) {
-            try out.print("\nBuilt using Zig {s} in {} mode\n", .{ builtin.zig_version_string, builtin.mode });
+                _ = try stdout.writeAll("path required after -e\n");
-            std.process.exit(0);
+                return;
-            return;
+            }
-        } else if (std.mem.eql(u8, arg, "--help")) {
+            try extr_files.append(next.?);
-            try out.print(help_mgs, .{});
+        } else if (std.mem.eql(u8, arg, "-o")) {
-            std.process.exit(0);
+            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");
             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;
+    };
 }

src/c.h

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

src/decomp.zig

@@ -1,76 +0,0 @@
-const std = @import("std");
-
-const options = @import("options");
-
-const lzma = @import("decomp/zig_lzma.zig");
-const xz = @import("decomp/zig_xz.zig");
-const Decompressor = @import("util/decompressor.zig");
-
-const zlib = if (options.use_zig_decomp) @import("decomp/zig_zlib.zig") else @import("decomp/c_zlib.zig");
-const lzo = if (options.use_zig_decomp or !options.allow_lzo) void else @import("decomp/c_lzo.zig");
-const lz4 = if (options.use_zig_decomp) void else @import("decomp/c_lz4.zig");
-const zstd = if (options.use_zig_decomp) @import("decomp/zig_zstd.zig") else @import("decomp/c_zstd.zig");
-
-pub const Enum = enum(u16) {
-    gzip = 1,
-    lzma,
-    lzo,
-    xz,
-    lz4,
-    zstd,
-};
-
-pub fn StatelessDecomp(val: Enum) !*const Decompressor {
-    return switch (val) {
-        .gzip => &zlib.stateless_decompressor,
-        .lzma => &lzma.stateless_decompressor,
-        .lzo => if (options.use_zig_decomp or !options.allow_lzo)
-            error.LzoUnsupported
-        else
-            &lzo.stateless_decompressor,
-        .xz => &xz.stateless_decompressor,
-        .lz4 => if (options.use_zig_decomp)
-            error.Lz4Unsupported
-        else
-            &lz4.stateless_decompressor,
-        .zstd => &zstd.stateless_decompressor,
-    };
-}
-
-pub const Decomp = union(enum) {
-    gzip: zlib,
-    lzma: lzma,
-    lzo: lzo,
-    xz: xz,
-    lz4: lz4,
-    zstd: zstd,
-
-    pub fn init(val: Enum, alloc: std.mem.Allocator, io: std.Io, block_size: u32) !Decomp {
-        return switch (val) {
-            .gzip => .{ .gzip = zlib.init(alloc, io, block_size) },
-            .lzma => .{ .lzma = .{} },
-            .lzo => .{ .lzo = .{} },
-            .xz => .{ .xz = .{} },
-            .lz4 => .{ .lz4 = .{} },
-            .zstd => .{ .zstd = zstd.init(alloc, io, block_size) },
-        };
-    }
-    pub fn deinit(self: *Decomp) void {
-        switch (self.*) {
-            .gzip => self.gzip.deinit(),
-            .zstd => self.zstd.deinit(),
-            else => {},
-        }
-    }
-
-    pub fn decompressor(self: *Decomp) *const Decompressor {
-        return switch (self.*) {
-            .gzip => &self.gzip.interface,
-            .lzma => &lzma.stateless_decompressor,
-            .lzo => &lzo.stateless_decompressor,
-            .xz => &xz.stateless_decompressor,
-            .lz4 => &lz4.stateless_decompressor,
-            .zstd => &self.zstd.interface,
-        };
-    }
-};

src/decomp/c_lz4.zig

@@ -1,25 +0,0 @@
-const std = @import("std");
-
-const c = @import("c");
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const res = c.LZ4_decompress_fast(in.ptr, out.ptr, @truncate(out.len));
-    if (res < 0) return Error.ReadFailed;
-    return @abs(res);
-}
-
-// lzma_allocator
-
-fn lzmaAlloc(ptr: ?*anyopaque, size: usize, _: usize) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    return alloc.rawAlloc(size, .@"1", 0);
-}
-fn lzmaFree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    alloc.rawFree(@ptrCast(mem_ptr), .@"1", 0);
-}

src/decomp/c_lzma.zig

@@ -1,48 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
-
-const c = @import("c");
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = std.Io.Queue(c.lzma_stream);
-
-const Self = @This();
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var stream: c.lzma_stream = .{
-        .allocator = &.{
-            .alloc = lzmaAlloc,
-            .free = lzmaFree,
-            .@"opaque" = @constCast(&alloc),
-        },
-        .next_in = in.ptr,
-        .avail_in = in.len,
-        .next_out = out.ptr,
-        .avail_out = out.len,
-    };
-
-    var res = c.lzma_alone_decoder(&stream, stream.avail_out * 2);
-    if (res != c.LZMA_OK) return Error.ReadFailed;
-    while (res == c.LZMA_OK)
-        res = c.lzma_code(&stream, c.LZMA_RUN);
-    if (res != c.LZMA_FINISH) return Error.ReadFailed;
-    return stream.total_out;
-}
-
-// lzma_allocator
-
-fn lzmaAlloc(ptr: ?*anyopaque, size: usize, _: usize) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    return alloc.rawAlloc(size, .@"1", 0);
-}
-fn lzmaFree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    alloc.rawFree(@ptrCast(mem_ptr), .@"1", 0);
-}

src/decomp/c_lzo.zig

@@ -1,35 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
-
-const c = @import("c");
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = std.Io.Queue(c.lzma_stream);
-
-const Self = @This();
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    _ = c.lzo_init();
-    var out_len = out.len;
-    const res = c.lzo1x_decompress_safe(in.ptr, in.len, out.ptr, &out_len, null);
-    if (res != c.LZO_E_OK) return Error.ReadFailed;
-    return out_len;
-}
-
-// lzma_allocator
-
-fn lzmaAlloc(ptr: ?*anyopaque, size: usize, _: usize) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    return alloc.rawAlloc(size, .@"1", 0);
-}
-fn lzmaFree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    alloc.rawFree(@ptrCast(mem_ptr), .@"1", 0);
-}

src/decomp/c_xz.zig

@@ -1,48 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
-
-const c = @import("c");
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = std.Io.Queue(c.lzma_stream);
-
-const Self = @This();
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var stream: c.lzma_stream = .{
-        .allocator = &.{
-            .alloc = lzmaAlloc,
-            .free = lzmaFree,
-            .@"opaque" = @constCast(&alloc),
-        },
-        .next_in = in.ptr,
-        .avail_in = in.len,
-        .next_out = out.ptr,
-        .avail_out = out.len,
-    };
-
-    var res = c.lzma_alone_decoder(&stream, stream.avail_out * 2);
-    if (res != c.LZMA_OK) return Error.ReadFailed;
-    while (res == c.LZMA_OK)
-        res = c.lzma_code(&stream, c.LZMA_RUN);
-    if (res != c.LZMA_FINISH) return Error.ReadFailed;
-    return stream.total_out;
-}
-
-// lzma_allocator
-
-fn lzmaAlloc(ptr: ?*anyopaque, size: usize, _: usize) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    return alloc.rawAlloc(size, .@"1", 0);
-}
-fn lzmaFree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(@constCast(ptr)));
-    alloc.rawFree(@ptrCast(mem_ptr), .@"1", 0);
-}

src/decomp/c_zlib.zig

@@ -1,98 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
-
-const c = @import("c");
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = std.Io.Queue(c.zng_stream);
-
-const Self = @This();
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-io: Io,
-
-ctx: []c.zng_stream,
-ctx_queue: Queue,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
-    const buf = try alloc.alloc(c.zng_stream, 20); // TODO: Choose a better number instead of a random one.
-    var queue: Queue = .init(buf);
-    for (0..20) |_|
-        try queue.putOne(io, .{
-            .zalloc = zalloc,
-            .zfree = zfree,
-        });
-
-    return .{
-        .alloc = alloc,
-        .io = io,
-
-        .block_size = block_size,
-        .ctx = buf,
-        .ctx_queue = queue,
-    };
-}
-pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
-    self.ctx_queue.close(self.io);
-    alloc.free(self.ctx);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        return statelessDecomp(d, alloc, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-
-    var stream = self.ctx_queue.getOne(self.io) catch return Error.ReadFailed;
-    defer self.ctx_queue.putOne(self.io, stream) catch {};
-
-    stream.@"opaque" = @constCast(&alloc);
-    stream.next_in = in.ptr;
-    stream.avail_in = @truncate(in.len);
-    stream.next_out = out.ptr;
-    stream.avail_out = @truncate(out.len);
-
-    try zlibDecomp(&stream, in, out);
-
-    return stream.total_out;
-}
-
-inline fn zlibDecomp(stream: *c.zng_stream) !void {
-    _ = c.zng_inflateReset(stream);
-
-    const res = c.zng_inflate(stream, c.Z_FULL_FLUSH);
-    if (res != c.Z_OK) return Error.ReadFailed;
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var stream: c.zng_stream = .{
-        .@"opaque" = @constCast(&alloc),
-        .next_in = in.ptr,
-        .avail_in = @truncate(in.len),
-        .next_out = out.ptr,
-        .avail_out = @truncate(out.len),
-    };
-    try zlibDecomp(&stream);
-    return stream.total_out;
-}
-
-// zalloc
-
-fn zalloc(ptr: ?*anyopaque, size: c_uint, len: c_uint) callconv(.c) ?*anyopaque {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
-    return alloc.rawAlloc(size * len, .@"1", 0);
-}
-fn zfree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
-    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
-    alloc.rawFree(@ptrCast(mem_ptr), .@"1", 0);
-}

src/decomp/c_zstd.zig

@@ -1,71 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
-
-const c = @import("c");
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = std.Io.Queue(?*c.ZSTD_DCtx);
-
-const Self = @This();
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-io: Io,
-
-ctx: []?*c.ZSTD_DCtx,
-ctx_queue: Queue,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
-    const buf = try alloc.alloc(?*c.ZSTD_DCtx, 20); // TODO: Choose a better number instead of a random one.
-    var queue: Queue = .init(buf);
-    for (0..20) |_|
-        try queue.putOne(io, c.ZSTD_createDCtx());
-
-    return .{
-        .alloc = alloc,
-        .io = io,
-
-        .block_size = block_size,
-        .ctx = buf,
-        .ctx_queue = queue,
-    };
-}
-pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
-    self.ctx_queue.close(self.io);
-    for (self.ctx) |ctx|
-        c.ZSTD_freeDCtx(ctx);
-    alloc.free(self.ctx);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        return statelessDecomp(d, alloc, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-
-    const ctx = self.ctx_queue.getOne(self.io) catch return Error.ReadFailed;
-    defer self.ctx_queue.putOne(self.io, ctx) catch {};
-
-    _ = c.ZSTD_DCtx_reset(ctx, c.ZSTD_reset_session_only);
-
-    const res = c.ZSTD_decompressDCtx(ctx, out.ptr, out.len, in.ptr, in.len);
-    if (c.ZSTD_isError(res) != 0)
-        return Error.ReadFailed;
-    return res;
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, _: 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;
-}

src/decomp/zig_lzma.zig

@@ -1,81 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const lzma = std.compress.lzma;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = Io.Queue([]u8);
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-io: Io,
-
-block_size: u32,
-buf: [][]u8,
-buf_queue: Queue,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
-    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
-    var queue: Queue = .init(buf);
-    for (0..20) |_|
-        try queue.putOne(io, try alloc.alloc(u8, block_size));
-
-    return .{
-        .alloc = alloc,
-        .io = io,
-
-        .block_size = block_size,
-        .buf = buf,
-        .buf_queue = queue,
-    };
-}
-pub fn deinit(self: *Self) void {
-    self.buf_queue.close(self.io);
-    for (self.buf) |buf|
-        self.alloc.free(buf);
-    self.alloc.free(self.buf);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        return statelessDecomp(d, alloc, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-
-    var buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
-    defer self.buf_queue.putOne(self.io, buf) catch {};
-
-    return lzmaDecomp(self.alloc, &buf, in, out) catch return Error.ReadFailed;
-}
-
-inline fn lzmaDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = try lzma.Decompress.initOptions(&rdr, alloc, buffer.*, .{}, in.len * 2);
-    defer {
-        buffer.* = d.takeBuffer();
-        d.deinit();
-    }
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-    return lzmaDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-}

src/decomp/zig_xz.zig

@@ -1,81 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const xz = std.compress.xz;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = Io.Queue([]u8);
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-io: Io,
-
-block_size: u32,
-buf: [][]u8,
-buf_queue: Queue,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
-    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
-    var queue: Queue = .init(buf);
-    for (0..20) |_|
-        try queue.putOne(io, try alloc.alloc(u8, block_size));
-
-    return .{
-        .alloc = alloc,
-        .io = io,
-
-        .block_size = block_size,
-        .buf = buf,
-        .buf_queue = queue,
-    };
-}
-pub fn deinit(self: *Self) void {
-    self.buf_queue.close(self.io);
-    for (self.buf) |buf|
-        self.alloc.free(buf);
-    self.alloc.free(self.buf);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        return statelessDecomp(d, alloc, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-
-    var buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
-    defer self.buf_queue.putOne(self.io, buf) catch {};
-
-    return xzDecomp(self.alloc, &buf, in, out) catch return Error.ReadFailed;
-}
-
-inline fn xzDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = try xz.Decompress.init(&rdr, alloc, buffer.*);
-    defer {
-        buffer.* = d.takeBuffer();
-        d.deinit();
-    }
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-    return xzDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-}

src/decomp/zig_zlib.zig

@@ -1,77 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const flate = std.compress.flate;
-const Node = std.SinglyLinkedList.Node;
-const Reader = Io.Reader;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = Io.Queue([]u8);
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-io: Io,
-
-block_size: u32,
-buf: [][]u8,
-buf_queue: Queue,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
-    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
-    var queue: Queue = .init(buf);
-    for (0..20) |_|
-        try queue.putOne(io, try alloc.alloc(u8, block_size));
-
-    return .{
-        .alloc = alloc,
-        .io = io,
-
-        .block_size = block_size,
-        .buf = buf,
-        .buf_queue = queue,
-    };
-}
-pub fn deinit(self: *Self) void {
-    self.buf_queue.close(self.io);
-    for (self.buf) |buf|
-        self.alloc.free(buf);
-    self.alloc.free(self.buf);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        return statelessDecomp(d, alloc, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-
-    const buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
-    defer self.buf_queue.putOne(self.io, buf) catch {};
-
-    return zlibDecomp(buf.buf, in, out);
-}
-
-inline fn zlibDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = flate.Decompress.init(&rdr, .zlib, buffer);
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const buf = try alloc.alloc(u8, out.len);
-    defer alloc.free(buf);
-    return zlibDecomp(buf, in, out);
-}

src/decomp/zig_zstd.zig

@@ -1,73 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Reader = std.Io.Reader;
-const zstd = std.compress.zstd;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Queue = std.Io.Queue([]u8);
-
-const Self = @This();
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-io: Io,
-
-block_size: u32,
-buf: [][]u8,
-buf_queue: Queue,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
-    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
-    var queue: Queue = .init(buf);
-    for (0..20) |_|
-        try queue.putOne(io, try alloc.alloc(u8, block_size + zstd.block_size_max));
-
-    return .{
-        .alloc = alloc,
-        .io = io,
-
-        .block_size = block_size,
-        .buf = buf,
-        .buf_queue = queue,
-    };
-}
-pub fn deinit(self: *Self) void {
-    self.buf_queue.close(self.io);
-    for (self.buf) |buf|
-        self.alloc.free(buf);
-    self.alloc.free(self.buf);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        const buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return zstdDecomp(buf, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-
-    const buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
-    defer self.buf_queue.putOne(self.io, buf) catch {};
-
-    return zstdDecomp(buf, in, out);
-}
-
-inline fn zstdDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = zstd.Decompress.init(&rdr, buffer, .{ .window_len = @truncate(out.len) });
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const buf = try alloc.alloc(u8, out.len + zstd.block_size_max);
-    defer alloc.free(buf);
-    return zstdDecomp(buf, in, out);
-}

src/directory.zig

@@ -1,69 +1,70 @@
 const std = @import("std");
-const Reader = std.Io.Reader;
 
-const Inode = @import("inode.zig");
+const InodeType = @import("inode.zig").Type;
+const Compression = @import("superblock.zig").Compression;
 
-pub const Error = error{OutOfMemory} || Reader.Error;
+const Header = extern struct { //use extern instead of packed, due to bit alignment
-
-const DirEntry = @This();
-
-block_start: u32,
-block_offset: u16,
-type: Inode.Type,
-name: []const u8,
-
-pub fn deinit(self: DirEntry, alloc: std.mem.Allocator) void {
-    alloc.free(self.name);
-}
-
-pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) Error![]DirEntry {
-    var hdr: Header = undefined;
-    var raw: RawEntry = undefined;
-    var out: std.ArrayList(DirEntry) = try .initCapacity(alloc, 30);
-    errdefer {
-        for (out.items) |ent|
-            alloc.free(ent.name);
-        out.deinit(alloc);
-    }
-
-    var tot_red: u32 = 3;
-    while (tot_red < size) {
-        try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
-        try out.ensureUnusedCapacity(alloc, hdr.count + 1);
-
-        tot_red += @sizeOf(Header);
-
-        for (0..hdr.count + 1) |_| {
-            try rdr.readSliceEndian(RawEntry, @ptrCast(&raw), .little);
-
-            const new_name = try alloc.alloc(u8, raw.name_size + 1);
-            try rdr.readSliceEndian(u8, new_name, .little);
-
-            const new = out.addOneAssumeCapacity();
-            new.* = .{
-                .block_start = hdr.block_start,
-                .block_offset = raw.block_offset,
-                .type = raw.type,
-                .name = new_name,
-            };
-
-            tot_red += @sizeOf(RawEntry) + raw.name_size + 1;
-        }
-    }
-    return out.toOwnedSlice(alloc);
-}
-
-// Types
-
-const Header = extern struct {
     count: u32,
-    block_start: u32,
+    block: u32,
     num: u32,
 };
 
-const RawEntry = extern struct {
+const RawEntry = struct {
-    block_offset: u16,
+    offset: u16,
     num_offset: i16,
-    type: Inode.Type,
+    type: InodeType,
-    name_size: u16,
+    size: u16,
+    name: []const u8,
+
+    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 const Entry = struct {
+    block: u32,
+    offset: u16,
+    num: u32,
+    type: InodeType,
+    name: []const u8,
+
+    pub fn deinit(self: Entry, alloc: std.mem.Allocator) void {
+        alloc.free(self.name);
+    }
+};
+
+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();
+}

src/extract_options.zig

@@ -0,0 +1,23 @@
+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(),
+    };
+}

src/file.zig

@@ -1,95 +1,355 @@
-//! An easier to use wrapper around an inode.
-
 const std = @import("std");
-const Io = std.Io;
+const builtin = @import("builtin");
 
-const Archive = @import("archive.zig");
+const dir = @import("directory.zig");
-const DirEntry = @import("directory.zig");
+
-const ExtractionOptions = @import("options.zig");
+const DirEntry = dir.Entry;
 const Inode = @import("inode.zig");
-const DataExtractor = @import("util/data_extractor.zig");
+const SfsReader = @import("reader.zig").SfsReader;
-const Decompressor = @import("util/decompressor.zig");
+const ToReader = @import("reader/to_read.zig").ToRead;
-const MetadataReader = @import("util/metadata.zig");
+const ExtractionOptions = @import("extract_options.zig");
-const SharedCache = @import("util/shared_cache.zig");
+const DataReader = @import("reader/data.zig").DataReader;
+const Compression = @import("superblock.zig").Compression;
+const MetadataReader = @import("reader/metadata.zig").MetadataReader;
 
-const File = @This();
+pub fn File(comptime T: type) type {
+    return struct {
+        pub const FileError = error{
+            NotRegular,
+            NotDirectory,
+            NotFound,
+        };
 
-alloc: std.mem.Allocator,
+        const Self = @This();
 
-archive: Archive,
+        rdr: *SfsReader(T),
+        // parent: *File(T),
 
-inode: Inode,
+        inode: Inode,
-name: []const u8,
+        name: []const u8,
 
-/// Creates a new File from an inode. Takes ownership of the Inode and creates a copy of the given name.
+        /// Directory entries. Only populated on directories.
-/// Requires the given allocator was used to create the Inode.
+        entries: ?[]DirEntry = null,
-pub fn init(alloc: std.mem.Allocator, archive: Archive, in: Inode, name: []const u8) !File {
+        /// File reader. Only populated on regular files.
-    const new_name = try alloc.alloc(u8, name.len);
+        data_reader: ?DataReader(T) = null,
-    @memcpy(new_name, name);
-    return .{
-        .alloc = alloc,
 
-        .archive = archive,
+        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();
+            }
+        }
 
-        .inode = in,
+        pub fn uid(self: Self) !u32 {
-        .name = new_name,
+            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});
+                },
+            }
+        }
     };
 }
-pub fn fromDirEntry(alloc: std.mem.Allocator, archive: Archive, ent: DirEntry) !File {
-    var rdr = archive.file.readerAt(archive.super.inode_start + ent.block_start);
-    var meta: MetadataReader = .init(alloc, &rdr.interface, archive.stateless_decomp);
-    try meta.interface.discardAll(ent.block_offset);
-
-    var in: Inode = try .read(alloc, &meta.interface, archive.super.block_size);
-    errdefer in.deinit(alloc);
-    return .init(alloc, archive, in, ent.name);
-}
-pub fn deinit(self: File) void {
-    self.alloc.free(self.name);
-    self.inode.deinit(self.alloc);
-}
-
-pub fn open(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
-    const entries = try self.inode.readDirectory(
-        alloc,
-        io,
-        self.archive.file,
-        self.archive.stateless_decomp,
-        self.archive.super.dir_start,
-    );
-    defer {
-        for (entries) |ent|
-            alloc.free(ent.name);
-        alloc.free(entries);
-    }
-    const path = std.mem.trim(u8, filepath, "/");
-    const first_element: []const u8 = std.mem.sliceTo(path, '/');
-
-    var search_slice = entries;
-    var idx: usize = undefined;
-    while (search_slice.len > 0) {
-        idx = search_slice.len / 2;
-        const middle = search_slice[idx];
-        switch (std.mem.order(u8, first_element, middle.name)) {
-            .eq => break,
-            .lt => search_slice = search_slice[0..idx],
-            .gt => search_slice = search_slice[idx + 1 ..],
-        }
-    } else return Error.FileNotFound;
-
-    const first_elem_file = try fromDirEntry(alloc, io, self.archive, search_slice[idx]);
-    if (first_element.len == path.len)
-        return first_elem_file;
-    defer first_elem_file.deinit();
-    return first_elem_file.open(alloc, io, path[first_element.len + 1 ..]);
-}
-
-pub fn extract(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8, options: ExtractionOptions) !void {
-    return self.inode.extract(alloc, io, self.archive.file, self.archive.super, filepath, options);
-}
-
-// Types
-
-pub const Error = error{
-    FileNotFound,
-} || Inode.Error;

src/frag.zig

@@ -1,85 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const BlockSize = @import("inode_data/file.zig").BlockSize;
-const LookupTable = @import("lookup_table.zig");
-const Decompressor = @import("util/decompressor.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-
-const FragManager = @This();
-
-pub const FragEntry = extern struct {
-    start: u64,
-    size: BlockSize,
-    _: u32,
-};
-
-alloc: std.mem.Allocator,
-fil: OffsetFile,
-decomp: *const Decompressor,
-block_size: u32,
-
-entries: []FragEntry,
-
-frag_cache: std.array_hash_map.Auto(u32, []u8),
-cache_mut: std.Io.RwLock = .init,
-
-pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, frag_start: u64, frag_num: u32, block_size: u32) !FragManager {
-    const first_offset: u64 = std.mem.readInt(u64, @ptrCast(fil.map.memory[frag_start .. frag_start + 8]), .little);
-
-    var rdr = fil.readerAt(first_offset);
-    var meta: MetadataReader = .init(alloc, &rdr, decomp);
-
-    const entries = try alloc.alloc(FragEntry, frag_num);
-    errdefer alloc.free(entries);
-
-    try meta.interface.readSliceEndian(FragEntry, entries, .little);
-
-    return .{
-        .alloc = alloc,
-        .fil = fil,
-        .decomp = decomp,
-        .block_size = block_size,
-
-        .entries = entries,
-
-        .frag_cache = .empty,
-    };
-}
-pub fn deinit(self: *FragManager, io: Io) void {
-    self.cache_mut.lockUncancelable(io);
-    self.alloc.free(self.entries);
-    for (self.frag_cache.values()) |v|
-        self.alloc.free(v);
-    self.frag_cache.deinit(self.alloc);
-}
-
-pub fn get(self: *FragManager, io: Io, idx: u32) ![]u8 {
-    {
-        try self.cache_mut.lockShared(io);
-        defer self.cache_mut.unlockShared(io);
-        if (self.frag_cache.contains(idx))
-            return self.frag_cache.get(idx).?;
-    }
-
-    try self.cache_mut.lock(io);
-    defer self.cache_mut.unlock(io);
-
-    if (self.frag_cache.contains(idx))
-        return self.frag_cache.get(idx).?;
-
-    const entry = self.entries[idx];
-
-    const out = try self.alloc.alloc(u8, if (entry.size.uncompressed) entry.size.size else self.block_size);
-
-    if (entry.size.uncompressed) {
-        @memcpy(out, self.fil.map.memory[entry.start .. entry.start + entry.size.size]);
-    } else {
-        @branchHint(.likely);
-        _ = try self.decomp.Decompress(self.alloc, self.fil.map.memory[entry.start .. entry.start + entry.size.size], out);
-    }
-
-    try self.frag_cache.put(self.alloc, idx, out);
-    return out;
-}

src/fragment.zig

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

src/inode.zig

@@ -1,166 +1,13 @@
-//! A file-system object. Represents a File or directory.
-
 const std = @import("std");
-const Reader = std.Io.Reader;
-const Io = std.Io;
 
-const Archive = @import("archive.zig");
+const dir = @import("inode/dir.zig");
-const Decomp = @import("decomp.zig").Decomp;
+const file = @import("inode/file.zig");
-const DirEntry = @import("directory.zig");
+const misc = @import("inode/misc.zig");
-const ExtractionOptions = @import("options.zig");
-const FragEntry = @import("frag.zig").FragEntry;
-const FragManager = @import("frag.zig");
-const dir = @import("inode_data/dir.zig");
-const file = @import("inode_data/file.zig");
-const misc = @import("inode_data/misc.zig");
-const LookupTable = @import("lookup_table.zig");
-const CachedTable = LookupTable.CachedTable;
-const DataExtractor = @import("util/data_extractor.zig");
-const DataReader = @import("util/data_reader.zig");
-const Decompressor = @import("util/decompressor.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-const SharedCache = @import("util/shared_cache.zig");
-const XattrTable = @import("xattr_table.zig");
 
-const Inode = @This();
+pub const Ref = packed struct {
-
+    offset: u16,
-hdr: Header,
+    block: u32,
-data: Data,
+    _: u16,
-
-pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
-    var hdr: Header = undefined;
-    try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
-    return .{
-        .hdr = hdr,
-        .data = switch (hdr.inode_type) {
-            .dir => .{ .dir = try .read(rdr) },
-            .file => .{ .file = try .read(alloc, rdr, block_size) },
-            .symlink => .{ .symlink = try .read(alloc, rdr) },
-            .block_dev => .{ .block_dev = try .read(rdr) },
-            .char_dev => .{ .char_dev = try .read(rdr) },
-            .fifo => .{ .fifo = try .read(rdr) },
-            .socket => .{ .socket = try .read(rdr) },
-            .ext_dir => .{ .ext_dir = try .read(rdr) },
-            .ext_file => .{ .ext_file = try .read(alloc, rdr, block_size) },
-            .ext_symlink => .{ .ext_symlink = try .read(alloc, rdr) },
-            .ext_block_dev => .{ .ext_block_dev = try .read(rdr) },
-            .ext_char_dev => .{ .ext_char_dev = try .read(rdr) },
-            .ext_fifo => .{ .ext_fifo = try .read(rdr) },
-            .ext_socket => .{ .ext_socket = try .read(rdr) },
-        },
-    };
-}
-pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
-    switch (self.data) {
-        .file => |d| d.deinit(alloc),
-        .symlink => |d| d.deinit(alloc),
-        .ext_file => |d| d.deinit(alloc),
-        .ext_symlink => |d| d.deinit(alloc),
-        else => {},
-    }
-}
-
-// Utility Functions
-
-/// Read the directory entries
-pub fn readDirectory(self: Inode, alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64) ![]DirEntry {
-    return switch (self.data) {
-        .dir => |d| readDirFromData(alloc, fil, decomp, dir_offset, d),
-        .ext_dir => |d| readDirFromData(alloc, fil, decomp, dir_offset, d),
-        else => Error.NotDirectory,
-    };
-}
-fn readDirFromData(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64, d: anytype) ![]DirEntry {
-    var rdr = fil.readerAt(dir_offset + d.block_start);
-    var meta: MetadataReader = .init(alloc, &rdr, decomp);
-    try meta.interface.discardAll(d.block_offset);
-
-    return DirEntry.readDirectory(alloc, &meta.interface, d.size);
-}
-/// Get a reader for a regular file's data.
-pub fn dataReader(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32) !DataReader {
-    return switch (self.data) {
-        .file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
-        .ext_file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
-        else => Error.NotRegularFile,
-    };
-}
-fn getReaderFromData(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataReader {
-    const ext: DataReader = .init(alloc, io, fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
-    if (d.frag_block_offset == 0xFFFFFFFF) {
-        // TODO:
-        return error.TODO;
-    }
-    return ext;
-}
-/// Get an extractor for a regular file's data.
-pub fn dataExtractor(self: Inode, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32) !DataExtractor {
-    return switch (self.data) {
-        .file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
-        .ext_file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
-        else => Error.NotRegularFile,
-    };
-}
-fn getExtractorFromData(fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataExtractor {
-    const ext: DataExtractor = .init(fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
-    if (d.frag_block_offset == 0xFFFFFFFF) {
-        // TODO:
-        return error.TODO;
-    }
-    return ext;
-}
-/// Get a symlink's target path
-pub fn symlinkTarget(self: Inode) ![]const u8 {
-    return switch (self.data) {
-        .symlink => |s| s.target,
-        .ext_symlink => |s| s.target,
-        else => Error.NotSymlink,
-    };
-}
-/// Get inode's gid
-pub fn gid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, id_table_start: u64) !u16 {
-    return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.gid_idx);
-}
-/// Get inode's uid
-pub fn uid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, id_table_start: u64) !u16 {
-    return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.uid_idx);
-}
-/// Get the inode's xattr values as an index into the Archive's xattr table.
-/// Returns error.NoXattr if the inode doesn't have extended attributes.
-pub fn xattrIndex(self: Inode) !u32 {
-    const idx = switch (self.data) {
-        .ext_dir => |e| e.xattr_idx,
-        .ext_file => |e| e.xattr_idx,
-        .ext_symlink => |e| e.xattr_idx,
-        .ext_block_dev => |e| e.xattr_idx,
-        .ext_char_dev => |e| e.xattr_idx,
-        .ext_fifo => |e| e.xattr_idx,
-        .ext_socket => |e| e.xattr_idx,
-        else => return error.NoXattr,
-    };
-    if (idx == 0xFFFFFFFF) return error.NoXattr;
-    return idx;
-}
-// Get an inode's xattr values. If the inode does not have xattr values (including if the inode is not an extended type), an empty slice is returned.
-pub fn xattrValues(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, xattr_table_start: u64) ![]XattrTable.XattrOwned {
-    const idx = self.xattrIndex() catch &[0]XattrTable.XattrOwned{};
-    return XattrTable.statelessLookup(alloc, io, decomp, fil, xattr_table_start, idx);
-}
-
-// Types
-
-pub const Error = error{
-    NotDirectory,
-    NotRegularFile,
-    NotSymlink,
-    NotExtended,
-};
-
-pub const Ref = packed struct(u64) {
-    block_offset: u16,
-    block_start: u32,
-    _: u16 = 0,
 };
 
 pub const Type = enum(u16) {
@@ -180,7 +27,16 @@ pub const Type = enum(u16) {
     ext_socket,
 };
 
-pub const Data = union(Type) {
+pub const Header = packed struct {
+    type: Type,
+    perm: 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,
@@ -197,260 +53,41 @@ pub const Data = union(Type) {
     ext_socket: misc.ExtIPC,
 };
 
-pub const Header = extern struct {
+const Self = @This();
-    inode_type: Type,
-    permissions: u16,
-    uid_idx: u16,
-    gid_idx: u16,
-    mod_time: u32,
-    num: u32,
-};
 
-// Extract
+hdr: Header,
+data: Data,
 
-const ExtractError = error{ MknodFailed, CannotSetXattr } || DataExtractor.Error || DirEntry.Error ||
+pub fn init(rdr: anytype, alloc: std.mem.Allocator, block_size: u32) !Self {
-    Decompressor.Error || Io.File.Atomic.InitError || Io.File.Atomic.LinkError || Io.Dir.SymLinkError;
+    var hdr: Header = undefined;
-const PathRet = struct {
+    _ = try rdr.read(std.mem.asBytes(&hdr));
-    path: []const u8,
+    const data: Data = switch (hdr.type) {
-    inode: Inode,
+        .dir => .{ .dir = try .init(rdr) },
-    origin: bool,
+        .file => .{ .file = try .init(rdr, alloc, block_size) },
-
+        .symlink => .{ .symlink = try .init(rdr, alloc) },
-    fn deinit(self: PathRet, alloc: std.mem.Allocator) void {
+        .block_dev => .{ .block_dev = try .init(rdr) },
-        if (self.origin) return;
+        .char_dev => .{ .char_dev = try .init(rdr) },
-        alloc.free(self.path);
+        .fifo => .{ .fifo = try .init(rdr) },
-        self.inode.deinit(alloc);
+        .socket => .{ .socket = try .init(rdr) },
-    }
+        .ext_dir => .{ .ext_dir = try .init(rdr) },
-    fn setMetadata(self: PathRet, alloc: std.mem.Allocator, io: Io, id_table: *CachedTable(u16), xattr_table: ?*XattrTable, options: ExtractionOptions) !void {
+        .ext_file => .{ .ext_file = try .init(rdr, alloc, block_size) },
-        var fil = try Io.Dir.cwd().openFile(io, self.path, .{});
+        .ext_symlink => .{ .ext_symlink = try .init(rdr, alloc) },
-        defer fil.close(io);
+        .ext_block_dev => .{ .ext_block_dev = try .init(rdr) },
-
+        .ext_char_dev => .{ .ext_char_dev = try .init(rdr) },
-        const inode = self.inode;
+        .ext_fifo => .{ .ext_fifo = try .init(rdr) },
-
+        .ext_socket => .{ .ext_socket = try .init(rdr) },
-        if (!options.ignore_permissions) {
+    };
-            try fil.setPermissions(io, @enumFromInt(inode.hdr.permissions));
-            try fil.setOwner(io, try id_table.get(io, inode.hdr.uid_idx), try id_table.get(io, inode.hdr.gid_idx));
-        }
-        if (xattr_table != null) {
-            const idx = inode.xattrIndex() catch return;
-
-            const xattrs = try xattr_table.?.get(alloc, io, idx);
-            defer {
-                for (xattrs) |x|
-                    x.deinit(alloc);
-                alloc.free(xattrs);
-            }
-
-            const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{self.path}, 0);
-            defer alloc.free(sentinel_path);
-            for (xattrs) |x| {
-                const xattr_ret = std.os.linux.fsetxattr(fil.handle, x.key, x.value.ptr, x.value.len, 0);
-                if (xattr_ret != 0)
-                    return ExtractError.CannotSetXattr;
-            }
-        }
-    }
-};
-fn DirCompare(_: void, a: PathRet, b: PathRet) std.math.Order {
-    return std.math.order(std.mem.count(u8, a.path, "/"), std.mem.count(u8, b.path, "/"));
-}
-const ExtractReturnUnion = union(enum) {
-    path_ret: ExtractError!PathRet,
-};
-const Tables = struct {
-    id: LookupTable.CachedTable(u16),
-    frag: LookupTable.CachedTable(FragEntry),
-    xattr: XattrTable,
-};
-
-/// Extracts the given inode to the given path. If the inode not a directory, the given path must not exist.
-/// If the inode is a directory the path must not exist or be a directory.
-pub fn extract(
-    self: Inode,
-    alloc: std.mem.Allocator,
-    io: Io,
-    fil: OffsetFile,
-    super: Archive.Superblock,
-    filepath: []const u8,
-    options: ExtractionOptions,
-) !void {
-    const path = std.mem.trimEnd(u8, filepath, "/");
-
-    var decomp_base: Decomp = try .init(super.compression, alloc, io, super.block_size);
-    const decomp = decomp_base.decompressor();
-
-    var frag_mgr: FragManager = try .init(alloc, fil, decomp, super.frag_start, super.frag_count, super.block_size);
-    defer frag_mgr.deinit(io);
-
-    var sel_buf: [10]ExtractReturnUnion = undefined;
-    var sel: Io.Select(ExtractReturnUnion) = .init(io, &sel_buf);
-    defer sel.cancelDiscard();
-
-    sel.async(.path_ret, extractReal, .{ self, alloc, io, fil, super, decomp, &sel, &frag_mgr, path, true });
-
-    var id_table: CachedTable(u16) = .init(alloc, fil, decomp, super.id_start, super.id_count);
-    defer id_table.deinit(io);
-
-    var xattr_table: ?XattrTable = if (super.flags.xattr_never or options.ignore_xattr or !@hasField(std.os, "linux"))
-        null
-    else
-        try .init(alloc, fil, decomp, super.xattr_start);
-    defer if (xattr_table != null) xattr_table.?.deinit(io);
-
-    var dir_queue: std.PriorityDequeue(PathRet, void, DirCompare) = .empty;
-    defer dir_queue.deinit(alloc);
-
-    while (true) {
-        if (sel.group.token.load(.unordered) == null) break;
-
-        const ret = try sel.await();
-        const path_ret = try ret.path_ret;
-
-        if (options.ignore_permissions and xattr_table == null) {
-            path_ret.deinit(alloc);
-            continue;
-        }
-
-        if (path_ret.inode.hdr.inode_type == .dir or path_ret.inode.hdr.inode_type == .ext_dir) {
-            try dir_queue.push(alloc, path_ret);
-            continue;
-        }
-
-        defer path_ret.deinit(alloc);
-        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
-    }
-
-    while (sel.cancel()) |ret| {
-        const path_ret = try ret.path_ret;
-
-        if (options.ignore_permissions and xattr_table == null) {
-            path_ret.deinit(alloc);
-            continue;
-        }
-
-        if (path_ret.inode.hdr.inode_type == .dir or path_ret.inode.hdr.inode_type == .ext_dir) {
-            try dir_queue.push(alloc, path_ret);
-            continue;
-        }
-
-        defer path_ret.deinit(alloc);
-        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
-    }
-
-    var iter = dir_queue.iterator();
-    while (iter.next()) |path_ret| {
-        defer path_ret.deinit(alloc);
-        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
-    }
-}
-pub fn extractReal(
-    self: Inode,
-    alloc: std.mem.Allocator,
-    io: Io,
-    fil: OffsetFile,
-    super: Archive.Superblock,
-    decomp: *const Decompressor,
-    sel: *Io.Select(ExtractReturnUnion),
-    frag_mgr: *FragManager,
-    path: []const u8,
-    origin: bool,
-) ExtractError!PathRet {
-    errdefer {
-        if (!origin) {
-            self.deinit(alloc);
-            alloc.free(path);
-        }
-    }
-    switch (self.hdr.inode_type) {
-        .dir, .ext_dir => {
-            try Io.Dir.cwd().createDir(io, path, @enumFromInt(0o777));
-
-            const entries = self.readDirectory(alloc, fil, decomp, super.dir_start) catch |err| switch (err) {
-                Error.NotDirectory, Error.NotExtended, Error.NotRegularFile, Error.NotSymlink => unreachable,
-                else => |e| return e,
-            };
-            defer {
-                for (entries) |e|
-                    e.deinit(alloc);
-                alloc.free(entries);
-            }
-
-            for (entries) |e| {
-                const new_path = try std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", e.name });
-                errdefer alloc.free(new_path);
-
-                var rdr = fil.readerAt(super.inode_start + e.block_start);
-                var meta: MetadataReader = .init(alloc, &rdr, decomp);
-                try meta.interface.discardAll(e.block_offset);
-
-                const new_inode = try read(alloc, &meta.interface, super.block_size);
-                errdefer new_inode.deinit(alloc);
-
-                sel.async(.path_ret, extractReal, .{ new_inode, alloc, io, fil, super, decomp, sel, frag_mgr, new_path, false });
-            }
-        },
-        .file, .ext_file => {
-            var atomic = try Io.Dir.cwd().createFileAtomic(io, path, .{ .make_path = true });
-            defer atomic.deinit(io);
-
-            var ext: DataExtractor = switch (self.data) {
-                .file => |f| blk: {
-                    var ext: DataExtractor = .init(fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
-                    if (f.frag_idx != 0xFFFFFFFF)
-                        ext.addFrag(f.frag_block_offset, try frag_mgr.get(io, f.frag_idx));
-                    break :blk ext;
-                },
-                .ext_file => |f| blk: {
-                    var ext: DataExtractor = .init(fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
-                    if (f.frag_idx != 0xFFFFFFFF)
-                        ext.addFrag(f.frag_block_offset, try frag_mgr.get(io, f.frag_idx));
-                    break :blk ext;
-                },
-                else => unreachable,
-            };
-
-            try ext.extractAsync(alloc, io, atomic.file);
-
-            try atomic.link(io);
-        },
-        .symlink, .ext_symlink => try Io.Dir.cwd().symLink(io, self.symlinkTarget() catch unreachable, path, .{}),
-        else => {
-            var mode: u32 = undefined;
-            var dev: u32 = 0;
-
-            const DT = std.posix.DT;
-
-            switch (self.data) {
-                .char_dev => |d| {
-                    dev = d.dev;
-                    mode = DT.CHR;
-                },
-                .ext_char_dev => |d| {
-                    dev = d.dev;
-                    mode = DT.CHR;
-                },
-                .block_dev => |d| {
-                    dev = d.dev;
-                    mode = DT.BLK;
-                },
-                .ext_block_dev => |d| {
-                    dev = d.dev;
-                    mode = DT.BLK;
-                },
-                .fifo, .ext_fifo => mode = DT.FIFO,
-                .socket, .ext_socket => mode = DT.SOCK,
-                else => unreachable,
-            }
-
-            const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{path}, 0);
-            const res = std.os.linux.mknod(sentinel_path, mode, dev);
-            alloc.free(sentinel_path);
-            if (res != 0)
-                return ExtractError.MknodFailed;
-        },
-    }
     return .{
-        .path = path,
+        .hdr = hdr,
-        .inode = self,
+        .data = data,
-        .origin = origin,
     };
 }
+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 => {},
+    }
+}

src/inode/dir.zig

@@ -0,0 +1,31 @@
+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;
+    }
+};

src/inode/file.zig

@@ -0,0 +1,77 @@
+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;
+    }
+};

src/inode/misc.zig

@@ -0,0 +1,87 @@
+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;
+    }
+};

src/inode_data/dir.zig

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

src/inode_data/file.zig

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

src/inode_data/misc.zig

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

src/lookup_table.zig

@@ -1,125 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const Decompressor = @import("util/decompressor.zig");
-const MetadataReader = @import("util/metadata.zig");
-const OffsetFile = @import("util/offset_file.zig");
-
-pub fn lookupValue(comptime T: anytype, alloc: std.mem.Allocator, decomp: *const Decompressor, file: OffsetFile, table_start: u64, idx: u32) !T {
-    const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
-
-    const block = idx / T_PER_BLOCK;
-    const block_offset = idx % T_PER_BLOCK;
-
-    const offset_pos = table_start + (8 * block);
-    const offset: u64 = std.mem.readInt(u64, @ptrCast(file.map.memory[offset_pos .. offset_pos + 8]), .little);
-
-    var rdr = file.readerAt(offset);
-    var meta: MetadataReader = .init(alloc, &rdr, decomp);
-
-    try meta.interface.discardAll(@sizeOf(T) * block_offset);
-    var out: T = undefined;
-    try meta.interface.readSliceEndian(T, @ptrCast(&out), .little);
-    return out;
-}
-
-pub const Error = Io.Cancelable || Io.File.Reader.SeekError || Io.Reader.ReadAllocError;
-
-pub fn CachedTable(comptime T: anytype) type {
-    return struct {
-        const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
-
-        const Table = @This();
-
-        alloc: std.mem.Allocator,
-        fil: OffsetFile,
-        decomp: *const Decompressor,
-
-        table_start: u64,
-        total_num: u32,
-
-        table: std.AutoHashMap(u32, []T),
-
-        mut: Io.RwLock = .init,
-
-        pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, offset: u64, total_num: u32) Table {
-            return .{
-                .alloc = alloc,
-                .fil = fil,
-                .decomp = decomp,
-
-                .table_start = offset,
-                .total_num = total_num,
-
-                .table = .init(alloc),
-            };
-        }
-        pub fn deinit(self: *Table, io: Io) void {
-            self.mut.lockUncancelable(io);
-            var iter = self.table.valueIterator();
-            while (iter.next()) |val|
-                self.alloc.free(val.*);
-            self.table.deinit();
-        }
-
-        pub fn fill(self: *Table, io: Io) Error!void {
-            try self.mut.lock(io);
-            defer self.mut.unlock(io);
-
-            var num_blocks = self.total_num / T_PER_BLOCK;
-            if (self.total_num % T_PER_BLOCK > 0)
-                num_blocks += 1;
-
-            for (0..num_blocks) |block| {
-                const offset_pos = self.table_start + (8 * block);
-                const offset: u64 = std.mem.readInt(u64, @ptrCast(self.fil.map.memory[offset_pos .. offset_pos + 8]), .little);
-
-                const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
-                    @truncate(self.total_num % T_PER_BLOCK)
-                else
-                    T_PER_BLOCK;
-
-                var rdr = self.fil.readerAt(offset);
-                var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
-
-                const slice = try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little);
-                try self.table.put(@truncate(block), slice);
-            }
-        }
-
-        pub fn get(self: *Table, io: Io, idx: u32) Error!T {
-            const block = idx / T_PER_BLOCK;
-            const block_offset = idx % T_PER_BLOCK;
-
-            {
-                try self.mut.lockShared(io);
-                defer self.mut.unlockShared(io);
-
-                if (self.table.contains(block))
-                    return self.table.get(block).?[block_offset];
-            }
-
-            try self.mut.lock(io);
-            defer self.mut.unlock(io);
-
-            if (self.table.contains(block))
-                return self.table.get(block).?[block_offset];
-
-            const offset_pos = self.table_start + (8 * block);
-            const offset: u64 = std.mem.readInt(u64, @ptrCast(self.fil.map.memory[offset_pos .. offset_pos + 8]), .little);
-
-            const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
-                @truncate(self.total_num % T_PER_BLOCK)
-            else
-                T_PER_BLOCK;
-
-            var rdr = self.fil.readerAt(offset);
-            var meta: MetadataReader = .init(self.alloc, &rdr, self.decomp);
-
-            const slice = try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little);
-            try self.table.put(@truncate(block), slice);
-
-            return slice[block_offset];
-        }
-    };
-}

src/options.zig

@@ -1,33 +0,0 @@
-//! Options for file/directory extraction.
-
-const std = @import("std");
-const Writer = std.Io.Writer;
-
-const ExtractionOptions = @This();
-
-// /// The number of threads used for extraction. 0 implies single threaded.
-// threads: usize = 1, // As of Zig 0.16 this should no longer be necessary, instead this should be set by the io instance used.
-/// 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 SingleThreadedDefault: ExtractionOptions = .{};
-pub fn Default() !ExtractionOptions {
-    return .{
-        .threads = try std.Thread.getCpuCount(),
-    };
-}
-pub fn VerboseDefault(wrt: *Writer) !ExtractionOptions {
-    return .{
-        .verbose = true,
-        .verbose_writer = wrt,
-        .threads = try std.Thread.getCpuCount(),
-    };
-}

src/reader.zig

@@ -0,0 +1,85 @@
+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);
+        }
+    };
+}

src/reader/data.zig

@@ -0,0 +1,271 @@
+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);
+            };
+        }
+    };
+}

src/reader/metadata.zig

@@ -0,0 +1,82 @@
+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;
+        }
+    };
+}

src/reader/p_read.zig

@@ -0,0 +1,29 @@
+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);
+        }
+    };
+}

src/reader/to_read.zig

@@ -0,0 +1,43 @@
+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),
+            };
+        }
+    };
+}

src/root.zig

@@ -1,2 +1,62 @@
-pub const Archive = @import("archive.zig");
+const std = @import("std");
-pub const ExtractionOptions = @import("options.zig");
+
+pub const SfsReader = @import("reader.zig").SfsReader;
+pub const ExtractionOptions = @import("extract_options.zig");
+
+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", .{});
+}

src/superblock.zig

@@ -0,0 +1,79 @@
+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);
+            },
+        }
+    }
+};

src/table.zig

@@ -0,0 +1,75 @@
+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];
+        }
+    };
+}

src/test.zig

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

src/util/data_extractor.zig

@@ -1,145 +0,0 @@
-//! The DataExtractor is meant to extract a regular file's data to a given file asyncronously.
-
-const std = @import("std");
-const Io = std.Io;
-
-const FragEntry = @import("../frag.zig").FragEntry;
-const BlockSize = @import("../inode_data/file.zig").BlockSize;
-const Decompressor = @import("decompressor.zig");
-const OffsetFile = @import("offset_file.zig");
-
-// const SharedCache = @import("shared_cache.zig");
-
-pub const Error = Decompressor.Error || Io.File.MemoryMap.CreateError || Io.File.WritePositionalError;
-
-const DataExtractor = @This();
-
-fil: OffsetFile,
-decomp: *const Decompressor,
-block_size: u32,
-
-file_size: u64,
-start: u64,
-blocks: []BlockSize,
-
-frag_offset: u32 = 0,
-frag_block: ?[]u8 = null,
-
-err: ?Error = null,
-
-pub fn init(fil: OffsetFile, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) DataExtractor {
-    return .{
-        .fil = fil,
-        .decomp = decomp,
-        .block_size = block_size,
-
-        .file_size = file_size,
-        .start = data_start,
-        .blocks = blocks,
-    };
-}
-pub fn addFrag(self: *DataExtractor, frag_offset: u32, block: []u8) void {
-    self.frag_offset = frag_offset;
-    self.frag_block = block;
-}
-
-fn numBlocks(self: DataExtractor) usize {
-    var num = self.blocks.len;
-    if (self.frag_block != null) num += 1;
-    return num;
-}
-
-/// Starts extracting the data using the given group to spawn async tasks.
-pub fn extractAsync(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File) Error!void {
-    var group: Io.Group = .init;
-    defer group.cancel(io);
-    var err: ?Error = null;
-
-    var read_offset: u64 = self.start;
-    for (0..self.blocks.len) |idx| {
-        group.async(io, blockThread, .{ self, alloc, io, fil, read_offset, idx, &err });
-        read_offset += self.blocks[idx].size;
-    }
-    if (self.frag_block != null)
-        group.async(io, fragThread, .{ self, io, fil, &err });
-
-    group.await(io) catch |cancel| return err orelse cancel;
-}
-
-fn blockThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File, read_offset: u64, idx: usize, ret_err: *?Error) Io.Cancelable!void {
-    const block = self.blocks[idx];
-
-    const cur_block_size = if (idx == self.numBlocks() - 1)
-        self.file_size % self.block_size
-    else
-        self.block_size;
-
-    const write_offset = self.block_size * idx;
-
-    var wrt = fil.writer(io, &[0]u8{});
-    wrt.seekTo(write_offset) catch |err| {
-        ret_err.* = err;
-        if (err == error.Canceled) io.recancel();
-        return Io.Cancelable.Canceled;
-    };
-
-    if (block.size == 0) {
-        wrt.interface.splatByteAll(0, cur_block_size) catch |err| {
-            ret_err.* = err;
-            if (err == error.Canceled) io.recancel();
-            return Io.Cancelable.Canceled;
-        };
-    } else {
-        if (block.uncompressed) {
-            wrt.interface.writeAll(self.fil.map.memory[read_offset..][0..cur_block_size]) catch |err| {
-                ret_err.* = err;
-                if (err == error.Canceled) io.recancel();
-                return Io.Cancelable.Canceled;
-            };
-        } else {
-            @branchHint(.likely);
-
-            var tmp: [1024 * 1024]u8 = undefined;
-
-            _ = self.decomp.Decompress(alloc, self.fil.map.memory[read_offset..][0..block.size], tmp[0..cur_block_size]) catch |err| {
-                ret_err.* = err;
-                return Io.Cancelable.Canceled;
-            };
-
-            wrt.interface.writeAll(tmp[0..cur_block_size]) catch |err| {
-                ret_err.* = err;
-                if (err == error.Canceled) io.recancel();
-                return Io.Cancelable.Canceled;
-            };
-        }
-    }
-    wrt.flush() catch |err| {
-        ret_err.* = err;
-        if (err == error.Canceled) io.recancel();
-        return Io.Cancelable.Canceled;
-    };
-}
-fn fragThread(self: DataExtractor, io: Io, fil: Io.File, ret_err: *?Error) Io.Cancelable!void {
-    const cur_block_size = self.file_size % self.block_size;
-
-    const write_offset = self.blocks.len * self.block_size;
-
-    var wrt = fil.writer(io, &[0]u8{});
-    wrt.seekTo(write_offset) catch |err| {
-        ret_err.* = err;
-        if (err == error.Canceled) io.recancel();
-        return Io.Cancelable.Canceled;
-    };
-
-    wrt.interface.writeAll(self.frag_block.?[self.frag_offset..][0..cur_block_size]) catch |err| {
-        ret_err.* = err;
-        if (err == error.Canceled) io.recancel();
-        return Io.Cancelable.Canceled;
-    };
-
-    wrt.flush() catch |err| {
-        ret_err.* = err;
-        if (err == error.Canceled) io.recancel();
-        return Io.Cancelable.Canceled;
-    };
-}

src/util/data_reader.zig

@@ -1,189 +0,0 @@
-//! DataReader reads a regular file's data linearly from start to finish using Io.Reader interface.
-
-const std = @import("std");
-const Io = std.Io;
-const Reader = Io.Reader;
-const Writer = Io.Writer;
-const Limit = Io.Limit;
-
-const BlockSize = @import("../inode_data/file.zig").BlockSize;
-const Decompressor = @import("decompressor.zig");
-const OffsetFile = @import("offset_file.zig");
-
-// const SharedCache = @import("shared_cache.zig");
-
-const DataReader = @This();
-
-alloc: std.mem.Allocator,
-
-fil: OffsetFile,
-io: Io,
-decomp: *const Decompressor,
-block_size: u32,
-
-file_size: u64,
-cur_offset: u64,
-blocks: []BlockSize,
-
-frag_offset: u32 = 0,
-frag_block: ?[]u8 = null,
-
-block_idx: usize = 0,
-sparse_block: bool = false,
-
-interface: Io.Reader,
-
-pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) !DataReader {
-    return .{
-        .alloc = alloc,
-
-        .fil = fil,
-        .io = io,
-        .decomp = decomp,
-        .block_size = block_size,
-
-        .file_size = file_size,
-        .cur_offset = data_start,
-        .blocks = blocks,
-
-        .interface = .{
-            .buffer = try alloc.alloc(u8, block_size),
-            .seek = 0,
-            .end = 0,
-            .vtable = &.{
-                .stream = stream,
-                .discard = discard,
-                .readVec = readVec,
-            },
-        },
-    };
-}
-pub fn deinit(self: *DataReader) void {
-    self.alloc.free(self.interface.buffer);
-}
-pub fn addFrag(self: *DataReader, frag_offset: u32, block: []u8) void {
-    self.frag_offset = frag_offset;
-    self.frag_block = block;
-}
-
-fn numBlocks(self: DataReader) usize {
-    var num = self.blocks.len;
-    if (self.frag_block != null) num += 1;
-    return num;
-}
-fn advanceBuffer(self: *DataReader) !void {
-    if (self.block_idx >= self.numBlocks())
-        return Reader.Error.EndOfStream;
-
-    errdefer self.interface.end = 0;
-    defer self.block_idx += 1;
-
-    self.interface.end = if (self.block_idx == self.numBlocks() - 1)
-        self.file_size % self.block_size
-    else
-        self.block_size;
-
-    // Fragment
-    if (self.block_idx == self.blocks.len) {
-        @memcpy(self.interface.buffer[0..self.interface.end], self.frag_block.?[self.frag_offset .. self.frag_offset + self.interface.end]);
-        self.interface.seek = 0;
-        return;
-    }
-
-    // Normal Block
-    const block = self.blocks[self.block_idx];
-    if (block.size == 0) {
-        self.interface.seek = 0;
-        self.sparse_block = true;
-        return;
-    } else {
-        self.sparse_block = false;
-    }
-    if (block.uncompressed) {
-        @memcpy(self.interface.buffer[0..self.interface.end], self.fil.map.memory[self.cur_offset .. self.cur_offset + self.interface.end]);
-        self.cur_offset += self.interface.end;
-    } else {
-        @branchHint(.likely);
-
-        _ = try self.decomp.Decompress(self.alloc, self.fil.map.memory[self.cur_offset .. self.cur_offset + block.size], self.interface.buffer[0..self.interface.end]);
-        self.cur_offset += block.size;
-    }
-    self.interface.seek = 0;
-}
-
-fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
-    var data: *DataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.seek == rdr.end)
-        data.advanceBuffer() catch |err| return switch (err) {
-            error.ReadFailed => error.ReadFailed,
-            error.EndOfStream => error.EndOfStream,
-            else => error.ReadFailed,
-        };
-
-    switch (limit) {
-        .nothing => return 0,
-        .unlimited => {
-            const wrote = if (data.sparse_block)
-                try wrt.splatByte(0, rdr.end - rdr.seek)
-            else
-                try wrt.write(rdr.buffer[rdr.seek..rdr.end]);
-            rdr.seek += wrote;
-            return wrote;
-        },
-        else => {
-            const to_read = @min(rdr.end - rdr.seek, @intFromEnum(limit));
-            const wrote = if (data.sparse_block)
-                try wrt.splatByte(0, to_read)
-            else
-                try wrt.write(rdr.buffer[rdr.seek .. rdr.seek + to_read]);
-            rdr.seek += wrote;
-            return wrote;
-        },
-    }
-}
-fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
-    var data: *DataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.seek == rdr.end)
-        data.advanceBuffer() catch |err| return switch (err) {
-            error.ReadFailed => error.ReadFailed,
-            error.EndOfStream => error.EndOfStream,
-            else => error.ReadFailed,
-        };
-
-    switch (limit) {
-        .nothing => return 0,
-        .unlimited => {
-            const adv = rdr.end - rdr.seek;
-            rdr.seek = rdr.end;
-            return adv;
-        },
-        else => {
-            const adv = @min(rdr.end - rdr.seek, @intFromEnum(limit));
-            rdr.seek += adv;
-            return adv;
-        },
-    }
-}
-fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
-    var data: *DataReader = @fieldParentPtr("interface", rdr);
-    if (rdr.seek == rdr.end)
-        data.advanceBuffer() catch |err| return switch (err) {
-            error.ReadFailed => error.ReadFailed,
-            error.EndOfStream => error.EndOfStream,
-            else => error.ReadFailed,
-        };
-
-    var wrote: usize = 0;
-    for (vec) |buf| {
-        if (rdr.seek == rdr.end) break;
-
-        const to_copy = @min(rdr.end - rdr.seek, buf.len);
-        if (data.sparse_block)
-            @memset(buf[0..to_copy], 0)
-        else
-            @memcpy(buf[0..to_copy], rdr.buffer[rdr.seek .. rdr.seek + to_copy]);
-        rdr.seek += to_copy;
-        wrote += to_copy;
-    }
-    return wrote;
-}

src/util/decompressor.zig

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

src/util/metadata.zig

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

src/util/misc.zig

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

src/util/offset_file.zig

@@ -1,27 +0,0 @@
-//! A File where it's meaningful (to us) content starts at a given offset.
-
-const std = @import("std");
-const Io = std.Io;
-const File = Io.File;
-const Reader = Io.Reader;
-
-const OffsetFile = @This();
-
-map: Io.File.MemoryMap,
-
-pub fn init(io: Io, fil: File, archive_size: u64, init_offset: u64) !OffsetFile {
-    return .{
-        .map = try fil.createMemoryMap(io, .{
-            .protection = .{ .read = true, .write = false, .execute = false },
-            .len = archive_size,
-            .offset = init_offset,
-        }),
-    };
-}
-pub fn deinit(self: @This(), io: Io) void {
-    self.map.destroy(io);
-}
-
-pub fn readerAt(self: OffsetFile, offset: u64) Reader {
-    return .fixed(self.map.memory[offset..]);
-}

src/util/shared_cache.zig

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

src/xattr_table.zig

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