268 lines
6.9 KiB
Zig
268 lines
6.9 KiB
Zig
const std = @import("std");
|
|
const Io = std.Io;
|
|
|
|
const util = @import("utils/util.zig");
|
|
|
|
const MetadataReader = @import("utils/meta.zig");
|
|
const Super = @import("archive.zig").Super;
|
|
|
|
const Inode = @This();
|
|
|
|
header: Header,
|
|
data: Data,
|
|
|
|
pub fn fromRef(alloc: std.mem.Allocator, data: []u8, ref: Reference, super: Super) !Inode {
|
|
var meta: MetadataReader = .init(alloc, data[super.inode_table_start + ref.start ..], super.decomp_fn);
|
|
try meta.interface.discardAll(ref.offset);
|
|
|
|
return read(alloc, &meta.interface, super.block_size);
|
|
}
|
|
pub fn read(alloc: std.mem.Allocator, rdr: *Io.Reader, block_size: u32) !Inode {
|
|
const hdr = try util.readValueRdr(Header, rdr);
|
|
|
|
return .{
|
|
.header = hdr,
|
|
.data = switch (hdr.type) {
|
|
.dir => .{ .dir = try .read(rdr) },
|
|
.file => .{ .file = try .read(rdr, alloc, block_size) },
|
|
.symlink => .{ .symlink = try .read(rdr, alloc) },
|
|
.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(rdr, alloc, block_size) },
|
|
.ext_symlink => .{ .ext_symlink = try .read(rdr, alloc) },
|
|
.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 copy(self: Inode, alloc: std.mem.Allocator) !Inode {
|
|
var new_inode = self;
|
|
|
|
switch (new_inode.data) {
|
|
.file => |*f| f.blocks = try alloc.dupe(BlockSize, f.blocks),
|
|
.ext_file => |*f| f.blocks = try alloc.dupe(BlockSize, f.blocks),
|
|
.symlink => |*f| f.target = try alloc.dupe(u8, f.target),
|
|
.ext_symlink => |*f| f.target = try alloc.dupe(u8, f.target),
|
|
else => {},
|
|
}
|
|
|
|
return new_inode;
|
|
}
|
|
pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
|
|
switch (self.data) {
|
|
.file => |f| alloc.free(f.blocks),
|
|
.ext_file => |f| alloc.free(f.blocks),
|
|
.symlink => |s| alloc.free(s.target),
|
|
.ext_symlink => |s| alloc.free(s.target),
|
|
else => {},
|
|
}
|
|
}
|
|
|
|
// Types
|
|
|
|
pub const Reference = packed struct(u64) {
|
|
offset: u16,
|
|
start: u32,
|
|
_: u16,
|
|
};
|
|
|
|
pub const BlockSize = packed struct(u32) {
|
|
size: u23,
|
|
uncompressed: bool,
|
|
_: u8,
|
|
};
|
|
|
|
pub const Type = enum(u16) {
|
|
dir,
|
|
file,
|
|
symlink,
|
|
block_dev,
|
|
char_dev,
|
|
fifo,
|
|
socket,
|
|
ext_dir,
|
|
ext_file,
|
|
ext_symlink,
|
|
ext_block_dev,
|
|
ext_char_dev,
|
|
ext_fifo,
|
|
ext_socket,
|
|
};
|
|
|
|
pub const Header = extern struct {
|
|
type: Type,
|
|
permission: u16,
|
|
uid_idx: u16,
|
|
gid_idx: u16,
|
|
mod_time: u32,
|
|
inode_num: u32,
|
|
};
|
|
|
|
pub const Data = union(Type) {
|
|
dir: Dir,
|
|
file: File,
|
|
symlink: Symlink,
|
|
block_dev: Dev,
|
|
char_dev: Dev,
|
|
fifo: Fifo,
|
|
socket: Fifo,
|
|
ext_dir: ExtDir,
|
|
ext_file: ExtFile,
|
|
ext_symlink: Symlink,
|
|
ext_block_dev: ExtDev,
|
|
ext_char_dev: ExtDev,
|
|
ext_fifo: ExtFifo,
|
|
ext_socket: ExtFifo,
|
|
};
|
|
|
|
// Inode data types
|
|
|
|
pub const Dir = extern struct {
|
|
start: u32,
|
|
hard_links: u32,
|
|
size: u16,
|
|
offset: u16,
|
|
parent_inode_num: u32,
|
|
|
|
pub fn read(rdr: *Io.Reader) !Dir {
|
|
return util.readValueRdr(Dir, rdr);
|
|
}
|
|
};
|
|
pub const ExtDir = extern struct {
|
|
hard_links: u32,
|
|
size: u32,
|
|
start: u32,
|
|
parent_inode_num: u32,
|
|
idx_count: u16,
|
|
offset: u16,
|
|
xattr_idx: u32,
|
|
|
|
pub fn read(rdr: *Io.Reader) !ExtDir {
|
|
return util.readValueRdr(ExtDir, rdr);
|
|
}
|
|
};
|
|
|
|
pub const File = struct {
|
|
start: u32,
|
|
frag_idx: u32,
|
|
frag_offset: u32,
|
|
size: u32,
|
|
blocks: []BlockSize,
|
|
|
|
pub fn read(rdr: *Io.Reader, alloc: std.mem.Allocator, block_size: u32) !File {
|
|
var raw: [16]u8 = undefined;
|
|
try rdr.readSliceAll(&raw);
|
|
|
|
const frag_idx = std.mem.readInt(u32, raw[4..8], .little);
|
|
const size = std.mem.readInt(u32, raw[12..16], .little);
|
|
|
|
var num = size / block_size;
|
|
if (frag_idx == 0xFFFFFFFF and size % block_size > 0)
|
|
num += 1;
|
|
|
|
const blocks = try alloc.alloc(BlockSize, num);
|
|
try rdr.readSliceEndian(BlockSize, blocks, .little);
|
|
|
|
return .{
|
|
.start = std.mem.readInt(u32, raw[0..4], .little),
|
|
.frag_idx = frag_idx,
|
|
.frag_offset = std.mem.readInt(u32, raw[8..12], .little),
|
|
.size = size,
|
|
.blocks = blocks,
|
|
};
|
|
}
|
|
};
|
|
pub const ExtFile = struct {
|
|
start: u64,
|
|
size: u64,
|
|
hard_links: u32,
|
|
frag_idx: u32,
|
|
frag_offset: u32,
|
|
xattr_idx: u32,
|
|
blocks: []BlockSize,
|
|
|
|
pub fn read(rdr: *Io.Reader, alloc: std.mem.Allocator, block_size: u32) !ExtFile {
|
|
var raw: [40]u8 = undefined;
|
|
try rdr.readSliceAll(&raw);
|
|
|
|
const frag_idx = std.mem.readInt(u32, raw[28..32], .little);
|
|
const size = std.mem.readInt(u64, raw[8..16], .little);
|
|
|
|
var num = size / block_size;
|
|
if (frag_idx == 0xFFFFFFFF and size % block_size > 0)
|
|
num += 1;
|
|
|
|
const blocks = try alloc.alloc(BlockSize, num);
|
|
try rdr.readSliceEndian(BlockSize, blocks, .little);
|
|
|
|
return .{
|
|
.start = std.mem.readInt(u64, raw[0..8], .little),
|
|
.size = size,
|
|
.hard_links = std.mem.readInt(u32, raw[24..28], .little),
|
|
.frag_idx = frag_idx,
|
|
.frag_offset = std.mem.readInt(u32, raw[32..36], .little),
|
|
.xattr_idx = std.mem.readInt(u32, raw[36..], .little),
|
|
.blocks = blocks,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Symlink = struct {
|
|
hard_links: u32,
|
|
target: []const u8,
|
|
|
|
pub fn read(rdr: *Io.Reader, alloc: std.mem.Allocator) !Symlink {
|
|
var raw: [8]u8 = undefined;
|
|
try rdr.readSliceAll(&raw);
|
|
|
|
const target = try alloc.alloc(u8, std.mem.readInt(u32, raw[4..], .little));
|
|
errdefer alloc.free(target);
|
|
|
|
try rdr.readSliceEndian(u8, target, .little);
|
|
|
|
return .{
|
|
.hard_links = std.mem.readInt(u32, raw[0..4], .little),
|
|
.target = target,
|
|
};
|
|
}
|
|
};
|
|
|
|
pub const Dev = extern struct {
|
|
hard_links: u32,
|
|
device: u32,
|
|
|
|
pub fn read(rdr: *Io.Reader) !Dev {
|
|
return util.readValueRdr(Dev, rdr);
|
|
}
|
|
};
|
|
pub const ExtDev = extern struct {
|
|
hard_links: u32,
|
|
device: u32,
|
|
xattr_idx: u32,
|
|
|
|
pub fn read(rdr: *Io.Reader) !ExtDev {
|
|
return util.readValue(ExtDev, rdr);
|
|
}
|
|
};
|
|
|
|
pub const Fifo = extern struct {
|
|
hard_links: u32,
|
|
|
|
pub fn read(rdr: *Io.Reader) !Fifo {
|
|
return util.readValueRdr(Fifo, rdr);
|
|
}
|
|
};
|
|
pub const ExtFifo = extern struct {
|
|
hard_links: u32,
|
|
xattr_idx: u32,
|
|
|
|
pub fn read(rdr: *Io.Reader) !ExtFifo {
|
|
return util.readValueRdr(ExtFifo, rdr);
|
|
}
|
|
};
|