Further implementing everthing again.

Added Decompressor vtable interface.
Directory table parsing
Inode reading
Metadata Reader

src/inode/dir.zig

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

src/inode/file.zig

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

src/inode/misc.zig

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

src/inode/sym.zig

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