Reseting. Again.
This commit is contained in:
Caleb J. Gardner
@@ -1,10 +0,0 @@
|
||||
#!/bin/sh
|
||||
|
||||
zig test \
|
||||
-lc \
|
||||
-lz \
|
||||
-llzma \
|
||||
-lminilzo \
|
||||
-llz4 \
|
||||
-lzstd \
|
||||
src/test.zig
|
||||
-121
@@ -1,121 +0,0 @@
|
||||
//! A squashfs archive read from a file.
|
||||
//! Can be used to directly access File's contents or extract to the filesystem.
|
||||
|
||||
const std = @import("std");
|
||||
const File = std.fs.File;
|
||||
const builtin = @import("builtin");
|
||||
|
||||
const config = @import("config");
|
||||
|
||||
const cDecomp = @import("decomp/misc_c.zig");
|
||||
const Decomp = @import("decomp/zig_decomp.zig");
|
||||
const ExtractionOptions = @import("options.zig");
|
||||
const Inode = @import("inode.zig");
|
||||
const InodeRef = Inode.Ref;
|
||||
const BlockSize = @import("inode_data/file.zig").BlockSize;
|
||||
const SfsFile = @import("file.zig");
|
||||
const Superblock = @import("super.zig").Superblock;
|
||||
const Tables = @import("tables.zig");
|
||||
const MetadataReader = @import("util/metadata.zig");
|
||||
const OffsetFile = @import("util/offset_file.zig");
|
||||
const XattrTable = @import("xattr.zig");
|
||||
|
||||
const Archive = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
|
||||
fil: OffsetFile,
|
||||
|
||||
super: Superblock,
|
||||
|
||||
tables: ?Tables = null,
|
||||
|
||||
decomp: if (config.use_zig_decomp) Decomp.DecompFn else union(enum) {
|
||||
gzip: @import("decomp/gzip.zig"),
|
||||
lzma: @import("decomp/lzma.zig"),
|
||||
lzo: void,
|
||||
xz: @import("decomp/lzma.zig"),
|
||||
lz4: void,
|
||||
zstd: @import("decomp/zstd.zig"),
|
||||
|
||||
pub fn decomp(self: @This(), in: []u8, out: []u8) !usize {
|
||||
return switch (self) {
|
||||
.gzip => |*g| g.decompress(in, out),
|
||||
.zstd => |*z| z.decompress(in, out),
|
||||
.lzma, .xz => |*d| d.decompress(in, out),
|
||||
.lz4 => cDecomp.lz4(in, out),
|
||||
.lzo => cDecomp.lzo(in, out),
|
||||
};
|
||||
}
|
||||
},
|
||||
|
||||
/// Default settings using std.Thread.getCpuCount() threads and the minimum of 4gb or half of system memory for memory usage.
|
||||
pub fn init(alloc: std.mem.Allocator, fil: File, offset: u64) !Archive {
|
||||
var super: Superblock = undefined;
|
||||
const red = try fil.pread(@ptrCast(&super), offset);
|
||||
std.debug.assert(red == @sizeOf(Superblock));
|
||||
try super.validate();
|
||||
const off_fil: OffsetFile = .init(fil, offset);
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.fil = off_fil,
|
||||
.decomp = if (config.use_zig_decomp)
|
||||
switch (super.compression) {
|
||||
.lz4 => return error.Lz4Unsupported,
|
||||
.lzo => return error.LzoUnsupported,
|
||||
.gzip => Decomp.gzip,
|
||||
.lzma => Decomp.lzma,
|
||||
.xz => Decomp.xz,
|
||||
.zstd => Decomp.zstd,
|
||||
}
|
||||
else switch (super.compression) {
|
||||
.gzip => .{ .gzip = .init(alloc) },
|
||||
.zstd => .{ .zstd = .init(alloc) },
|
||||
.xz => .{ .xz = .init(alloc, true) },
|
||||
.lzma => .{ .lzma = .init(alloc, false) },
|
||||
.lzo => .{ .lzo = .{} },
|
||||
.lz4 => .{ .lz4 = .{} },
|
||||
},
|
||||
.super = super,
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: *Archive) void {
|
||||
if (self.tables != null)
|
||||
self.tables.?.deinit();
|
||||
}
|
||||
|
||||
pub fn inode(self: *Archive, alloc: std.mem.Allocator, num: u32) !Inode {
|
||||
if (self.tables == null)
|
||||
self.tables = try .init(alloc, self);
|
||||
const ref = try self.export_table.get(num - 1);
|
||||
var rdr = try self.fil.readerAt(ref.block_start + self.super.inode_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(alloc, &rdr.interface, &self.decomp);
|
||||
try meta.interface.discardAll(ref.block_offset);
|
||||
return try .read(alloc, &meta.interface, self.super.block_size);
|
||||
}
|
||||
|
||||
pub fn root(self: *Archive, alloc: std.mem.Allocator) !SfsFile {
|
||||
if (self.tables == null)
|
||||
self.tables = try .init(alloc, self);
|
||||
var rdr = try self.fil.readerAt(self.super.root_ref.block_start + self.super.inode_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(alloc, &rdr.interface, self.decomp);
|
||||
try meta.interface.discardAll(self.super.root_ref.block_offset);
|
||||
const in: Inode = try .read(alloc, &meta.interface, self.super.block_size);
|
||||
return .init(self, in, "");
|
||||
}
|
||||
|
||||
pub fn open(self: *Archive, alloc: std.mem.Allocator, path: []const u8) !SfsFile {
|
||||
if (self.tables == null)
|
||||
self.tables = try .init(alloc, self);
|
||||
var root_fil = try self.root(alloc);
|
||||
defer if (!SfsFile.pathIsSelf(path)) root_fil.deinit();
|
||||
return root_fil.open(path);
|
||||
}
|
||||
|
||||
pub fn extract(self: Archive, alloc: std.mem.Allocator, path: []const u8, options: ExtractionOptions) !void {
|
||||
var rdr = try self.fil.readerAt(self.super.root_ref.block_start + self.super.inode_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
|
||||
try meta.interface.discardAll(self.super.root_ref.block_offset);
|
||||
const in: Inode = try .read(self.alloc, &meta.interface, self.super.block_size);
|
||||
try in.extractTo(alloc, self, path, options);
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const Decompressor = @This();
|
||||
|
||||
pub const Error = error{
|
||||
OutOfMemory,
|
||||
BadInput,
|
||||
OutputTooSmall,
|
||||
ReadFailed,
|
||||
WriteFailed,
|
||||
EndOfStream,
|
||||
};
|
||||
|
||||
vtable: *const struct {
|
||||
decompress: *const fn (*Decompressor, []u8, []u8) Error!usize = DefaultDecompress,
|
||||
stateless: *const fn (std.mem.Allocator, []u8, []u8) Error!usize,
|
||||
},
|
||||
|
||||
pub fn decompress(self: *Decompressor, in: []u8, out: []u8) Error!usize {
|
||||
return self.vtable.decompress(self, in, out);
|
||||
}
|
||||
|
||||
fn DefaultDecompress(self: *Decompressor, in: []u8, out: []u8) Error!usize {
|
||||
return self.vtable.stateless(std.heap.smp_allocator, in, out);
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
const builtin = @import("builtin");
|
||||
|
||||
const config = @import("config");
|
||||
|
||||
pub const c = @cImport({
|
||||
@cInclude("zlib-ng.h");
|
||||
@cInclude("lzma.h");
|
||||
@cInclude("lz4.h");
|
||||
@cInclude("zstd.h");
|
||||
@cInclude("zstd_errors.h");
|
||||
@cInclude("lzo/minilzo.h");
|
||||
});
|
||||
@@ -1,114 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
const builtin = @import("builtin");
|
||||
|
||||
const Decompressor = @import("../decomp.zig");
|
||||
const c = @import("c.zig").c;
|
||||
const zng_stream = c.zng_stream;
|
||||
|
||||
const ZlibErrors = error{
|
||||
OutOfMemory,
|
||||
OutputBufferTooSmall,
|
||||
BadData,
|
||||
StreamError,
|
||||
Unknown,
|
||||
};
|
||||
|
||||
const Self = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
|
||||
streams: std.AutoHashMap(std.Thread.Id, zng_stream),
|
||||
interface: Decompressor = .{ .vtable = &.{
|
||||
.decompress = decompress,
|
||||
.stateless = stateless,
|
||||
} },
|
||||
|
||||
err: ?ZlibErrors = null,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator) !Self {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.streams = .init(alloc),
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: Self) void {
|
||||
var iter = self.streams.keyIterator();
|
||||
while (iter.next()) |key| {
|
||||
_ = c.inflateEnd(self.streams.getPtr(key).?);
|
||||
}
|
||||
self.streams.deinit(self.alloc);
|
||||
}
|
||||
|
||||
fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
var self: *Self = @fieldParentPtr("interface", decomp);
|
||||
|
||||
var stream = try self.getOrCreate();
|
||||
stream.next_in = in.ptr;
|
||||
stream.avail_in = @truncate(in.len);
|
||||
stream.next_out = out.ptr;
|
||||
stream.avail_out = @truncate(out.len);
|
||||
var res = c.zng_inflateReset(stream);
|
||||
switch (res) {
|
||||
c.Z_OK => {},
|
||||
c.Z_STREAM_ERROR => {
|
||||
self.err = ZlibErrors.StreamError;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
else => {
|
||||
self.err = ZlibErrors.Unknown;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
}
|
||||
res = c.zng_inflate(stream, c.Z_FINISH);
|
||||
switch (res) {
|
||||
c.Z_OK => return stream.total_out,
|
||||
c.Z_MEM_ERROR => {
|
||||
self.err = ZlibErrors.OutOfMemory;
|
||||
return Decompressor.Error.OutOfMemory;
|
||||
},
|
||||
c.Z_BUF_ERROR => {
|
||||
self.err = ZlibErrors.OutputBufferTooSmall;
|
||||
return Decompressor.Error.OutputTooSmall;
|
||||
},
|
||||
c.Z_DATA_ERROR => {
|
||||
self.err = ZlibErrors.BadData;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
else => {
|
||||
self.err = ZlibErrors.Unknown;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
}
|
||||
}
|
||||
inline fn getOrCreate(self: *Self) Decompressor.Error!*zng_stream {
|
||||
const res = try self.streams.getOrPut(std.Thread.getCurrentId());
|
||||
if (res.found_existing) return res.value_ptr;
|
||||
res.value_ptr.* = .{
|
||||
.zalloc = zalloc,
|
||||
.zfree = zfree,
|
||||
.@"opaque" = @ptrCast(self),
|
||||
};
|
||||
return res.value_ptr;
|
||||
}
|
||||
|
||||
fn zalloc(self_ptr: ?*anyopaque, items: c_uint, size: c_uint) callconv(.c) ?*anyopaque {
|
||||
var self: *Self = @ptrCast(@alignCast(self_ptr));
|
||||
return self.alloc.rawAlloc(items * size, .@"1", 0);
|
||||
}
|
||||
fn zfree(self_ptr: ?*anyopaque, alloc_ptr: ?*anyopaque) callconv(.c) void {
|
||||
var self: *Self = @ptrCast(@alignCast(self_ptr));
|
||||
self.alloc.rawFree(@ptrCast(alloc_ptr), .@"1", 0);
|
||||
}
|
||||
|
||||
fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
var out_len = out.len;
|
||||
const res = c.zng_uncompress(out.ptr, &out_len, in.ptr, in.len);
|
||||
return switch (res) {
|
||||
c.Z_OK => out_len,
|
||||
c.Z_MEM_ERROR => Decompressor.Error.OutOfMemory,
|
||||
c.Z_BUF_ERROR => Decompressor.Error.OutputTooSmall,
|
||||
c.Z_DATA_ERROR => Decompressor.Error.BadInput,
|
||||
else => Decompressor.Error.BadInput,
|
||||
};
|
||||
}
|
||||
@@ -1,146 +0,0 @@
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
|
||||
const Decompressor = @import("../decomp.zig");
|
||||
const c = @import("c.zig").c;
|
||||
const stream = c.lzma_stream;
|
||||
|
||||
const Self = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
streams: std.AutoHashMap(std.Thread.Id, stream),
|
||||
|
||||
xz: bool,
|
||||
interface: Decompressor = .{ .vtable = &.{
|
||||
.decompress = decompress,
|
||||
.stateless = stateless,
|
||||
} },
|
||||
|
||||
err: ?LzmaError = null,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, xz: bool) !Self {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.streams = .init(alloc),
|
||||
.xz = xz,
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: Self) void {
|
||||
var iter = self.streams.keyIterator();
|
||||
while (iter.next()) |key|
|
||||
c.lzma_end(self.streams.getPtr(key));
|
||||
self.streams.deinit();
|
||||
}
|
||||
|
||||
pub fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
var self: *Self = @fieldParentPtr("interface", decomp);
|
||||
|
||||
var strm = try self.getOrCreate();
|
||||
strm.next_in = in.ptr;
|
||||
strm.avail_in = in.len;
|
||||
strm.next_out = out.ptr;
|
||||
strm.avail_out = out.len;
|
||||
|
||||
var res = if (self.xz)
|
||||
c.lzma_stream_decoder(strm, in.len * 2, 0)
|
||||
else
|
||||
c.lzma_alone_decoder(strm, in.len * 2);
|
||||
switch (res) {
|
||||
c.LZMA_OK => {},
|
||||
c.LZMA_MEM_ERROR => {
|
||||
self.err = LzmaError.LzmaMemoryError;
|
||||
return Decompressor.Error.OutOfMemory;
|
||||
},
|
||||
c.LZMA_PROG_ERROR => {
|
||||
self.err = LzmaError.LzmaProgramError;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
else => {
|
||||
self.err = LzmaError.Unknown;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
}
|
||||
while (res == c.LZMA_OK)
|
||||
res = c.lzma_code(strm, c.LZMA_RUN);
|
||||
switch (res) {
|
||||
c.LZMA_STREAM_END => return strm.total_out,
|
||||
c.LZMA_MEM_ERROR => {
|
||||
self.err = LzmaError.LzmaMemoryError;
|
||||
return Decompressor.Error.OutOfMemory;
|
||||
},
|
||||
c.LZMA_MEMLIMIT_ERROR => {
|
||||
self.err = LzmaError.LzmaMemoryLimit;
|
||||
return Decompressor.Error.OutOfMemory;
|
||||
},
|
||||
c.LZMA_FORMAT_ERROR => {
|
||||
self.err = LzmaError.LzmaBadFormat;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.LZMA_DATA_ERROR => {
|
||||
self.err = LzmaError.LzmaDataCorrupt;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.LZMA_BUF_ERROR => {
|
||||
self.err = LzmaError.LzmaCannotProgress;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.LZMA_PROG_ERROR => {
|
||||
self.err = LzmaError.LzmaProgramError;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
else => {
|
||||
self.err = LzmaError.Unknown;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
}
|
||||
}
|
||||
pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
var strm = c.lzma_stream{
|
||||
.next_in = in.ptr,
|
||||
.avail_in = in.len,
|
||||
.next_out = out.ptr,
|
||||
.avail_out = out.len,
|
||||
};
|
||||
|
||||
var res = c.lzma_auto_decoder(&strm, out.len * 2, 0);
|
||||
switch (res) {
|
||||
c.LZMA_OK => {},
|
||||
c.LZMA_MEM_ERROR => return Decompressor.Error.OutOfMemory,
|
||||
c.LZMA_PROG_ERROR => return Decompressor.Error.BadInput,
|
||||
else => return Decompressor.Error.BadInput,
|
||||
}
|
||||
while (res == c.LZMA_OK)
|
||||
res = c.lzma_code(&strm, c.LZMA_RUN);
|
||||
return switch (res) {
|
||||
c.LZMA_STREAM_END => strm.total_out,
|
||||
c.LZMA_MEM_ERROR => Decompressor.Error.OutOfMemory,
|
||||
c.LZMA_MEMLIMIT_ERROR => Decompressor.Error.OutOfMemory,
|
||||
c.LZMA_FORMAT_ERROR => Decompressor.Error.BadInput,
|
||||
c.LZMA_DATA_ERROR => Decompressor.Error.BadInput,
|
||||
c.LZMA_BUF_ERROR => Decompressor.Error.BadInput,
|
||||
c.LZMA_PROG_ERROR => Decompressor.Error.BadInput,
|
||||
else => Decompressor.Error.BadInput,
|
||||
};
|
||||
}
|
||||
|
||||
inline fn getOrCreate(self: *Self) Decompressor.Error!*stream {
|
||||
const res = try self.streams.getOrPut(std.Thread.getCurrentId());
|
||||
if (res.found_existing) return res.value_ptr;
|
||||
|
||||
// Ideally, the zero value should be LZMA_STREAM_INIT, but translate-c can't handle it properly.
|
||||
// According to lzma, setting it to entirely zero values *should* work.
|
||||
// res.value_ptr.* = c.LZMA_STREAM_INIT;
|
||||
res.value_ptr.* = std.mem.zeroInit(stream, .{});
|
||||
return res.value_ptr;
|
||||
}
|
||||
|
||||
pub const LzmaError = error{
|
||||
OutOfMemory,
|
||||
LzmaMemoryError,
|
||||
LzmaMemoryLimit,
|
||||
LzmaBadFormat,
|
||||
LzmaDataCorrupt,
|
||||
LzmaCannotProgress,
|
||||
LzmaProgramError,
|
||||
Unknown,
|
||||
};
|
||||
@@ -1,43 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const Decompressor = @import("../decomp.zig");
|
||||
const c = @import("c.zig").c;
|
||||
|
||||
pub const Lzo = struct {
|
||||
interface: Decompressor = .{ .vtable = &.{ .stateless = lzo } },
|
||||
};
|
||||
|
||||
fn lzo(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
var res = c.lzo_init();
|
||||
if (res != 0) return Decompressor.Error.BadInput;
|
||||
var out_len: usize = out.len;
|
||||
res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &out_len, null);
|
||||
|
||||
return switch (res) {
|
||||
c.LZO_E_OK => out_len,
|
||||
c.LZO_E_OUT_OF_MEMORY => Decompressor.Error.OutOfMemory,
|
||||
c.LZO_E_ERROR,
|
||||
c.LZO_E_INPUT_OVERRUN,
|
||||
c.LZO_E_LOOKBEHIND_OVERRUN,
|
||||
c.LZO_E_EOF_NOT_FOUND,
|
||||
c.LZO_E_NOT_YET_IMPLEMENTED,
|
||||
c.LZO_E_INVALID_ARGUMENT,
|
||||
c.LZO_E_INVALID_ALIGNMENT,
|
||||
=> Decompressor.Error.BadInput,
|
||||
c.LZO_E_INPUT_NOT_CONSUMED,
|
||||
c.LZO_E_OUTPUT_NOT_CONSUMED,
|
||||
c.LZO_E_OUTPUT_OVERRUN,
|
||||
=> Decompressor.Error.OutputTooSmall,
|
||||
else => Decompressor.Error.BadInput,
|
||||
};
|
||||
}
|
||||
|
||||
pub const Lz4 = struct {
|
||||
interface: Decompressor = .{ .vtable = &.{ .stateless = lz4 } },
|
||||
};
|
||||
|
||||
fn lz4(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
const res = c.LZ4_decompress_safe(in.ptr, out.ptr, @intCast(in.len), @intCast(out.len));
|
||||
if (res > 0) return @abs(res);
|
||||
return Decompressor.Error.BadInput; // TODO: Find out what error values it can return.
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
const builtin = @import("builtin");
|
||||
|
||||
const Decompressor = @import("../decomp.zig");
|
||||
|
||||
pub const Gzip = struct {
|
||||
interface: Decompressor = .{ .vtable = &.{ .stateless = gzip } },
|
||||
};
|
||||
|
||||
pub fn gzip(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
|
||||
var rdr: Reader = .fixed(in);
|
||||
const buf = try alloc.alloc(u8, out.len);
|
||||
defer alloc.free(buf);
|
||||
var decomp = std.compress.flate.Decompress.init(&rdr, .zlib, buf);
|
||||
return decomp.reader.readSliceShort(out);
|
||||
}
|
||||
|
||||
pub const Lzma = struct {
|
||||
interface: Decompressor = .{ .vtable = &.{ .stateless = lzma } },
|
||||
};
|
||||
|
||||
pub fn lzma(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
|
||||
var rdr: Reader = .fixed(in);
|
||||
var decomp = try std.compress.lzma.decompress(alloc, rdr.adaptToOldInterface());
|
||||
return decomp.read(out);
|
||||
}
|
||||
|
||||
pub const Xz = struct {
|
||||
interface: Decompressor = .{ .vtable = &.{ .stateless = xz } },
|
||||
};
|
||||
|
||||
pub fn xz(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
|
||||
var rdr: Reader = .fixed(in);
|
||||
var decomp = try std.compress.xz.decompress(alloc, rdr.adaptToOldInterface());
|
||||
return decomp.read(out);
|
||||
}
|
||||
|
||||
pub const Zstd = struct {
|
||||
interface: Decompressor = .{ .vtable = &.{ .stateless = zstd } },
|
||||
};
|
||||
|
||||
pub fn zstd(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
|
||||
var rdr: Reader = .fixed(in);
|
||||
const buf = try alloc.alloc(u8, 1024 * 1024);
|
||||
defer alloc.free(buf);
|
||||
var decomp = std.compress.zstd.Decompress.init(&rdr, buf, .{});
|
||||
return decomp.reader.readSliceShort(out) catch |err| {
|
||||
return decomp.err orelse err;
|
||||
};
|
||||
}
|
||||
@@ -1,216 +0,0 @@
|
||||
const std = @import("std");
|
||||
const builtin = @import("builtin");
|
||||
|
||||
const Decompressor = @import("../decomp.zig");
|
||||
const c = @import("c.zig").c;
|
||||
const DCtx = c.ZSTD_DCtx;
|
||||
|
||||
const Self = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
ctx: std.AutoHashMap(std.Thread.Id, *DCtx),
|
||||
|
||||
interface: Decompressor = .{ .vtable = &.{
|
||||
.decompress = decompress,
|
||||
.stateless = stateless,
|
||||
} },
|
||||
err: ?ZstdError = null,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator) !Self {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.ctx = .init(alloc),
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: Self) void {
|
||||
var iter = self.ctx.keyIterator();
|
||||
while (iter.next()) |key| {
|
||||
_ = c.ZSTD_freeDCtx(self.ctx.getPtr(key));
|
||||
}
|
||||
self.ctx.deinit(self.alloc);
|
||||
}
|
||||
|
||||
pub fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
var self: *Self = @fieldParentPtr("interface", decomp);
|
||||
|
||||
const ctx = try self.getOrCreate();
|
||||
const res = c.ZSTD_decompressDCtx(ctx, out.ptr, out.len, in.ptr, in.len);
|
||||
try self.checkError(res);
|
||||
return res;
|
||||
}
|
||||
inline fn getOrCreate(self: *Self) Decompressor.Error!*DCtx {
|
||||
const res = try self.ctx.getOrPut(std.Thread.getCurrentId());
|
||||
if (res.found_existing) {
|
||||
try self.checkError(c.ZSTD_DCtx_reset(res.value_ptr.*, c.ZSTD_reset_session_only));
|
||||
return res.value_ptr.*;
|
||||
}
|
||||
res.value_ptr.* = c.ZSTD_createDCtx() orelse return Decompressor.Error.OutOfMemory;
|
||||
return res.value_ptr.*;
|
||||
}
|
||||
|
||||
fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
|
||||
const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
|
||||
if (c.ZSTD_isError(res) == 0) return res;
|
||||
return switch (c.ZSTD_getErrorCode(res)) {
|
||||
c.ZSTD_error_memory_allocation => Decompressor.Error.OutOfMemory,
|
||||
c.ZSTD_error_workSpace_tooSmall,
|
||||
c.ZSTD_error_dstSize_tooSmall,
|
||||
c.ZSTD_error_dstBuffer_null,
|
||||
c.ZSTD_error_noForwardProgress_destFull,
|
||||
=> Decompressor.Error.OutputTooSmall,
|
||||
else => Decompressor.Error.BadInput,
|
||||
};
|
||||
}
|
||||
|
||||
inline fn checkError(self: *Self, res: usize) Decompressor.Error!void {
|
||||
if (res == 0) return;
|
||||
if (c.ZSTD_isError(res) == 0) return;
|
||||
switch (c.ZSTD_getErrorCode(res)) {
|
||||
c.ZSTD_error_prefix_unknown => {
|
||||
self.err = ZstdError.PrefixUnknown;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_version_unsupported => {
|
||||
self.err = ZstdError.VersionUnsupported;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_frameParameter_unsupported => {
|
||||
self.err = ZstdError.FrameParameterUnsupported;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_frameParameter_windowTooLarge => {
|
||||
self.err = ZstdError.FrameParameterWindowTooLarge;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_corruption_detected => {
|
||||
self.err = ZstdError.CorruptionDetected;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_checksum_wrong => {
|
||||
self.err = ZstdError.ChecksumWrong;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_literals_headerWrong => {
|
||||
self.err = ZstdError.LiteralsHeaderWrong;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_dictionary_corrupted => {
|
||||
self.err = ZstdError.DictionaryCorrupted;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_dictionary_wrong => {
|
||||
self.err = ZstdError.DictionaryWrong;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_dictionaryCreation_failed => {
|
||||
self.err = ZstdError.DictionaryCreationFailed;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_parameter_unsupported => {
|
||||
self.err = ZstdError.ParameterUnsupported;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_parameter_combination_unsupported => {
|
||||
self.err = ZstdError.ParameterCombinationUnsupported;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_parameter_outOfBound => {
|
||||
self.err = ZstdError.ParameterOutOfBound;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_tableLog_tooLarge => {
|
||||
self.err = ZstdError.TableLogTooLarge;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_maxSymbolValue_tooLarge => {
|
||||
self.err = ZstdError.MaxSymbolValueTooLarge;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_maxSymbolValue_tooSmall => {
|
||||
self.err = ZstdError.MaxSymbolValueTooSmall;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_stabilityCondition_notRespected => {
|
||||
self.err = ZstdError.StabilityConditionNotRespected;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_stage_wrong => {
|
||||
self.err = ZstdError.StageWrong;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_init_missing => {
|
||||
self.err = ZstdError.InitMissing;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_memory_allocation => {
|
||||
self.err = ZstdError.MemoryAllocation;
|
||||
return Decompressor.Error.OutOfMemory;
|
||||
},
|
||||
c.ZSTD_error_workSpace_tooSmall => {
|
||||
self.err = ZstdError.WorkSpaceTooSmall;
|
||||
return Decompressor.Error.OutputTooSmall;
|
||||
},
|
||||
c.ZSTD_error_dstSize_tooSmall => {
|
||||
self.err = ZstdError.DstSizeTooSmall;
|
||||
return Decompressor.Error.OutputTooSmall;
|
||||
},
|
||||
c.ZSTD_error_srcSize_wrong => {
|
||||
self.err = ZstdError.SrcSizeWrong;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
c.ZSTD_error_dstBuffer_null => {
|
||||
self.err = ZstdError.DstBufferNull;
|
||||
return Decompressor.Error.OutputTooSmall;
|
||||
},
|
||||
c.ZSTD_error_noForwardProgress_destFull => {
|
||||
self.err = ZstdError.NoForwardProgressDestFull;
|
||||
return Decompressor.Error.OutputTooSmall;
|
||||
},
|
||||
c.ZSTD_error_noForwardProgress_inputEmpty => {
|
||||
self.err = ZstdError.NoForwardProgressInputEmpty;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
else => {
|
||||
self.err = ZstdError.Generic;
|
||||
return Decompressor.Error.BadInput;
|
||||
},
|
||||
}
|
||||
}
|
||||
pub const ZstdError = error{
|
||||
OutOfMemory,
|
||||
Generic,
|
||||
PrefixUnknown,
|
||||
VersionUnsupported,
|
||||
FrameParameterUnsupported,
|
||||
FrameParameterWindowTooLarge,
|
||||
CorruptionDetected,
|
||||
ChecksumWrong,
|
||||
LiteralsHeaderWrong,
|
||||
DictionaryCorrupted,
|
||||
DictionaryWrong,
|
||||
DictionaryCreationFailed,
|
||||
ParameterUnsupported,
|
||||
ParameterCombinationUnsupported,
|
||||
ParameterOutOfBound,
|
||||
TableLogTooLarge,
|
||||
MaxSymbolValueTooLarge,
|
||||
MaxSymbolValueTooSmall,
|
||||
CannotProduceUncompressedBlock,
|
||||
StabilityConditionNotRespected,
|
||||
StageWrong,
|
||||
InitMissing,
|
||||
MemoryAllocation,
|
||||
WorkSpaceTooSmall,
|
||||
DstSizeTooSmall,
|
||||
SrcSizeWrong,
|
||||
DstBufferNull,
|
||||
NoForwardProgressDestFull,
|
||||
NoForwardProgressInputEmpty,
|
||||
FrameIndexTooLarge,
|
||||
SeekableIo,
|
||||
DstBufferWrong,
|
||||
SrcBufferWrong,
|
||||
SequenceProducerFailed,
|
||||
ExternalSequencesInvalid,
|
||||
MaxCode,
|
||||
};
|
||||
@@ -1,60 +0,0 @@
|
||||
//! Directory entry from the directory table.
|
||||
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
|
||||
const InodeType = @import("inode.zig").InodeType;
|
||||
|
||||
const Entry = @This();
|
||||
|
||||
const Header = extern struct { // use extern due to bad alignment with packed.
|
||||
count: u32,
|
||||
block_start: u32,
|
||||
num: u32,
|
||||
};
|
||||
|
||||
const RawEntry = packed struct {
|
||||
offset: u16,
|
||||
inode_offset: i16,
|
||||
inode_type: InodeType,
|
||||
name_size: u16,
|
||||
};
|
||||
|
||||
block_start: u32,
|
||||
block_offset: u16,
|
||||
num: u32,
|
||||
inode_type: InodeType,
|
||||
name: []const u8,
|
||||
|
||||
pub fn readDir(alloc: std.mem.Allocator, rdr: *Reader, size: u32) ![]Entry {
|
||||
var cur_red: u32 = 3; // start at 3 due to "." & ".." being counted in the dir size.
|
||||
var hdr: Header = undefined;
|
||||
var raw: RawEntry = undefined;
|
||||
var out: std.ArrayList(Entry) = try .initCapacity(alloc, 100); // Start out with a decent capacity instead of needing to allocate per header.
|
||||
errdefer out.deinit(alloc);
|
||||
while (cur_red < size) {
|
||||
try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
|
||||
cur_red += @sizeOf(Header);
|
||||
try out.ensureUnusedCapacity(alloc, hdr.count + 1);
|
||||
for (0..hdr.count + 1) |_| {
|
||||
try rdr.readSliceEndian(RawEntry, @ptrCast(&raw), .little);
|
||||
const name = try alloc.alloc(u8, raw.name_size + 1);
|
||||
errdefer alloc.free(name);
|
||||
try rdr.readSliceEndian(u8, name, .little);
|
||||
const val = out.addOneAssumeCapacity();
|
||||
val.* = .{
|
||||
.block_start = hdr.block_start,
|
||||
.block_offset = raw.offset,
|
||||
.num = @abs(hdr.num + raw.offset),
|
||||
.inode_type = raw.inode_type,
|
||||
.name = name,
|
||||
};
|
||||
cur_red += @sizeOf(RawEntry) + raw.name_size + 1;
|
||||
}
|
||||
}
|
||||
return out.toOwnedSlice(alloc);
|
||||
}
|
||||
|
||||
pub fn deinit(self: Entry, alloc: std.mem.Allocator) void {
|
||||
alloc.free(self.name);
|
||||
}
|
||||
-202
@@ -1,202 +0,0 @@
|
||||
//! A file/directory within the squashfs archive.
|
||||
|
||||
const std = @import("std");
|
||||
const File = std.fs.File;
|
||||
const WaitGroup = std.Thread.WaitGroup;
|
||||
const Mutex = std.Thread.Mutex;
|
||||
|
||||
const Archive = @import("archive.zig");
|
||||
const DirEntry = @import("dir_entry.zig");
|
||||
const ExtractionOptions = @import("options.zig");
|
||||
const Inode = @import("inode.zig");
|
||||
const BlockSize = @import("inode_data/file.zig").BlockSize;
|
||||
const DataReader = @import("util/data.zig");
|
||||
const MetadataReader = @import("util/metadata.zig");
|
||||
|
||||
const FileError = error{
|
||||
NotDirectory,
|
||||
NotRegularFile,
|
||||
NotSymlink,
|
||||
NotDevice,
|
||||
NotFound,
|
||||
ExtractionPathExists,
|
||||
};
|
||||
|
||||
const SfsFile = @This();
|
||||
|
||||
archive: *Archive,
|
||||
|
||||
inode: Inode,
|
||||
name: []const u8,
|
||||
|
||||
/// Initialize a new File.
|
||||
/// name is copied to the File so can be safely freed afterwards.
|
||||
pub fn init(archive: *Archive, inode: Inode, name: []const u8) !SfsFile {
|
||||
const new_name = try archive.allocator().alloc(u8, name.len);
|
||||
@memcpy(new_name, name);
|
||||
return .{
|
||||
.archive = archive,
|
||||
.inode = inode,
|
||||
.name = new_name,
|
||||
};
|
||||
}
|
||||
pub fn fromEntry(archive: *Archive, entry: DirEntry) !SfsFile {
|
||||
var rdr = try archive.fil.readerAt(entry.block_start + archive.super.inode_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(archive.allocator(), &rdr.interface, archive.decomp);
|
||||
try meta.interface.discardAll(entry.block_offset);
|
||||
const inode: Inode = try .read(archive.allocator(), &meta.interface, archive.super.block_size);
|
||||
errdefer inode.deinit(archive.allocator());
|
||||
return .init(archive, inode, entry.name);
|
||||
}
|
||||
|
||||
pub fn deinit(self: SfsFile) void {
|
||||
var alloc = self.archive.allocator();
|
||||
alloc.free(self.name);
|
||||
self.inode.deinit(alloc);
|
||||
}
|
||||
|
||||
fn getEntries(self: SfsFile) ![]DirEntry {
|
||||
return self.inode.dirEntries(self.archive.allocator(), self.archive.*);
|
||||
}
|
||||
|
||||
pub fn ownerUid(self: SfsFile) !u16 {
|
||||
return self.archive.id(self.inode.hdr.uid_idx);
|
||||
}
|
||||
pub fn ownerGid(self: SfsFile) !u16 {
|
||||
return self.archive.id(self.inode.hdr.gid_idx);
|
||||
}
|
||||
pub fn permissions(self: SfsFile) u16 {
|
||||
return self.inode.hdr.permissions;
|
||||
}
|
||||
|
||||
pub fn isRegular(self: SfsFile) bool {
|
||||
return switch (self.inode.hdr.inode_type) {
|
||||
.file, .ext_file => true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
/// The returned DataReader will no longer work if the File's deinit function is called
|
||||
/// or, more specifically, it's inode's deinit function is called.
|
||||
pub fn dataReader(self: SfsFile) !DataReader {
|
||||
return self.inode.dataReader(self.archive);
|
||||
}
|
||||
|
||||
pub fn isDir(self: SfsFile) bool {
|
||||
return switch (self.inode.hdr.inode_type) {
|
||||
.dir, .ext_dir => true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
pub fn iterate(self: SfsFile) !Iterator {
|
||||
if (!self.isDir()) return FileError.NotDirectory;
|
||||
return .{
|
||||
.entries = try self.getEntries(),
|
||||
.archive = self.archive,
|
||||
};
|
||||
}
|
||||
/// Open a sub-file/folder within a directory at the given path.
|
||||
/// If path is "", ".", "/", or "./", this File is returned.
|
||||
pub fn open(self: SfsFile, alloc: std.mem.Allocator, path: []const u8) !SfsFile {
|
||||
if (!self.isDir()) return FileError.NotDirectory;
|
||||
if (pathIsSelf(path)) return self;
|
||||
|
||||
// Recursively stip ending & leading path separators.
|
||||
if (path[0] == '/') return self.open(path[1..]);
|
||||
if (path[path.len - 1] == '/') return self.open(path[0 .. path.len - 1]);
|
||||
|
||||
const idx = std.mem.indexOf(u8, path, "/") orelse path.len;
|
||||
const first_element = path[0..idx];
|
||||
if (std.mem.eql(u8, first_element, ".")) return self.open(path[idx + 1 ..]);
|
||||
const entries = try self.getEntries();
|
||||
defer {
|
||||
for (entries) |e| {
|
||||
e.deinit(alloc);
|
||||
}
|
||||
alloc.free(entries);
|
||||
}
|
||||
var cur_slice = entries;
|
||||
var split = cur_slice.len / 2;
|
||||
while (cur_slice.len > 0) {
|
||||
split = cur_slice.len / 2;
|
||||
const comp = std.mem.order(u8, first_element, cur_slice[split].name);
|
||||
switch (comp) {
|
||||
.eq => {
|
||||
var fil: SfsFile = try .fromEntry(self.archive, cur_slice[split]);
|
||||
if (idx == path.len) {
|
||||
return fil;
|
||||
}
|
||||
defer fil.deinit();
|
||||
return fil.open(alloc, path[idx + 1 ..]);
|
||||
},
|
||||
.lt => cur_slice = cur_slice[0..split],
|
||||
.gt => cur_slice = cur_slice[split + 1 ..],
|
||||
}
|
||||
}
|
||||
return FileError.NotFound;
|
||||
}
|
||||
|
||||
pub fn isSymlink(self: SfsFile) bool {
|
||||
return switch (self.inode.hdr.inode_type) {
|
||||
.symlink, .ext_symlink => true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
pub fn symlinkPath(self: SfsFile) ![]const u8 {
|
||||
if (!self.isSymlink()) return FileError.NotSymlink;
|
||||
return switch (self.inode.data) {
|
||||
.symlink => |s| s.target,
|
||||
.ext_symlink => |s| s.target,
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
/// Check if the File is a block or character device.
|
||||
pub fn isDevice(self: SfsFile) bool {
|
||||
return switch (self.inode.hdr.inode_type) {
|
||||
.block_dev, .char_dev, .ext_block_dev, .ext_char_dev => true,
|
||||
else => false,
|
||||
};
|
||||
}
|
||||
/// If the File is a block or character device, get's it's device number.
|
||||
pub fn devNum(self: SfsFile) !u32 {
|
||||
if (!self.isDevice()) return FileError.NotDevice;
|
||||
return switch (self.inode.data) {
|
||||
.block_dev, .char_dev => |d| d.dev,
|
||||
.ext_block_dev, .ext_char_dev => |d| d.dev,
|
||||
else => unreachable,
|
||||
};
|
||||
}
|
||||
|
||||
/// Extract the given File to the path. If File is a regular file, the path must be a directory or not exist.
|
||||
/// If the gievn path is a folder, the File's contents will be extracted within.
|
||||
pub fn extract(self: *SfsFile, alloc: std.mem.Allocator, path: []const u8, options: ExtractionOptions) !void {
|
||||
return self.inode.extractToThreaded(alloc, self.archive, path, options);
|
||||
}
|
||||
|
||||
/// Utility function.
|
||||
pub fn pathIsSelf(path: []const u8) bool {
|
||||
if (path.len == 0) return true;
|
||||
if (path.len == 1 and (path[0] == '/' or path[0] == '.')) return true;
|
||||
if (path.len == 2 and (path[0] == '.' and path[1] == '/')) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
pub const Iterator = struct {
|
||||
entries: []DirEntry,
|
||||
archive: *Archive,
|
||||
|
||||
idx: u32 = 0,
|
||||
|
||||
pub fn next(self: *Iterator) !?SfsFile {
|
||||
if (self.idx >= self.entries.len) return null;
|
||||
defer self.idx += 1;
|
||||
return try SfsFile.fromEntry(self.archive, self.entries[self.idx]);
|
||||
}
|
||||
pub fn deinit(self: Iterator) void {
|
||||
var alloc = self.archive.allocator();
|
||||
for (self.entries) |e| {
|
||||
e.deinit(alloc);
|
||||
}
|
||||
alloc.free(self.entries);
|
||||
}
|
||||
};
|
||||
-189
@@ -1,189 +0,0 @@
|
||||
//! A file-system object. Represents a File or directory.
|
||||
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
const WaitGroup = std.Thread.WaitGroup;
|
||||
const Pool = std.Thread.Pool;
|
||||
const Mutex = std.Thread.Mutex;
|
||||
|
||||
const Archive = @import("archive.zig");
|
||||
const DirEntry = @import("dir_entry.zig");
|
||||
const ExtractionOptions = @import("options.zig");
|
||||
const dir = @import("inode_data/dir.zig");
|
||||
const file = @import("inode_data/file.zig");
|
||||
const misc = @import("inode_data/misc.zig");
|
||||
const Tables = @import("tables.zig");
|
||||
const DataReader = @import("util/data.zig");
|
||||
const ThreadedDataReader = @import("util/data_threaded.zig");
|
||||
const InodeExtract = @import("util/extract.zig");
|
||||
const InodeFinish = @import("util/inode_finish.zig");
|
||||
const FinishUnion = InodeFinish.FinishUnion;
|
||||
const MetadataReader = @import("util/metadata.zig");
|
||||
|
||||
pub const Ref = packed struct {
|
||||
block_offset: u16,
|
||||
block_start: u32,
|
||||
_: u16,
|
||||
};
|
||||
|
||||
pub const InodeType = enum(u16) {
|
||||
dir = 1,
|
||||
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 InodeData = union(InodeType) {
|
||||
dir: dir.Dir,
|
||||
file: file.File,
|
||||
symlink: misc.Symlink,
|
||||
block_dev: misc.Dev,
|
||||
char_dev: misc.Dev,
|
||||
fifo: misc.IPC,
|
||||
socket: misc.IPC,
|
||||
ext_dir: dir.ExtDir,
|
||||
ext_file: file.ExtFile,
|
||||
ext_symlink: misc.ExtSymlink,
|
||||
ext_block_dev: misc.ExtDev,
|
||||
ext_char_dev: misc.ExtDev,
|
||||
ext_fifo: misc.ExtIPC,
|
||||
ext_socket: misc.ExtIPC,
|
||||
};
|
||||
|
||||
pub const Header = packed struct {
|
||||
inode_type: InodeType,
|
||||
permissions: u16,
|
||||
uid_idx: u16,
|
||||
gid_idx: u16,
|
||||
mod_time: u32,
|
||||
num: u32,
|
||||
};
|
||||
|
||||
const Inode = @This();
|
||||
|
||||
hdr: Header,
|
||||
data: InodeData,
|
||||
|
||||
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 readFromEntry(alloc: std.mem.Allocator, archive: Archive, entry: DirEntry) !Inode {
|
||||
var rdr = try archive.fil.readerAt(archive.super.inode_start + entry.block_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(alloc, &rdr.interface, archive.decomp);
|
||||
try meta.interface.discardAll(entry.block_offset);
|
||||
return read(alloc, &meta.interface, archive.super.block_size);
|
||||
}
|
||||
|
||||
pub fn deinit(self: Inode, 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 => {},
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the data reader for a file inode.
|
||||
pub fn dataReader(self: Inode, alloc: std.mem.Allocator, archive: Archive, tables: *Tables) !DataReader {
|
||||
return switch (self.hdr.inode_type) {
|
||||
.file => readerFromData(alloc, archive, tables, self.data.file),
|
||||
.ext_file => readerFromData(alloc, archive, tables, self.data.ext_file),
|
||||
else => error.NotRegularFile,
|
||||
};
|
||||
}
|
||||
fn readerFromData(alloc: std.mem.Allocator, archive: Archive, tables: *Tables, data: anytype) !DataReader {
|
||||
var out: DataReader = .init(alloc, archive, data.block_sizes, data.block_start, data.size);
|
||||
if (data.frag_idx != 0xFFFFFFFF)
|
||||
out.addFragment(try tables.frag_table.get(data.frag_idx), data.frag_block_offset);
|
||||
return out;
|
||||
}
|
||||
|
||||
/// Get the directory entries for a directory inode.
|
||||
pub fn dirEntries(self: Inode, alloc: std.mem.Allocator, archive: Archive) ![]DirEntry {
|
||||
return switch (self.hdr.inode_type) {
|
||||
.dir => entriesFromData(alloc, archive, self.data.dir),
|
||||
.ext_dir => entriesFromData(alloc, archive, self.data.ext_dir),
|
||||
else => error.NotDirectory,
|
||||
};
|
||||
}
|
||||
fn entriesFromData(alloc: std.mem.Allocator, archive: Archive, data: anytype) ![]DirEntry {
|
||||
var rdr = try archive.fil.readerAt(archive.super.dir_start + data.block_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(alloc, &rdr.interface, archive.decomp);
|
||||
try meta.interface.discardAll(data.block_offset);
|
||||
return DirEntry.readDir(alloc, &meta.interface, data.size);
|
||||
}
|
||||
|
||||
/// Returns the xattr index for the given inode. If the inode isn't an extended variant or doesn't have any, the u32 max is returned (0xFFFFFFFF).
|
||||
pub fn xattrIdx(self: Inode) u32 {
|
||||
return switch (self.data) {
|
||||
.ext_dir => |d| d.xattr_id,
|
||||
.ext_file => |f| f.xattr_idx,
|
||||
.ext_symlink => |s| s.xattr_idx,
|
||||
.ext_block_dev, .ext_char_dev => |d| d.xattr_idx,
|
||||
.ext_fifo, .ext_socket => |i| i.xattr_idx,
|
||||
else => 0xFFFFFFFF,
|
||||
};
|
||||
}
|
||||
|
||||
/// Applies the Inode's metadata to the given File.
|
||||
/// Mod time is always set, but permissions and xattrs are set based on the given ExtractionOptions.
|
||||
pub fn setMetadata(self: Inode, alloc: std.mem.Allocator, tables: *Tables, fil: std.fs.File, options: ExtractionOptions) !void {
|
||||
const time = @as(i128, self.hdr.mod_time) * 1000000000;
|
||||
try fil.updateTimes(time, time);
|
||||
if (!options.ignore_permissions) {
|
||||
try fil.chmod(self.hdr.permissions);
|
||||
try fil.chown(try tables.id_table.get(self.hdr.uid_idx), try tables.id_table.get(self.hdr.gid_idx));
|
||||
}
|
||||
if (!options.ignore_xattr) {
|
||||
const idx = self.xattrIdx();
|
||||
if (idx == 0xFFFFFFFF) return;
|
||||
const xattrs = try tables.xattr_table.get(alloc, idx);
|
||||
defer alloc.free(xattrs);
|
||||
for (xattrs) |kv| {
|
||||
const res = std.os.linux.fsetxattr(fil.handle, kv.key, kv.value.ptr, kv.value.len, 0);
|
||||
alloc.free(kv.key);
|
||||
alloc.free(kv.value);
|
||||
if (res != 0) {
|
||||
if (options.verbose)
|
||||
options.verbose_writer.?.print("fsetxattr has result of: {}\n", .{res}) catch {};
|
||||
return error.SetXattr;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Extract the inode to the given path.
|
||||
pub fn extractTo(self: Inode, alloc: std.mem.Allocator, archive: Archive, path: []const u8, options: ExtractionOptions) !void {
|
||||
return InodeExtract.extractTo(alloc, self, archive, path, options);
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
const Reader = @import("std").Io.Reader;
|
||||
|
||||
pub const Dir = packed struct {
|
||||
block_start: u32,
|
||||
hard_links: u32,
|
||||
size: u16,
|
||||
block_offset: u16,
|
||||
parent_num: u32,
|
||||
|
||||
pub fn read(rdr: *Reader) !Dir {
|
||||
var d: Dir = undefined;
|
||||
try rdr.readSliceEndian(Dir, @ptrCast(&d), .little);
|
||||
return d;
|
||||
}
|
||||
};
|
||||
|
||||
pub const ExtDir = packed struct {
|
||||
hard_links: u32,
|
||||
size: u32,
|
||||
block_start: u32,
|
||||
parent_num: u32,
|
||||
idx_count: u16,
|
||||
block_offset: u16,
|
||||
xattr_id: u32,
|
||||
// index: []DirIndex
|
||||
|
||||
pub fn read(rdr: *Reader) !ExtDir {
|
||||
var d: ExtDir = undefined;
|
||||
try rdr.readSliceEndian(Dir, @ptrCast(&d), .little);
|
||||
return d;
|
||||
}
|
||||
};
|
||||
@@ -1,76 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
|
||||
pub const BlockSize = packed struct {
|
||||
size: u24,
|
||||
uncompressed: bool,
|
||||
_: u7,
|
||||
};
|
||||
|
||||
pub const File = struct {
|
||||
block_start: u32, // bytes 0-3
|
||||
frag_idx: u32, // bytes 4-7
|
||||
frag_block_offset: u32, // bytes 8-11
|
||||
size: u32, // bytes 12-15
|
||||
block_sizes: []BlockSize,
|
||||
|
||||
pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
|
||||
var start: [16]u8 = undefined;
|
||||
try rdr.readSliceAll(&start);
|
||||
const frag_idx: u32 = std.mem.readInt(u32, start[4..8], .little);
|
||||
const size: u32 = std.mem.readInt(u32, start[12..16], .little);
|
||||
var num_blocks: u32 = size / block_size;
|
||||
if (size % block_size != 0 and 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 = std.mem.readInt(u32, start[0..4], .little),
|
||||
.frag_idx = frag_idx,
|
||||
.frag_block_offset = std.mem.readInt(u32, start[8..12], .little),
|
||||
.size = size,
|
||||
.block_sizes = sizes,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: File, alloc: std.mem.Allocator) void {
|
||||
alloc.free(self.block_sizes);
|
||||
}
|
||||
};
|
||||
|
||||
pub const ExtFile = struct {
|
||||
block_start: u64, // bytes 0-7
|
||||
size: u64, // bytes 8-15
|
||||
sparse: u64, // bytes 16-23
|
||||
hard_links: u32, // bytes 24-27
|
||||
frag_idx: u32, // bytes 28-31
|
||||
frag_block_offset: u32, // bytes 32-35
|
||||
xattr_idx: u32, // bytes 36-39
|
||||
block_sizes: []BlockSize,
|
||||
|
||||
pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !ExtFile {
|
||||
var start: [40]u8 = undefined;
|
||||
try rdr.readSliceAll(&start);
|
||||
const frag_idx: u32 = std.mem.readInt(u32, start[28..32], .little);
|
||||
const size: u64 = std.mem.readInt(u64, start[8..16], .little);
|
||||
var num_blocks: u32 = @truncate(size / block_size);
|
||||
if (size % block_size != 0 and 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 = std.mem.readInt(u64, start[0..8], .little),
|
||||
.size = size,
|
||||
.sparse = std.mem.readInt(u64, start[16..24], .little),
|
||||
.hard_links = std.mem.readInt(u32, start[24..28], .little),
|
||||
.frag_idx = frag_idx,
|
||||
.frag_block_offset = std.mem.readInt(u32, start[32..36], .little),
|
||||
.xattr_idx = std.mem.readInt(u32, start[36..40], .little),
|
||||
.block_sizes = sizes,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: ExtFile, alloc: std.mem.Allocator) void {
|
||||
alloc.free(self.block_sizes);
|
||||
}
|
||||
};
|
||||
@@ -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 = packed 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 = packed 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 = packed 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 = packed 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;
|
||||
}
|
||||
};
|
||||
@@ -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,
|
||||
/// 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(),
|
||||
};
|
||||
}
|
||||
@@ -1,2 +0,0 @@
|
||||
pub const Archive = @import("archive.zig");
|
||||
pub const ExtractionOptions = @import("options.zig");
|
||||
@@ -1,69 +0,0 @@
|
||||
const std = @import("std");
|
||||
const math = std.math;
|
||||
|
||||
const InodeRef = @import("inode.zig").Ref;
|
||||
|
||||
const SQUASHFS_MAGIC: u32 = std.mem.readInt(u32, "hsqs", .little);
|
||||
|
||||
const SuperblockError = error{
|
||||
InvalidMagic,
|
||||
InvalidBlockLog,
|
||||
InvalidVersion,
|
||||
InvalidCheck,
|
||||
};
|
||||
|
||||
/// A squashfs Superblock
|
||||
pub const Superblock = packed struct {
|
||||
magic: u32,
|
||||
inode_count: u32,
|
||||
mod_time: u32,
|
||||
block_size: u32,
|
||||
frag_count: u32,
|
||||
compression: enum(u16) {
|
||||
gzip = 1,
|
||||
lzma,
|
||||
lzo,
|
||||
xz,
|
||||
lz4,
|
||||
zstd,
|
||||
},
|
||||
block_log: u16,
|
||||
flags: packed struct {
|
||||
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: InodeRef,
|
||||
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 (math.log2(self.block_size) != self.block_log)
|
||||
return SuperblockError.InvalidBlockLog;
|
||||
}
|
||||
};
|
||||
-107
@@ -1,107 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Mutex = std.Thread.Mutex;
|
||||
|
||||
const Archive = @import("archive.zig");
|
||||
const BlockSize = @import("inode_data/file.zig").BlockSize;
|
||||
const InodeRef = @import("inode.zig").Ref;
|
||||
const Superblock = @import("super.zig").Superblock;
|
||||
const MetadataReader = @import("util/metadata.zig");
|
||||
const OffsetFile = @import("util/offset_file.zig");
|
||||
const XattrTable = @import("xattr.zig");
|
||||
|
||||
/// Information about a fragment section. Multiple fragments are contained in the block described by a single FragEntry.
|
||||
/// The offset into the block and fragment size is stored in the file's inode.
|
||||
pub const FragEntry = packed struct {
|
||||
start: u64,
|
||||
size: BlockSize,
|
||||
_: u32,
|
||||
};
|
||||
|
||||
const Tables = @This();
|
||||
|
||||
frag_table: Table(FragEntry),
|
||||
id_table: Table(u16),
|
||||
export_table: Table(InodeRef),
|
||||
xattr_table: XattrTable,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, archive: Archive) !Tables {
|
||||
return .{
|
||||
.frag_table = try .init(alloc, archive.fil, archive.decomp, archive.super.frag_start, archive.super.frag_count),
|
||||
.id_table = try .init(alloc, archive.fil, archive.decomp, archive.super.id_start, archive.super.id_count),
|
||||
.export_table = try .init(alloc, archive.fil, archive.decomp, archive.super.export_start, archive.super.inode_count),
|
||||
.xattr_table = try .init(alloc, archive.fil, archive.decomp, archive.super.xattr_start),
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: *Tables) void {
|
||||
self.frag_table.deinit();
|
||||
self.id_table.deinit();
|
||||
self.export_table.deinit();
|
||||
self.xattr_table.deinit();
|
||||
}
|
||||
|
||||
/// A two-layer metadata table.
|
||||
pub fn Table(T: anytype) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
const VALS_PER_BLOCK = 8192 / @sizeOf(T);
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
fil: OffsetFile,
|
||||
decomp: DecompFn,
|
||||
tab_start: u64,
|
||||
|
||||
tab: std.AutoHashMap(u32, []T),
|
||||
values: u32,
|
||||
|
||||
mut: Mutex = .{},
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: DecompFn, tab_start: u64, values: u32) !Self {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.fil = fil,
|
||||
.decomp = decomp,
|
||||
.tab_start = tab_start,
|
||||
|
||||
.tab = .init(alloc),
|
||||
.values = values,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Self) void {
|
||||
var iter = self.tab.valueIterator();
|
||||
while (iter.next()) |s| {
|
||||
self.alloc.free(s.*);
|
||||
}
|
||||
self.tab.deinit();
|
||||
}
|
||||
|
||||
pub fn get(self: *Self, idx: u32) !T {
|
||||
if (idx >= self.values) return error.InvalidIndex;
|
||||
const block_num = idx / VALS_PER_BLOCK;
|
||||
const idx_offset = idx - (block_num * VALS_PER_BLOCK);
|
||||
if (self.tab.contains(block_num)) {
|
||||
const block = self.tab.get(block_num).?;
|
||||
return block[idx_offset];
|
||||
}
|
||||
self.mut.lock();
|
||||
defer self.mut.unlock();
|
||||
// Double check in case of race condition..
|
||||
if (self.tab.contains(block_num)) {
|
||||
const block = self.tab.get(block_num).?;
|
||||
return block[idx_offset];
|
||||
}
|
||||
const is_last = (self.values - 1) / VALS_PER_BLOCK == block_num;
|
||||
const slice_size = if (is_last) self.values - (block_num * VALS_PER_BLOCK) else VALS_PER_BLOCK;
|
||||
const slice = try self.alloc.alloc(T, slice_size);
|
||||
var rdr = try self.fil.readerAt(self.tab_start + (8 * block_num), &[0]u8{});
|
||||
var offset: u64 = 0;
|
||||
try rdr.interface.readSliceEndian(u64, @ptrCast(&offset), .little);
|
||||
rdr = try self.fil.readerAt(offset, &[0]u8{});
|
||||
var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
|
||||
try meta.interface.readSliceEndian(T, @ptrCast(slice), .little);
|
||||
try self.tab.put(block_num, slice);
|
||||
return slice[idx_offset];
|
||||
}
|
||||
};
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
const std = @import("std");
|
||||
const stuff = @import("builtin");
|
||||
|
||||
const Archive = @import("archive.zig");
|
||||
const Superblock = @import("super.zig").Superblock;
|
||||
|
||||
const TestArchive = "testing/LinuxPATest.sfs";
|
||||
|
||||
test "Basics" {
|
||||
var fil = try std.fs.cwd().openFile(TestArchive, .{});
|
||||
defer fil.close();
|
||||
var sfs: Archive = try .init(std.testing.allocator, fil);
|
||||
defer sfs.deinit();
|
||||
if (sfs.super != LinuxPATestCorrectSuperblock) {
|
||||
std.debug.print("Superblock wrong\nShould be: {}\n\nis: {}\n", .{ LinuxPATestCorrectSuperblock, sfs.super });
|
||||
return error.BadSuperblock;
|
||||
}
|
||||
}
|
||||
|
||||
const TestFile = "Start.exe";
|
||||
const TestFileExtractLocation = "testing/Start.exe";
|
||||
|
||||
test "ExtractSingleFile" {
|
||||
std.fs.cwd().deleteFile(TestFileExtractLocation) catch {};
|
||||
var fil = try std.fs.cwd().openFile(TestArchive, .{});
|
||||
defer fil.close();
|
||||
var sfs: Archive = try .init(std.testing.allocator, fil);
|
||||
defer sfs.deinit();
|
||||
var test_fil = try sfs.open(TestFile);
|
||||
defer test_fil.deinit();
|
||||
try test_fil.extract(TestFileExtractLocation, .Default);
|
||||
//TODO: validate extracted file.
|
||||
}
|
||||
|
||||
const TestFullExtractLocation = "testing/TestExtract";
|
||||
|
||||
test "ExtractCompleteArchive" {
|
||||
std.fs.cwd().deleteTree(TestFullExtractLocation) catch {};
|
||||
var fil = try std.fs.cwd().openFile(TestArchive, .{});
|
||||
defer fil.close();
|
||||
var sfs: Archive = try .init(std.testing.allocator, fil);
|
||||
defer sfs.deinit();
|
||||
try sfs.extract(TestFullExtractLocation, .Default);
|
||||
}
|
||||
|
||||
const LinuxPATestCorrectSuperblock: Superblock = .{
|
||||
.magic = std.mem.readInt(u32, "hsqs", .little),
|
||||
.inode_count = 2974,
|
||||
.mod_time = 1632696724,
|
||||
.block_size = 131072,
|
||||
.frag_count = 264,
|
||||
.compression = .zstd,
|
||||
.block_log = 17,
|
||||
.flags = .{
|
||||
.inode_uncompressed = false,
|
||||
.data_uncompressed = false,
|
||||
.check = false,
|
||||
.frag_uncompressed = false,
|
||||
.fragment_never = false,
|
||||
.fragment_always = false,
|
||||
.duplicates = true,
|
||||
.exportable = true,
|
||||
.xattr_uncompressed = false,
|
||||
.xattr_never = false,
|
||||
.compression_options = false,
|
||||
.ids_uncompressed = false,
|
||||
._ = 0,
|
||||
},
|
||||
.id_count = 1,
|
||||
.ver_maj = 4,
|
||||
.ver_min = 0,
|
||||
.root_ref = .{
|
||||
.block_offset = 1363,
|
||||
.block_start = 29237,
|
||||
._ = 0,
|
||||
},
|
||||
.size = 106841744,
|
||||
.id_start = 106841632,
|
||||
.xattr_start = 106841720,
|
||||
.inode_start = 106778274,
|
||||
.dir_start = 106807998,
|
||||
.frag_start = 106837747,
|
||||
.export_start = 106841602,
|
||||
};
|
||||
@@ -1,174 +0,0 @@
|
||||
//! A reader for a regular file.
|
||||
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
const Writer = std.Io.Writer;
|
||||
const Limit = std.Io.Limit;
|
||||
|
||||
const Archive = @import("../archive.zig");
|
||||
const DecompFn = @import("../decomp.zig").DecompFn;
|
||||
const BlockSize = @import("../inode_data/file.zig").BlockSize;
|
||||
const FragEntry = @import("../tables.zig").FragEntry;
|
||||
const OffsetFile = @import("offset_file.zig");
|
||||
|
||||
const DataReader = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
fil: OffsetFile,
|
||||
decomp: DecompFn,
|
||||
block_size: u32,
|
||||
|
||||
blocks: []BlockSize,
|
||||
|
||||
frag: ?FragEntry = null, // TODO: do something better?
|
||||
frag_offset: u32 = 0,
|
||||
size: u64,
|
||||
|
||||
interface: Reader,
|
||||
|
||||
cur_offset: u64,
|
||||
block_idx: u32 = 0,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, archive: Archive, blocks: []BlockSize, start: u64, size: u64) DataReader {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.fil = archive.fil,
|
||||
.decomp = archive.decomp,
|
||||
.block_size = archive.super.block_size,
|
||||
.blocks = blocks,
|
||||
.size = size,
|
||||
.cur_offset = start,
|
||||
.interface = .{
|
||||
.end = 0,
|
||||
.seek = 0,
|
||||
.buffer = &[0]u8{},
|
||||
.vtable = &.{
|
||||
.stream = stream,
|
||||
.discard = discard,
|
||||
.readVec = readVec,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: *DataReader) void {
|
||||
self.alloc.free(self.interface.buffer);
|
||||
self.interface.end = 0;
|
||||
self.interface.seek = 0;
|
||||
}
|
||||
|
||||
pub fn addFragment(self: *DataReader, entry: FragEntry, frag_offset: u32) void {
|
||||
self.frag = entry;
|
||||
self.frag_offset = frag_offset;
|
||||
}
|
||||
|
||||
fn numBlocks(self: DataReader) usize {
|
||||
var res = self.blocks.len;
|
||||
if (self.frag != null) res += 1;
|
||||
return res;
|
||||
}
|
||||
|
||||
fn advance(self: *DataReader) !void {
|
||||
if (self.block_idx > self.blocks.len or (self.block_idx == self.blocks.len and self.frag == null)) {
|
||||
if (self.interface.buffer.len > 0) {
|
||||
self.alloc.free(self.interface.buffer);
|
||||
self.interface.buffer = &[0]u8{};
|
||||
self.interface.end = 0;
|
||||
self.interface.seek = 0;
|
||||
}
|
||||
return Reader.Error.EndOfStream;
|
||||
}
|
||||
defer self.block_idx += 1;
|
||||
const cur_block_size = if (self.block_idx == self.numBlocks() - 1) self.size % self.block_size else self.block_size;
|
||||
try self.resizeBuffer(cur_block_size);
|
||||
self.interface.seek = 0;
|
||||
self.interface.end = cur_block_size;
|
||||
if (self.block_idx == self.blocks.len) { // fragment
|
||||
var rdr = try self.fil.readerAt(self.frag.?.start, &[0]u8{});
|
||||
if (self.frag.?.size.uncompressed) {
|
||||
try rdr.interface.discardAll(self.frag_offset);
|
||||
try rdr.interface.readSliceAll(self.interface.buffer);
|
||||
return;
|
||||
}
|
||||
const tmp_buf = try self.alloc.alloc(u8, self.frag.?.size.size);
|
||||
defer self.alloc.free(tmp_buf);
|
||||
try rdr.interface.readSliceAll(tmp_buf);
|
||||
const needed_block = try self.alloc.alloc(u8, self.block_size);
|
||||
defer self.alloc.free(needed_block);
|
||||
_ = try self.decomp(self.alloc, tmp_buf, needed_block);
|
||||
@memcpy(self.interface.buffer, needed_block[self.frag_offset .. self.frag_offset + cur_block_size]);
|
||||
return;
|
||||
}
|
||||
const block = self.blocks[self.block_idx];
|
||||
if (block.size == 0) {
|
||||
@memset(self.interface.buffer, 0);
|
||||
return;
|
||||
}
|
||||
var rdr = try self.fil.readerAt(self.cur_offset, &[0]u8{});
|
||||
self.cur_offset += block.size;
|
||||
if (block.uncompressed) {
|
||||
try rdr.interface.readSliceAll(self.interface.buffer);
|
||||
return;
|
||||
}
|
||||
const tmp_buf = try self.alloc.alloc(u8, block.size);
|
||||
defer self.alloc.free(tmp_buf);
|
||||
try rdr.interface.readSliceAll(tmp_buf);
|
||||
_ = try self.decomp(self.alloc, tmp_buf, self.interface.buffer);
|
||||
}
|
||||
/// Does not guarentee that data currently in the buffer is retained.
|
||||
fn resizeBuffer(self: *DataReader, size: usize) !void {
|
||||
if (self.interface.buffer.len == size) return;
|
||||
if (!self.alloc.resize(self.interface.buffer, size)) {
|
||||
self.alloc.free(self.interface.buffer);
|
||||
self.interface.buffer = self.alloc.alloc(u8, size) catch |err| {
|
||||
self.interface.buffer = &[0]u8{};
|
||||
return err;
|
||||
};
|
||||
} else {
|
||||
self.interface.buffer.len = size;
|
||||
}
|
||||
}
|
||||
|
||||
fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
|
||||
var self: *DataReader = @alignCast(@fieldParentPtr("interface", rdr));
|
||||
if (rdr.seek >= rdr.end) self.advance() catch |err| {
|
||||
if (err == error.EndOfStream) return error.EndOfStream;
|
||||
std.log.err("Error advancing data reader: {}\n", .{err});
|
||||
return Reader.Error.ReadFailed;
|
||||
};
|
||||
if (limit == .nothing) return 0;
|
||||
const to_read = @min(rdr.end - rdr.seek, @intFromEnum(limit));
|
||||
const res = try wrt.write(rdr.buffer[rdr.seek .. rdr.seek + to_read]);
|
||||
rdr.seek += res;
|
||||
return res;
|
||||
}
|
||||
|
||||
fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
|
||||
var self: *DataReader = @alignCast(@fieldParentPtr("interface", rdr));
|
||||
if (rdr.seek >= rdr.end) self.advance() catch |err| {
|
||||
if (err == error.EndOfStream) return error.EndOfStream;
|
||||
std.log.err("Error advancing data reader: {}\n", .{err});
|
||||
return Reader.Error.ReadFailed;
|
||||
};
|
||||
if (limit == .nothing) return 0;
|
||||
const to_adv = @min(rdr.end - rdr.seek, @intFromEnum(limit));
|
||||
rdr.seek += to_adv;
|
||||
return to_adv;
|
||||
}
|
||||
|
||||
fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
|
||||
var self: *DataReader = @alignCast(@fieldParentPtr("interface", rdr));
|
||||
if (rdr.seek >= rdr.end) self.advance() catch |err| {
|
||||
if (err == error.EndOfStream) return error.EndOfStream;
|
||||
std.log.err("Error advancing data reader: {}\n", .{err});
|
||||
return Reader.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], rdr.buffer[rdr.seek .. rdr.seek + to_copy]);
|
||||
rdr.seek += to_copy;
|
||||
cur_red += to_copy;
|
||||
if (rdr.end == rdr.seek) break;
|
||||
}
|
||||
return cur_red;
|
||||
}
|
||||
@@ -1,207 +0,0 @@
|
||||
//! Similiar to DataReader, but set-up for threaded writing to files.
|
||||
|
||||
const std = @import("std");
|
||||
const Reader = std.Io.Reader;
|
||||
const Writer = std.Io.Writer;
|
||||
const Limit = std.Io.Limit;
|
||||
const WaitGroup = std.Thread.WaitGroup;
|
||||
const Pool = std.Thread.Pool;
|
||||
|
||||
const Archive = @import("../archive.zig");
|
||||
const DecompFn = @import("../decomp.zig").DecompFn;
|
||||
const BlockSize = @import("../inode_data/file.zig").BlockSize;
|
||||
const FragEntry = @import("../tables.zig").FragEntry;
|
||||
const InodeFinish = @import("inode_finish.zig");
|
||||
const OffsetFile = @import("offset_file.zig");
|
||||
|
||||
const ThreadedDataReader = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
fil: OffsetFile,
|
||||
decomp: DecompFn,
|
||||
block_size: u32,
|
||||
|
||||
blocks: []BlockSize,
|
||||
|
||||
frag: ?FragEntry = null, // TODO: do something better?
|
||||
frag_offset: u32 = 0,
|
||||
size: u64,
|
||||
num_blocks: usize,
|
||||
|
||||
start_offset: u64,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, archive: Archive, blocks: []BlockSize, start: u64, size: u64) ThreadedDataReader {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.fil = archive.fil,
|
||||
.decomp = archive.decomp,
|
||||
.block_size = archive.super.block_size,
|
||||
|
||||
.blocks = blocks,
|
||||
|
||||
.size = size,
|
||||
.num_blocks = blocks.len,
|
||||
|
||||
.start_offset = start,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn addFragment(self: *ThreadedDataReader, entry: FragEntry, frag_offset: u32) void {
|
||||
self.frag = entry;
|
||||
self.frag_offset = frag_offset;
|
||||
self.num_blocks = self.blocks.len + 1;
|
||||
}
|
||||
|
||||
/// Extract the data to the file threadedly, using pool to spawn threads.
|
||||
/// If errors occur, they are set to finish.out_err.
|
||||
pub fn extractThreaded(self: ThreadedDataReader, file: std.fs.File, pool: *Pool, finish: *InodeFinish) void {
|
||||
var cur_write_offset: u64 = 0;
|
||||
var cur_read_offset: u64 = self.start_offset;
|
||||
for (0..self.blocks.len) |i| {
|
||||
const cur_block_size = if (i == self.num_blocks - 1) self.size % self.block_size else self.block_size;
|
||||
pool.spawn(workThreadBlocks, .{ self, file, cur_write_offset, cur_read_offset, self.blocks[i], cur_block_size, finish }) catch |res_err| {
|
||||
finish.logError("Can't spawn pool task: {}", .{res_err});
|
||||
finish.out_err.* = res_err;
|
||||
finish.finish();
|
||||
};
|
||||
cur_write_offset += cur_block_size;
|
||||
cur_read_offset += self.blocks[i].size;
|
||||
}
|
||||
if (self.frag != null)
|
||||
pool.spawn(workThreadFragment, .{ self, file, cur_write_offset, finish }) catch |res_err| {
|
||||
finish.logError("Can't spawn pool task: {}", .{res_err});
|
||||
finish.out_err.* = res_err;
|
||||
finish.finish();
|
||||
};
|
||||
}
|
||||
|
||||
fn workThreadBlocks(
|
||||
self: ThreadedDataReader,
|
||||
fil: std.fs.File,
|
||||
write_offset: u64,
|
||||
read_offset: u64,
|
||||
block: BlockSize,
|
||||
cur_block_size: u64,
|
||||
finish: *InodeFinish,
|
||||
) void {
|
||||
defer finish.finish();
|
||||
var wrt = fil.writer(&[0]u8{});
|
||||
wrt.seekTo(write_offset) catch |err| {
|
||||
finish.logError("Error seeking file writer: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer wrt.interface.flush() catch |err| {
|
||||
finish.logError("Error flushing file writer: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
};
|
||||
if (block.size == 0) {
|
||||
wrt.interface.splatByteAll(0, cur_block_size) catch |err| {
|
||||
finish.logError("Error writing zeroes: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
return;
|
||||
}
|
||||
var rdr = self.fil.readerAt(read_offset, &[0]u8{}) catch |err| {
|
||||
finish.logError("Error creating file reader: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
if (block.uncompressed) {
|
||||
rdr.interface.streamExact(&wrt.interface, block.size) catch |err| {
|
||||
finish.logError("Error streaming data: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
return;
|
||||
}
|
||||
// TODO: shared buffers
|
||||
const read_buf = self.alloc.alloc(u8, block.size) catch |err| {
|
||||
finish.logError("Error creating reader buffer: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer self.alloc.free(read_buf);
|
||||
rdr.interface.readSliceAll(read_buf) catch |err| {
|
||||
finish.logError("Error reading data into reader buffer: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
// TODO: shared buffers
|
||||
const res_buf = self.alloc.alloc(u8, cur_block_size) catch |err| {
|
||||
finish.logError("Error creating result buffer: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer self.alloc.free(res_buf);
|
||||
_ = self.decomp(self.alloc, read_buf, res_buf) catch |err| {
|
||||
finish.logError("Error decompressing data block: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
wrt.interface.writeAll(res_buf) catch |err| {
|
||||
finish.logError("Error writing to file: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
}
|
||||
fn workThreadFragment(self: ThreadedDataReader, fil: std.fs.File, write_offset: u64, finish: *InodeFinish) void {
|
||||
defer finish.finish();
|
||||
|
||||
var wrt = fil.writer(&[0]u8{});
|
||||
wrt.seekTo(write_offset) catch |err| {
|
||||
finish.logError("Error seeking file writer for file fragment: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer wrt.interface.flush() catch |err| {
|
||||
finish.out_err.* = err;
|
||||
};
|
||||
|
||||
var rdr = self.fil.readerAt(self.frag.?.start, &[0]u8{}) catch |err| {
|
||||
finish.logError("Error creating file reader for file fragment: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
if (self.frag.?.size.uncompressed) {
|
||||
rdr.interface.discardAll(self.frag_offset) catch |err| {
|
||||
finish.logError("Error discarding useless fragment data: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
rdr.interface.streamExact(&wrt.interface, self.size % self.block_size) catch |err| {
|
||||
finish.logError("Error streaming fragment data: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
return;
|
||||
}
|
||||
const tmp_buf = self.alloc.alloc(u8, self.frag.?.size.size) catch |err| {
|
||||
finish.logError("Error creating a temporary buffer for a file fragment: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer self.alloc.free(tmp_buf);
|
||||
rdr.interface.readSliceAll(tmp_buf) catch |err| {
|
||||
finish.logError("Error reading data into fragment buffer: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
const needed_block = self.alloc.alloc(u8, self.block_size) catch |err| {
|
||||
finish.logError("Error allocating fragment decompression results: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer self.alloc.free(needed_block);
|
||||
_ = self.decomp(self.alloc, tmp_buf, needed_block) catch |err| {
|
||||
finish.logError("Error decompressing fragment: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
wrt.interface.writeAll(needed_block[self.frag_offset .. self.frag_offset + (self.size % self.block_size)]) catch |err| {
|
||||
finish.logError("Error writing fragment: {}", .{err});
|
||||
finish.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
}
|
||||
@@ -1,353 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const Pool = std.Thread.Pool;
|
||||
const WaitGroup = std.Thread.WaitGroup;
|
||||
|
||||
const Archive = @import("../archive.zig");
|
||||
const DirEntry = @import("../dir_entry.zig");
|
||||
const Inode = @import("../inode.zig");
|
||||
const ExtractionOptions = @import("../options.zig");
|
||||
const Tables = @import("../tables.zig");
|
||||
const InodeFinish = @import("inode_finish.zig");
|
||||
const FinishUnion = InodeFinish.FinishUnion;
|
||||
const ThreadedDataReader = @import("data_threaded.zig");
|
||||
|
||||
// 1 MB
|
||||
const STACK_ALLOC_SIZE = 1024 * 1024;
|
||||
|
||||
pub fn extractTo(
|
||||
allocator: Allocator,
|
||||
inode: Inode,
|
||||
archive: Archive,
|
||||
path: []const u8,
|
||||
options: ExtractionOptions,
|
||||
) !void {
|
||||
if (path[path.len - 1] == '/')
|
||||
return extractTo(allocator, inode, archive, path[0 .. path.len - 2], options);
|
||||
|
||||
var stack_alloc = std.heap.stackFallback(STACK_ALLOC_SIZE, allocator);
|
||||
var arena: std.heap.ArenaAllocator = .init(stack_alloc.get());
|
||||
defer arena.deinit();
|
||||
if (options.threads <= 1) {
|
||||
const alloc = arena.allocator();
|
||||
var tables: Tables = try .init(alloc, archive);
|
||||
return extractSingleThread(arena.allocator(), inode, archive, &tables, path, options);
|
||||
}
|
||||
|
||||
var thread_alloc = std.heap.ThreadSafeAllocator{ .child_allocator = arena.allocator() };
|
||||
const alloc = thread_alloc.allocator();
|
||||
var tables: Tables = try .init(alloc, archive);
|
||||
|
||||
var pool_alloc = std.heap.stackFallback(10 * 1024, alloc);
|
||||
var pool: Pool = undefined;
|
||||
try pool.init(.{ .allocator = pool_alloc.get(), .n_jobs = options.threads - 1 });
|
||||
|
||||
var wg: WaitGroup = .{};
|
||||
var err: ?anyerror = null;
|
||||
wg.start();
|
||||
try pool.spawn(extractMultiThread, .{
|
||||
alloc,
|
||||
inode,
|
||||
archive,
|
||||
&tables,
|
||||
path,
|
||||
options,
|
||||
&pool,
|
||||
FinishUnion{ .wg = &wg },
|
||||
&err,
|
||||
});
|
||||
pool.waitAndWork(&wg);
|
||||
if (err != null) return err.?;
|
||||
}
|
||||
|
||||
fn extractSingleThread(
|
||||
alloc: Allocator,
|
||||
inode: Inode,
|
||||
archive: Archive,
|
||||
tables: *Tables,
|
||||
path: []const u8,
|
||||
options: ExtractionOptions,
|
||||
) !void {
|
||||
switch (inode.hdr.inode_type) {
|
||||
.dir, .ext_dir => {
|
||||
_ = std.fs.cwd().makeDir(path) catch |err| switch (err) {
|
||||
std.fs.Dir.MakeError.PathAlreadyExists => {},
|
||||
else => return err,
|
||||
};
|
||||
|
||||
// Currently we are ignoring any deinit or free calls since we know we are under an ArenaAllocator.
|
||||
// Possibly in the future, do some simple math to see if it would be safe to ONLY deinit via Arena,
|
||||
// otherwise be more conscientious about freeing memory.
|
||||
// For now, this is good enough.
|
||||
|
||||
const entries = try inode.dirEntries(alloc, archive);
|
||||
for (entries) |ent| {
|
||||
const sub_inode: Inode = try .readFromEntry(alloc, archive, ent);
|
||||
const new_path = try std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", ent.name });
|
||||
try extractSingleThread(alloc, sub_inode, archive, tables, new_path, options);
|
||||
}
|
||||
|
||||
const fil = try std.fs.cwd().openFile(path, .{});
|
||||
defer fil.close();
|
||||
try inode.setMetadata(alloc, tables, fil, options);
|
||||
},
|
||||
.file, .ext_file => {
|
||||
var fil = try std.fs.cwd().createFile(path, .{ .exclusive = true });
|
||||
defer fil.close();
|
||||
var wrt = fil.writer(&[0]u8{});
|
||||
var dat_rdr = try inode.dataReader(alloc, archive, tables);
|
||||
defer dat_rdr.deinit();
|
||||
_ = try dat_rdr.interface.streamRemaining(&wrt.interface);
|
||||
try wrt.interface.flush();
|
||||
|
||||
try inode.setMetadata(alloc, tables, fil, options);
|
||||
},
|
||||
.symlink, .ext_symlink => return extractSymlink(inode, path),
|
||||
else => return extractDeviceAndIPC(inode, alloc, tables, path, options),
|
||||
}
|
||||
}
|
||||
|
||||
fn extractMultiThread(
|
||||
alloc: Allocator,
|
||||
inode: Inode,
|
||||
archive: Archive,
|
||||
tables: *Tables,
|
||||
path: []const u8,
|
||||
options: ExtractionOptions,
|
||||
pool: *Pool,
|
||||
fin: FinishUnion,
|
||||
err: *?anyerror,
|
||||
) void {
|
||||
if (err.* != null) {
|
||||
fin.finish();
|
||||
return;
|
||||
}
|
||||
switch (inode.hdr.inode_type) {
|
||||
.dir, .ext_dir => {
|
||||
_ = std.fs.cwd().makeDir(path) catch |res_err| switch (res_err) {
|
||||
std.fs.Dir.MakeError.PathAlreadyExists => {},
|
||||
else => {
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
},
|
||||
};
|
||||
|
||||
// Currently we are ignoring any deinit or free calls since we know we are under an ArenaAllocator.
|
||||
// Possibly in the future, do some simple math to see if it would be safe to ONLY deinit via Arena,
|
||||
// otherwise be more conscientious about freeing memory.
|
||||
// For now, this is good enough.
|
||||
|
||||
const entries = inode.dirEntries(alloc, archive) catch |res_err| {
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
|
||||
if (entries.len == 0) {
|
||||
fin.finish();
|
||||
return;
|
||||
}
|
||||
|
||||
var dir_fin = InodeFinish.create(
|
||||
alloc,
|
||||
inode,
|
||||
path,
|
||||
tables,
|
||||
options,
|
||||
fin,
|
||||
err,
|
||||
null,
|
||||
entries.len,
|
||||
) catch |res_err| {
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
|
||||
for (entries) |ent| {
|
||||
if (ent.inode_type == .dir) {
|
||||
extractEntry(
|
||||
alloc,
|
||||
ent,
|
||||
archive,
|
||||
tables,
|
||||
path,
|
||||
options,
|
||||
pool,
|
||||
.{ .fin = dir_fin },
|
||||
err,
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
pool.spawn(
|
||||
extractEntry,
|
||||
.{ alloc, ent, archive, tables, path, options, pool, FinishUnion{ .fin = dir_fin }, err },
|
||||
) catch |res_err| {
|
||||
err.* = res_err;
|
||||
dir_fin.finish();
|
||||
return;
|
||||
};
|
||||
}
|
||||
},
|
||||
.file, .ext_file => {
|
||||
const fil = std.fs.cwd().createFile(path, .{ .exclusive = true }) catch |res_err| {
|
||||
if (options.verbose)
|
||||
options.verbose_writer.?.print("Can't create file at {s}: {}\n", .{ path, res_err }) catch {};
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
|
||||
var data_rdr = threadedDataReader(inode, alloc, archive, tables) catch |res_err| {
|
||||
if (options.verbose)
|
||||
options.verbose_writer.?.print("Can't create data reader for inode #{} (extracting to {s}): {}\n", .{ inode.hdr.num, path, res_err }) catch {};
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
if (data_rdr == null) {
|
||||
inode.setMetadata(alloc, tables, fil, options) catch |res_err| {
|
||||
if (options.verbose)
|
||||
options.verbose_writer.?.print("Can't set metadata to {s}: {}\n", .{ path, res_err }) catch {};
|
||||
err.* = res_err;
|
||||
};
|
||||
fin.finish();
|
||||
return;
|
||||
}
|
||||
const file_fin = InodeFinish.create(
|
||||
alloc,
|
||||
inode,
|
||||
path,
|
||||
tables,
|
||||
options,
|
||||
fin,
|
||||
err,
|
||||
fil,
|
||||
data_rdr.?.num_blocks,
|
||||
) catch |res_err| {
|
||||
if (options.verbose)
|
||||
options.verbose_writer.?.print("Can't create callback for inode #{} (extracting to {s}): {}\n", .{ inode.hdr.num, path, res_err }) catch {};
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
|
||||
data_rdr.?.extractThreaded(fil, pool, file_fin);
|
||||
},
|
||||
.symlink, .ext_symlink => {
|
||||
extractSymlink(inode, path) catch |res_err| {
|
||||
err.* = res_err;
|
||||
};
|
||||
fin.finish();
|
||||
},
|
||||
else => {
|
||||
extractDeviceAndIPC(inode, alloc, tables, path, options) catch |res_err| {
|
||||
err.* = res_err;
|
||||
};
|
||||
fin.finish();
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn extractEntry(
|
||||
alloc: Allocator,
|
||||
ent: DirEntry,
|
||||
archive: Archive,
|
||||
tables: *Tables,
|
||||
path: []const u8,
|
||||
options: ExtractionOptions,
|
||||
pool: *Pool,
|
||||
fin: FinishUnion,
|
||||
err: *?anyerror,
|
||||
) void {
|
||||
const new_path = std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", ent.name }) catch |res_err| {
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
|
||||
const inode = Inode.readFromEntry(alloc, archive, ent) catch |res_err| {
|
||||
err.* = res_err;
|
||||
fin.finish();
|
||||
return;
|
||||
};
|
||||
extractMultiThread(alloc, inode, archive, tables, new_path, options, pool, fin, err);
|
||||
}
|
||||
|
||||
/// Get a threaded data reader for a file inode.
|
||||
fn threadedDataReader(self: Inode, alloc: std.mem.Allocator, archive: Archive, tables: *Tables) !?ThreadedDataReader {
|
||||
return switch (self.hdr.inode_type) {
|
||||
.file => threadedReaderFromData(alloc, archive, tables, self.data.file),
|
||||
.ext_file => threadedReaderFromData(alloc, archive, tables, self.data.ext_file),
|
||||
else => error.NotRegularFile,
|
||||
};
|
||||
}
|
||||
fn threadedReaderFromData(alloc: std.mem.Allocator, archive: Archive, tables: *Tables, data: anytype) !?ThreadedDataReader {
|
||||
if (data.block_sizes.len == 0 and data.frag_idx == 0xFFFFFFFF) return null;
|
||||
var out: ThreadedDataReader = .init(alloc, archive, data.block_sizes, data.block_start, data.size);
|
||||
if (data.frag_idx != 0xFFFFFFFF)
|
||||
out.addFragment(try tables.frag_table.get(data.frag_idx), data.frag_block_offset);
|
||||
return out;
|
||||
}
|
||||
|
||||
/// Creates the symlink described by the inode.
|
||||
/// Sets metadata.
|
||||
fn extractSymlink(self: Inode, path: []const u8) !void {
|
||||
const target = switch (self.data) {
|
||||
.symlink => |s| s.target,
|
||||
.ext_symlink => |s| s.target,
|
||||
else => unreachable,
|
||||
};
|
||||
try std.fs.cwd().symLink(target, path, .{});
|
||||
}
|
||||
/// Creates the device described by the inode.
|
||||
/// Sets metadata.
|
||||
fn extractDeviceAndIPC(self: Inode, alloc: std.mem.Allocator, tables: *Tables, path: []const u8, options: ExtractionOptions) !void {
|
||||
var mode: u32 = undefined;
|
||||
var dev: u32 = 0;
|
||||
switch (self.data) {
|
||||
.char_dev => |d| {
|
||||
mode = std.posix.S.IFCHR;
|
||||
dev = d.dev;
|
||||
},
|
||||
.ext_char_dev => |d| {
|
||||
mode = std.posix.S.IFCHR;
|
||||
dev = d.dev;
|
||||
},
|
||||
.block_dev => |d| {
|
||||
mode = std.posix.S.IFBLK;
|
||||
dev = d.dev;
|
||||
},
|
||||
.ext_block_dev => |d| {
|
||||
mode = std.posix.S.IFBLK;
|
||||
dev = d.dev;
|
||||
},
|
||||
.fifo, .ext_fifo => mode = std.posix.S.IFIFO,
|
||||
.socket, .ext_socket => mode = std.posix.S.IFSOCK,
|
||||
else => unreachable,
|
||||
}
|
||||
const res: std.os.linux.E = @enumFromInt(std.os.linux.mknod(@ptrCast(path), mode, dev));
|
||||
switch (res) {
|
||||
.SUCCESS => {},
|
||||
.ACCES => return std.fs.Dir.MakeError.AccessDenied,
|
||||
.DQUOT => return std.fs.Dir.MakeError.DiskQuota,
|
||||
.EXIST => return std.fs.Dir.MakeError.PathAlreadyExists,
|
||||
.FAULT, .NOENT => return std.fs.Dir.MakeError.BadPathName,
|
||||
.LOOP => return std.fs.Dir.MakeError.SymLinkLoop,
|
||||
.NAMETOOLONG => return std.fs.Dir.MakeError.NameTooLong,
|
||||
.NOMEM => return std.fs.Dir.MakeError.SystemResources,
|
||||
.NOSPC => return std.fs.Dir.MakeError.NoSpaceLeft,
|
||||
.NOTDIR => return std.fs.Dir.MakeError.NotDir,
|
||||
.PERM => return std.fs.Dir.MakeError.PermissionDenied,
|
||||
.ROFS => return std.fs.Dir.MakeError.ReadOnlyFileSystem,
|
||||
else => return blk: {
|
||||
std.debug.print("unhandled mknod result: {}\n", .{res});
|
||||
break :blk std.fs.Dir.MakeError.Unexpected;
|
||||
},
|
||||
}
|
||||
var fil = try std.fs.cwd().openFile(path, .{});
|
||||
defer fil.close();
|
||||
try self.setMetadata(alloc, tables, fil, options);
|
||||
}
|
||||
@@ -1,101 +0,0 @@
|
||||
const std = @import("std");
|
||||
const WaitGroup = std.Thread.WaitGroup;
|
||||
const Mutex = std.Thread.Mutex;
|
||||
|
||||
const Archive = @import("../archive.zig");
|
||||
const Inode = @import("../inode.zig");
|
||||
const ExtractionOptions = @import("../options.zig");
|
||||
const Tables = @import("../tables.zig");
|
||||
|
||||
const InodeFinish = @This();
|
||||
|
||||
const FinishEnum = enum {
|
||||
wg,
|
||||
fin,
|
||||
};
|
||||
pub const FinishUnion = union(FinishEnum) {
|
||||
wg: *WaitGroup,
|
||||
fin: *InodeFinish,
|
||||
|
||||
pub fn finish(self: FinishUnion) void {
|
||||
switch (self) {
|
||||
.wg => |wg| wg.finish(),
|
||||
.fin => |fin| fin.finish(),
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
|
||||
inode: Inode,
|
||||
path: []const u8,
|
||||
tables: *Tables,
|
||||
options: ExtractionOptions,
|
||||
parent_finish: FinishUnion,
|
||||
fil: ?std.fs.File,
|
||||
out_err: *?anyerror,
|
||||
|
||||
wg: WaitGroup = .{},
|
||||
mut: Mutex = .{},
|
||||
|
||||
pub fn create(
|
||||
alloc: std.mem.Allocator,
|
||||
inode: Inode,
|
||||
path: []const u8,
|
||||
tables: *Tables,
|
||||
options: ExtractionOptions,
|
||||
parent_finish: FinishUnion,
|
||||
out_err: *?anyerror,
|
||||
fil: ?std.fs.File,
|
||||
work_size: usize,
|
||||
) !*InodeFinish {
|
||||
if (work_size == 0)
|
||||
return error.InvalidWorkSize;
|
||||
const out = try alloc.create(InodeFinish);
|
||||
errdefer alloc.destroy(out);
|
||||
out.* = .{
|
||||
.alloc = alloc,
|
||||
|
||||
.inode = inode,
|
||||
.path = path,
|
||||
.tables = tables,
|
||||
.options = options,
|
||||
.parent_finish = parent_finish,
|
||||
.out_err = out_err,
|
||||
.fil = fil,
|
||||
};
|
||||
out.wg.startMany(work_size);
|
||||
return out;
|
||||
}
|
||||
|
||||
pub fn logError(self: *InodeFinish, comptime fmt: []const u8, args: anytype) void {
|
||||
if (self.options.verbose)
|
||||
self.options.verbose_writer.?.print(fmt, args) catch {};
|
||||
}
|
||||
|
||||
pub fn finish(self: *InodeFinish) void {
|
||||
self.mut.lock();
|
||||
{
|
||||
defer self.mut.unlock();
|
||||
self.wg.finish();
|
||||
if (!self.wg.isDone()) return;
|
||||
}
|
||||
defer {
|
||||
self.parent_finish.finish();
|
||||
self.alloc.destroy(self);
|
||||
}
|
||||
if (self.fil == null)
|
||||
self.fil = std.fs.cwd().openFile(self.path, .{}) catch |err| {
|
||||
if (self.options.verbose)
|
||||
self.options.verbose_writer.?.print("Error opening {s} to set metadata: {}\n", .{ self.path, err }) catch {};
|
||||
self.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
defer self.fil.?.close();
|
||||
self.inode.setMetadata(self.alloc, self.tables, self.fil.?, self.options) catch |err| {
|
||||
if (self.options.verbose)
|
||||
self.options.verbose_writer.?.print("Error setting metadata to {s}: {}\n", .{ self.path, err }) catch {};
|
||||
self.out_err.* = err;
|
||||
return;
|
||||
};
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const OffsetFile = @import("offset_file.zig");
|
||||
|
||||
const MetadataCache = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
|
||||
buf: []u8,
|
||||
fixed_alloc: std.heap.FixedBufferAllocator,
|
||||
|
||||
cache: std.AutoArrayHashMap(u64, [8192]u8),
|
||||
|
||||
mut: std.Thread.Mutex = .{},
|
||||
cache_mut: std.AutoArrayHashMap(u64, std.Thread.Mutex),
|
||||
|
||||
fil: OffsetFile,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, cache_size: u64) !MetadataCache {}
|
||||
pub fn deinit(self: *MetadataCache) void {
|
||||
self.mut.lock();
|
||||
defer self.mut.unlock();
|
||||
self.cache.deinit();
|
||||
self.cache_mut.deinit();
|
||||
self.alloc.free(self.buf);
|
||||
}
|
||||
|
||||
pub fn getChunk(self: *MetadataCache, offset: u64) ![8192]u8 {
|
||||
var res = self.cache.get(offset);
|
||||
if (res != null) return res.?;
|
||||
var offset_mut = blk: {
|
||||
self.mut.lock();
|
||||
defer self.mut.unlock();
|
||||
const mut = try self.cache_mut.getOrPut(offset);
|
||||
if (!mut.found_existing)
|
||||
mut.value_ptr.* = .{};
|
||||
break :blk mut.value_ptr;
|
||||
};
|
||||
offset_mut.lock();
|
||||
defer offset_mut.unlock();
|
||||
}
|
||||
@@ -1,97 +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 DecompFn = @import("../decomp.zig").DecompFn;
|
||||
|
||||
const BlockHeader = packed struct {
|
||||
size: u15,
|
||||
uncompressed: bool,
|
||||
};
|
||||
|
||||
const This = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
rdr: *Reader,
|
||||
decomp: DecompFn,
|
||||
|
||||
buf: [8192]u8 = undefined,
|
||||
|
||||
interface: Reader,
|
||||
err: ?anyerror = null,
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, rdr: *Reader, decomp: DecompFn) This {
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.rdr = rdr,
|
||||
.decomp = decomp,
|
||||
.interface = .{
|
||||
.buffer = &[0]u8{},
|
||||
.end = 0,
|
||||
.seek = 0,
|
||||
.vtable = &.{
|
||||
.stream = stream,
|
||||
.discard = discard,
|
||||
.readVec = readVec,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
fn advance(self: *This) !void {
|
||||
self.interface.seek = 0;
|
||||
var hdr: BlockHeader = undefined;
|
||||
try self.rdr.readSliceEndian(BlockHeader, @ptrCast(&hdr), .little);
|
||||
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;
|
||||
}
|
||||
var tmp_buf: [8192]u8 = undefined;
|
||||
try self.rdr.readSliceAll(tmp_buf[0..hdr.size]);
|
||||
self.interface.end = try self.decomp(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) error{ EndOfStream, ReadFailed }!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_skip = @min(rdr.end - rdr.seek, @intFromEnum(limit));
|
||||
rdr.seek += to_skip;
|
||||
return to_skip;
|
||||
}
|
||||
fn readVec(rdr: *Reader, vec: [][]u8) error{ EndOfStream, ReadFailed }!usize {
|
||||
const self: *This = @fieldParentPtr("interface", rdr);
|
||||
if (rdr.end == rdr.seek) self.advance() catch |err| {
|
||||
self.err = err;
|
||||
return StreamError.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;
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
//! A File where it's meaningful (to us) content starts at a given offset.
|
||||
|
||||
const std = @import("std");
|
||||
const File = std.fs.File;
|
||||
const Reader = std.fs.File.Reader;
|
||||
|
||||
const OffsetFile = @This();
|
||||
|
||||
fil: File,
|
||||
offset: u64,
|
||||
|
||||
pub fn init(fil: File, init_offset: u64) OffsetFile {
|
||||
return .{ .fil = fil, .offset = init_offset };
|
||||
}
|
||||
|
||||
pub fn readerAt(self: OffsetFile, offset: u64, buffer: []u8) !Reader {
|
||||
var rdr = self.fil.reader(buffer);
|
||||
try rdr.seekTo(self.offset + offset);
|
||||
return rdr;
|
||||
}
|
||||
-117
@@ -1,117 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const DecompFn = @import("decomp.zig").DecompFn;
|
||||
const Table = @import("tables.zig").Table;
|
||||
const MetadataReader = @import("util/metadata.zig");
|
||||
const OffsetFile = @import("util/offset_file.zig");
|
||||
|
||||
const Ref = packed struct {
|
||||
block_offset: u16,
|
||||
block_start: u32,
|
||||
_: u16,
|
||||
};
|
||||
const Entry = packed struct {
|
||||
ref: Ref,
|
||||
count: u32,
|
||||
size: u32,
|
||||
};
|
||||
const KeyPrefix = enum(u8) {
|
||||
user,
|
||||
trusted,
|
||||
security,
|
||||
};
|
||||
const KeyRaw = packed struct {
|
||||
type: packed struct {
|
||||
prefix: KeyPrefix,
|
||||
out_of_line: bool,
|
||||
_: u7,
|
||||
},
|
||||
name_size: u16,
|
||||
};
|
||||
|
||||
pub const KeyValue = struct {
|
||||
key: [:0]u8,
|
||||
value: []u8,
|
||||
};
|
||||
|
||||
const XattrTable = @This();
|
||||
|
||||
alloc: std.mem.Allocator,
|
||||
fil: OffsetFile,
|
||||
decomp: DecompFn,
|
||||
|
||||
count: u32,
|
||||
start: u64,
|
||||
|
||||
table: Table(Entry),
|
||||
|
||||
pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: DecompFn, table_start: u64) !XattrTable {
|
||||
var info = packed struct {
|
||||
start: u64 = undefined,
|
||||
count: u32 = undefined,
|
||||
_: u32 = undefined,
|
||||
}{};
|
||||
var rdr = try fil.readerAt(table_start, &[0]u8{});
|
||||
try rdr.interface.readSliceEndian(@TypeOf(info), @ptrCast(&info), .little);
|
||||
return .{
|
||||
.alloc = alloc,
|
||||
.fil = fil,
|
||||
.decomp = decomp,
|
||||
.count = info.count,
|
||||
.start = info.start,
|
||||
.table = try .init(alloc, fil, decomp, table_start + 16, info.count),
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: *XattrTable) void {
|
||||
self.table.deinit();
|
||||
}
|
||||
|
||||
pub fn get(self: *XattrTable, alloc: std.mem.Allocator, idx: u32) ![]KeyValue {
|
||||
const entry: Entry = try self.table.get(idx);
|
||||
const out = try alloc.alloc(KeyValue, entry.count);
|
||||
|
||||
for (out) |*kv| {
|
||||
var rdr = try self.fil.readerAt(self.start + entry.ref.block_start, &[0]u8{});
|
||||
var meta: MetadataReader = .init(alloc, &rdr.interface, self.decomp);
|
||||
try meta.interface.discardAll(entry.ref.block_offset);
|
||||
|
||||
var key_raw: KeyRaw = undefined;
|
||||
try meta.interface.readSliceEndian(KeyRaw, @ptrCast(&key_raw), .little);
|
||||
|
||||
switch (key_raw.type.prefix) {
|
||||
.user => {
|
||||
kv.key = @ptrCast(try alloc.alloc(u8, key_raw.name_size + 5 + 1));
|
||||
@memcpy(kv.key[0..5], "user.");
|
||||
try meta.interface.readSliceAll(kv.key[5 .. kv.key.len - 1]);
|
||||
kv.key[kv.key.len - 1] = 0;
|
||||
},
|
||||
.security => {
|
||||
kv.key = @ptrCast(try alloc.alloc(u8, key_raw.name_size + 9 + 1));
|
||||
@memcpy(kv.key[0..9], "security.");
|
||||
try meta.interface.readSliceAll(kv.key[9 .. kv.key.len - 1]);
|
||||
kv.key[kv.key.len - 1] = 0;
|
||||
},
|
||||
.trusted => {
|
||||
kv.key = @ptrCast(try alloc.alloc(u8, key_raw.name_size + 8 + 1));
|
||||
@memcpy(kv.key[0..8], "trusted.");
|
||||
try meta.interface.readSliceAll(kv.key[8 .. kv.key.len - 1]);
|
||||
kv.key[kv.key.len - 1] = 0;
|
||||
},
|
||||
}
|
||||
if (key_raw.type.out_of_line) {
|
||||
try meta.interface.discardAll(4);
|
||||
var ref: Ref = undefined;
|
||||
try meta.interface.readSliceEndian(Ref, @ptrCast(&ref), .little);
|
||||
|
||||
rdr = try self.fil.readerAt(self.start + ref.block_start, &[0]u8{});
|
||||
meta = .init(alloc, &rdr.interface, self.decomp);
|
||||
try meta.interface.discardAll(ref.block_offset);
|
||||
}
|
||||
var value_size: u32 = undefined;
|
||||
try meta.interface.readSliceEndian(u32, @ptrCast(&value_size), .little);
|
||||
kv.value = try alloc.alloc(u8, value_size);
|
||||
try meta.interface.readSliceAll(kv.value);
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
Reference in New Issue
Block a user