weekend changes
- move main.zig to it's own package, create lib/
- rename AllSections to DB, remove intermediate tuples
- iovec does not allocate
- remove error{Overflow} from almost everywhere
This commit is contained in:
Motiejus Jakštys
30
src/bdz.zig
30
src/bdz.zig
@@ -1,30 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
extern fn bdz_search_packed(packed_mphf: [*]const u8, key: [*]const u8, len: c_uint) u32;
|
||||
|
||||
pub fn search(packed_mphf: []const u8, key: []const u8) u32 {
|
||||
const len = std.math.cast(c_uint, key.len) catch unreachable;
|
||||
return @as(u32, bdz_search_packed(packed_mphf.ptr, key.ptr, len));
|
||||
}
|
||||
|
||||
const u32len = 5;
|
||||
|
||||
pub fn search_u32(packed_mphf: []const u8, key: u32) u32 {
|
||||
return @as(u32, bdz_search_packed(packed_mphf.ptr, &unzero(key), u32len));
|
||||
}
|
||||
|
||||
// encode a u32 to 5 bytes so no bytes is a '\0'.
|
||||
//
|
||||
// TODO(motiejus) figure out how to use cmph_io_byte_vector_adapter, so cmph
|
||||
// packing would accept zero bytes. For now we will be doing a dance of not
|
||||
// passing zero bytes.
|
||||
pub fn unzero(x: u32) [5]u8 {
|
||||
const bit: u8 = 0b10000000;
|
||||
var buf: [u32len]u8 = undefined;
|
||||
buf[0] = @truncate(u8, (x & 0b11111110_00000000_00000000_00000000) >> 25) | bit;
|
||||
buf[1] = @truncate(u8, (x & 0b00000001_11111100_00000000_00000000) >> 18) | bit;
|
||||
buf[2] = @truncate(u8, (x & 0b00000000_00000011_11110000_00000000) >> 12) | bit;
|
||||
buf[3] = @truncate(u8, (x & 0b00000000_00000000_00001111_11000000) >> 6) | bit;
|
||||
buf[4] = @truncate(u8, (x & 0b00000000_00000000_00000000_00111111) >> 0) | bit;
|
||||
return buf;
|
||||
}
|
||||
169
src/cmph.zig
169
src/cmph.zig
@@ -1,169 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const math = std.math;
|
||||
const sort = std.sort;
|
||||
|
||||
const bdz = @import("bdz.zig");
|
||||
|
||||
// must be kept in sync with the definition in cmph_types.h
|
||||
const CMPH_ALGO = enum(c_int) {
|
||||
CMPH_BMZ,
|
||||
CMPH_BMZ8,
|
||||
CMPH_CHM,
|
||||
CMPH_BRZ,
|
||||
CMPH_FCH,
|
||||
CMPH_BDZ,
|
||||
CMPH_BDZ_PH,
|
||||
CMPH_CHD_PH,
|
||||
CMPH_CHD,
|
||||
CMPH_COUNT,
|
||||
};
|
||||
|
||||
extern fn cmph_io_vector_adapter(vector: [*]const [*:0]const u8, len: c_uint) [*]u8;
|
||||
extern fn cmph_io_vector_adapter_destroy(key_source: [*]u8) void;
|
||||
extern fn cmph_config_new(key_source: [*]const u8) ?[*]u8;
|
||||
extern fn cmph_config_set_algo(mph: [*]u8, algo: c_int) void;
|
||||
extern fn cmph_config_set_b(mph: [*]u8, b: c_int) void;
|
||||
extern fn cmph_new(config: [*]const u8) ?[*]u8;
|
||||
extern fn cmph_config_destroy(mph: [*]u8) void;
|
||||
extern fn cmph_packed_size(mphf: [*]const u8) u32;
|
||||
extern fn cmph_pack(mphf: [*]const u8, packed_mphf: [*]u8) void;
|
||||
extern fn cmph_destroy(mphf: [*]const u8) void;
|
||||
|
||||
// pack packs cmph hashes for the given input and returns a slice ("cmph pack
|
||||
// minus first 4 bytes") for further storage. The slice must be freed by the
|
||||
// caller.
|
||||
pub const Error = error{ OutOfMemory, Overflow };
|
||||
pub fn pack(allocator: Allocator, input: [][*:0]const u8) Error![]const u8 {
|
||||
const input_len = try math.cast(c_uint, input.len);
|
||||
var source = cmph_io_vector_adapter(input.ptr, input_len);
|
||||
defer cmph_io_vector_adapter_destroy(source);
|
||||
var config = cmph_config_new(source) orelse return error.OutOfMemory;
|
||||
cmph_config_set_algo(config, @enumToInt(CMPH_ALGO.CMPH_BDZ));
|
||||
cmph_config_set_b(config, 7);
|
||||
var mph = cmph_new(config) orelse return error.OutOfMemory;
|
||||
cmph_config_destroy(config);
|
||||
|
||||
const size = cmph_packed_size(mph);
|
||||
var buf = try allocator.alloc(u8, size);
|
||||
errdefer allocator.free(buf);
|
||||
cmph_pack(mph, buf.ptr);
|
||||
cmph_destroy(mph);
|
||||
return buf[4..];
|
||||
}
|
||||
|
||||
// perfect-hash a list of numbers and return the packed mphf
|
||||
pub fn packU32(allocator: Allocator, numbers: []const u32) Error![]const u8 {
|
||||
var keys: [][6]u8 = try allocator.alloc([6]u8, numbers.len);
|
||||
defer allocator.free(keys);
|
||||
for (numbers) |n, i|
|
||||
keys[i] = unzeroZ(n);
|
||||
|
||||
var keys2 = try allocator.alloc([*:0]const u8, numbers.len);
|
||||
defer allocator.free(keys2);
|
||||
for (keys) |_, i|
|
||||
keys2[i] = @ptrCast([*:0]const u8, &keys[i]);
|
||||
return pack(allocator, keys2);
|
||||
}
|
||||
|
||||
// perfect-hash a list of strings and return the packed mphf
|
||||
pub fn packStr(allocator: Allocator, strings: []const []const u8) Error![]const u8 {
|
||||
var arena = std.heap.ArenaAllocator.init(allocator);
|
||||
defer arena.deinit();
|
||||
var keys = try arena.allocator().alloc([*:0]const u8, strings.len);
|
||||
for (strings) |_, i|
|
||||
keys[i] = try arena.allocator().dupeZ(u8, strings[i]);
|
||||
return pack(allocator, keys);
|
||||
}
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
const items = .{
|
||||
"aaaaaaaaaa",
|
||||
"bbbbbbbbbb",
|
||||
"cccccccccc",
|
||||
"dddddddddd",
|
||||
"eeeeeeeeee",
|
||||
"ffffffffff",
|
||||
"gggggggggg",
|
||||
"hhhhhhhhhh",
|
||||
"iiiiiiiiii",
|
||||
"jjjjjjjjjj",
|
||||
};
|
||||
const items_len = items.len;
|
||||
|
||||
fn samplePack(allocator: Allocator) ![]const u8 {
|
||||
var vector = std.ArrayList([*:0]const u8).init(allocator);
|
||||
defer vector.deinit();
|
||||
try vector.appendSlice(&items);
|
||||
return pack(allocator, vector.items);
|
||||
}
|
||||
|
||||
test "basic pack/unpack" {
|
||||
const buf = try samplePack(testing.allocator);
|
||||
defer testing.allocator.free(buf);
|
||||
try testing.expect(buf.len < 100);
|
||||
|
||||
var used: [items_len]bool = undefined;
|
||||
|
||||
inline for (items) |elem| {
|
||||
const hashed = bdz.search(buf, elem);
|
||||
used[hashed] = true;
|
||||
}
|
||||
|
||||
for (used) |item| {
|
||||
try testing.expect(item);
|
||||
}
|
||||
}
|
||||
|
||||
// encodes a u32 to 6 bytes so no bytes except the last one is a '\0'.
|
||||
// This is useful for cmph-packing, where it accepts 0-terminated char*s.
|
||||
pub fn unzeroZ(x: u32) [6]u8 {
|
||||
var buf: [6]u8 = undefined;
|
||||
std.mem.copy(u8, buf[0..], bdz.unzero(x)[0..]);
|
||||
buf[5] = 0;
|
||||
return buf;
|
||||
}
|
||||
|
||||
test "unzeroZ" {
|
||||
const result = unzeroZ(0);
|
||||
try testing.expect(result[0] != 0);
|
||||
try testing.expect(result[1] != 0);
|
||||
try testing.expect(result[2] != 0);
|
||||
try testing.expect(result[3] != 0);
|
||||
try testing.expect(result[4] != 0);
|
||||
try testing.expect(result[5] == 0);
|
||||
}
|
||||
|
||||
test "pack u32" {
|
||||
const keys = &[_]u32{ 42, 1, math.maxInt(u32), 2 };
|
||||
const packed_mphf = try packU32(testing.allocator, keys);
|
||||
defer testing.allocator.free(packed_mphf);
|
||||
var hashes: [keys.len]u32 = undefined;
|
||||
for (keys) |key, i| {
|
||||
hashes[i] = bdz.search_u32(packed_mphf, key);
|
||||
}
|
||||
sort.sort(u32, hashes[0..], {}, comptime sort.asc(u32));
|
||||
for (hashes) |hash, i|
|
||||
try testing.expectEqual(i, hash);
|
||||
}
|
||||
|
||||
test "pack str" {
|
||||
const keys = &[_][]const u8{ "foo", "bar", "baz", "1", "2", "3" };
|
||||
const packed_mphf = try packStr(testing.allocator, keys[0..]);
|
||||
defer testing.allocator.free(packed_mphf);
|
||||
var hashes: [keys.len]u32 = undefined;
|
||||
for (keys) |key, i| {
|
||||
hashes[i] = bdz.search(packed_mphf, key);
|
||||
}
|
||||
sort.sort(u32, hashes[0..], {}, comptime sort.asc(u32));
|
||||
for (hashes) |hash, i|
|
||||
try testing.expectEqual(i, hash);
|
||||
}
|
||||
|
||||
test "CMPH_ALGO.CMPH_BDZ is in sync with our definition" {
|
||||
const c = @cImport({
|
||||
@cInclude("cmph_types.h");
|
||||
});
|
||||
try testing.expectEqual(c.CMPH_BDZ, @enumToInt(CMPH_ALGO.CMPH_BDZ));
|
||||
}
|
||||
311
src/compress.zig
311
src/compress.zig
@@ -1,311 +0,0 @@
|
||||
//
|
||||
// varint64 []const u8 variants
|
||||
//
|
||||
// Thanks to https://github.com/gsquire/zig-snappy/blob/master/snappy.zig and
|
||||
// golang's varint implementation.
|
||||
const std = @import("std");
|
||||
|
||||
const ArrayList = std.ArrayList;
|
||||
const Allocator = std.mem.Allocator;
|
||||
const assert = std.debug.assert;
|
||||
const math = std.math;
|
||||
|
||||
// compresses a strictly incrementing sorted slice of integers using delta
|
||||
// compression. Compression is in-place.
|
||||
pub fn deltaCompress(comptime T: type, elems: []T) error{NotSorted}!void {
|
||||
if (elems.len <= 1) {
|
||||
return;
|
||||
}
|
||||
var prev: T = elems[0];
|
||||
var i: usize = 1;
|
||||
while (i < elems.len) : (i += 1) {
|
||||
const cur = elems[i];
|
||||
if (cur <= prev) {
|
||||
return error.NotSorted;
|
||||
}
|
||||
elems[i] = cur - prev - 1;
|
||||
prev = cur;
|
||||
}
|
||||
}
|
||||
|
||||
// decompresses a slice compressed by deltaCompress. In-place.
|
||||
pub fn deltaDecompress(comptime T: type, elems: []T) error{Overflow}!void {
|
||||
if (elems.len <= 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
var i: usize = 1;
|
||||
while (i < elems.len) : (i += 1) {
|
||||
const x = try math.add(T, elems[i - 1], 1);
|
||||
elems[i] = try math.add(T, elems[i], x);
|
||||
}
|
||||
}
|
||||
|
||||
// Represents a variable length integer that we read from a byte stream along
|
||||
// with how many bytes were read to decode it.
|
||||
pub const Varint = struct {
|
||||
value: u64,
|
||||
bytes_read: usize,
|
||||
};
|
||||
|
||||
pub const maxVarintLen64 = 10;
|
||||
|
||||
// https://golang.org/pkg/encoding/binary/#Uvarint
|
||||
pub fn uvarint(buf: []const u8) error{Overflow}!Varint {
|
||||
var x: u64 = 0;
|
||||
var s: u6 = 0;
|
||||
|
||||
for (buf) |b, i| {
|
||||
if (i == maxVarintLen64)
|
||||
// Catch byte reads past maxVarintLen64.
|
||||
// See issue https://golang.org/issues/41185
|
||||
return error.Overflow;
|
||||
|
||||
if (b < 0x80) {
|
||||
if (i == maxVarintLen64 - 1 and b > 1) {
|
||||
return error.Overflow;
|
||||
}
|
||||
return Varint{
|
||||
.value = x | (@as(u64, b) << s),
|
||||
.bytes_read = i + 1,
|
||||
};
|
||||
}
|
||||
x |= (@as(u64, b & 0x7f) << s);
|
||||
s = try math.add(u6, s, 7);
|
||||
}
|
||||
|
||||
return Varint{
|
||||
.value = 0,
|
||||
.bytes_read = 0,
|
||||
};
|
||||
}
|
||||
|
||||
// https://golang.org/pkg/encoding/binary/#PutUvarint
|
||||
pub fn putUvarint(buf: []u8, x: u64) usize {
|
||||
var i: usize = 0;
|
||||
var mutX = x;
|
||||
|
||||
while (mutX >= 0x80) {
|
||||
buf[i] = @truncate(u8, mutX) | 0x80;
|
||||
mutX >>= 7;
|
||||
i += 1;
|
||||
}
|
||||
buf[i] = @truncate(u8, mutX);
|
||||
|
||||
return i + 1;
|
||||
}
|
||||
|
||||
// VarintSliceIterator iterates over varint-encoded slice.
|
||||
// The first element is the length of the slice, in decoded numbers.
|
||||
const varintSliceIterator = struct {
|
||||
remaining: usize,
|
||||
arr: []const u8,
|
||||
idx: usize,
|
||||
|
||||
pub fn next(self: *varintSliceIterator) error{Overflow}!?u64 {
|
||||
if (self.remaining == 0)
|
||||
return null;
|
||||
const value = try uvarint(self.arr[self.idx..]);
|
||||
self.idx += value.bytes_read;
|
||||
self.remaining -= 1;
|
||||
return value.value;
|
||||
}
|
||||
|
||||
// returns the number of remaining items. If called before the first
|
||||
// next(), returns the length of the slice.
|
||||
pub fn remaining(self: *const varintSliceIterator) usize {
|
||||
return self.remaining;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn VarintSliceIterator(arr: []const u8) error{Overflow}!varintSliceIterator {
|
||||
const firstnumber = try uvarint(arr);
|
||||
return varintSliceIterator{
|
||||
.remaining = firstnumber.value,
|
||||
.arr = arr,
|
||||
.idx = firstnumber.bytes_read,
|
||||
};
|
||||
}
|
||||
|
||||
const deltaDecompressionIterator = struct {
|
||||
vit: *varintSliceIterator,
|
||||
prev: u64,
|
||||
add_to_prev: u1,
|
||||
|
||||
pub fn next(self: *deltaDecompressionIterator) error{Overflow}!?u64 {
|
||||
const current = try self.vit.next();
|
||||
if (current == null) return null;
|
||||
|
||||
const prevExtra = try math.add(u64, self.prev, self.add_to_prev);
|
||||
const result = try math.add(u64, current.?, prevExtra);
|
||||
self.prev = result;
|
||||
self.add_to_prev = 1;
|
||||
return result;
|
||||
}
|
||||
|
||||
// returns the number of remaining items. If called before the first
|
||||
// next(), returns the length of the slice.
|
||||
pub fn remaining(self: *const deltaDecompressionIterator) usize {
|
||||
return self.vit.remaining;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn DeltaDecompressionIterator(vit: *varintSliceIterator) deltaDecompressionIterator {
|
||||
return deltaDecompressionIterator{
|
||||
.vit = vit,
|
||||
.prev = 0,
|
||||
.add_to_prev = 0,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn appendUvarint(arr: *ArrayList(u8), x: u64) Allocator.Error!void {
|
||||
var buf: [maxVarintLen64]u8 = undefined;
|
||||
const n = putUvarint(&buf, x);
|
||||
try arr.appendSlice(buf[0..n]);
|
||||
}
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
const uvarint_tests = [_]u64{
|
||||
0,
|
||||
1,
|
||||
2,
|
||||
10,
|
||||
20,
|
||||
63,
|
||||
64,
|
||||
65,
|
||||
127,
|
||||
128,
|
||||
129,
|
||||
255,
|
||||
256,
|
||||
257,
|
||||
1 << 63 - 1,
|
||||
};
|
||||
|
||||
test "putUvarint/uvarint" {
|
||||
for (uvarint_tests) |x| {
|
||||
var buf: [maxVarintLen64]u8 = undefined;
|
||||
const n = putUvarint(buf[0..], x);
|
||||
const got = try uvarint(buf[0..n]);
|
||||
|
||||
try testing.expectEqual(x, got.value);
|
||||
try testing.expectEqual(n, got.bytes_read);
|
||||
}
|
||||
}
|
||||
|
||||
test "VarintSliceIterator" {
|
||||
var buf = ArrayList(u8).init(testing.allocator);
|
||||
defer buf.deinit();
|
||||
try appendUvarint(&buf, uvarint_tests.len);
|
||||
for (uvarint_tests) |x|
|
||||
try appendUvarint(&buf, x);
|
||||
|
||||
var it = try VarintSliceIterator(buf.items);
|
||||
var i: usize = 0;
|
||||
while (try it.next()) |got| : (i += 1) {
|
||||
try testing.expectEqual(uvarint_tests[i], got);
|
||||
}
|
||||
try testing.expectEqual(i, uvarint_tests.len);
|
||||
}
|
||||
|
||||
test "delta compress/decompress" {
|
||||
const tests = [_]struct { input: []const u8, want: []const u8 }{
|
||||
.{ .input = &[_]u8{}, .want = &[_]u8{} },
|
||||
.{ .input = &[_]u8{0}, .want = &[_]u8{0} },
|
||||
.{ .input = &[_]u8{10}, .want = &[_]u8{10} },
|
||||
.{ .input = &[_]u8{ 0, 1, 2 }, .want = &[_]u8{ 0, 0, 0 } },
|
||||
.{ .input = &[_]u8{ 10, 20, 30, 255 }, .want = &[_]u8{ 10, 9, 9, 224 } },
|
||||
.{ .input = &[_]u8{ 0, 254, 255 }, .want = &[_]u8{ 0, 253, 0 } },
|
||||
};
|
||||
for (tests) |t| {
|
||||
var arr = try ArrayList(u8).initCapacity(
|
||||
testing.allocator,
|
||||
t.input.len,
|
||||
);
|
||||
defer arr.deinit();
|
||||
try arr.appendSlice(t.input);
|
||||
|
||||
try deltaCompress(u8, arr.items);
|
||||
try testing.expectEqualSlices(u8, arr.items, t.want);
|
||||
|
||||
try deltaDecompress(u8, arr.items);
|
||||
try testing.expectEqualSlices(u8, arr.items, t.input);
|
||||
}
|
||||
}
|
||||
|
||||
test "delta compression with varint tests" {
|
||||
var scratch: [uvarint_tests.len]u64 = undefined;
|
||||
std.mem.copy(u64, scratch[0..], uvarint_tests[0..]);
|
||||
try deltaCompress(u64, scratch[0..]);
|
||||
try deltaDecompress(u64, scratch[0..]);
|
||||
try testing.expectEqualSlices(u64, uvarint_tests[0..], scratch[0..]);
|
||||
}
|
||||
|
||||
test "delta compression negative tests" {
|
||||
for ([_][]const u8{
|
||||
&[_]u8{ 0, 0 },
|
||||
&[_]u8{ 0, 1, 1 },
|
||||
&[_]u8{ 0, 1, 2, 1 },
|
||||
}) |t| {
|
||||
var arr = try ArrayList(u8).initCapacity(testing.allocator, t.len);
|
||||
defer arr.deinit();
|
||||
try arr.appendSlice(t);
|
||||
try testing.expectError(error.NotSorted, deltaCompress(u8, arr.items));
|
||||
}
|
||||
}
|
||||
|
||||
test "delta decompress overflow" {
|
||||
for ([_][]const u8{
|
||||
&[_]u8{ 255, 0 },
|
||||
&[_]u8{ 0, 128, 127 },
|
||||
}) |t| {
|
||||
var arr = try ArrayList(u8).initCapacity(testing.allocator, t.len);
|
||||
defer arr.deinit();
|
||||
try arr.appendSlice(t);
|
||||
try testing.expectError(error.Overflow, deltaDecompress(u8, arr.items));
|
||||
}
|
||||
}
|
||||
|
||||
test "delta decompression with an iterator" {
|
||||
var compressed: [uvarint_tests.len]u64 = undefined;
|
||||
std.mem.copy(u64, compressed[0..], uvarint_tests[0..]);
|
||||
try deltaCompress(u64, compressed[0..]);
|
||||
|
||||
var buf = ArrayList(u8).init(testing.allocator);
|
||||
defer buf.deinit();
|
||||
try appendUvarint(&buf, compressed.len);
|
||||
for (compressed) |x|
|
||||
try appendUvarint(&buf, x);
|
||||
|
||||
var it = DeltaDecompressionIterator(&try VarintSliceIterator(buf.items));
|
||||
var i: usize = 0;
|
||||
try testing.expectEqual(it.remaining(), uvarint_tests.len);
|
||||
while (try it.next()) |got| : (i += 1) {
|
||||
try testing.expectEqual(uvarint_tests[i], got);
|
||||
}
|
||||
try testing.expectEqual(i, uvarint_tests.len);
|
||||
}
|
||||
|
||||
test "appendUvarint" {
|
||||
for (uvarint_tests) |x| {
|
||||
var buf = ArrayList(u8).init(testing.allocator);
|
||||
defer buf.deinit();
|
||||
|
||||
try appendUvarint(&buf, x);
|
||||
const got = try uvarint(buf.items);
|
||||
|
||||
try testing.expectEqual(x, got.value);
|
||||
}
|
||||
}
|
||||
|
||||
test "overflow" {
|
||||
for ([_][]const u8{
|
||||
&[_]u8{ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x2 },
|
||||
&[_]u8{ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x1, 0, 0 },
|
||||
&[_]u8{ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
|
||||
}) |t| {
|
||||
try testing.expectError(error.Overflow, uvarint(t));
|
||||
}
|
||||
}
|
||||
202
src/group.zig
202
src/group.zig
@@ -1,202 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const pad = @import("padding.zig");
|
||||
const validate = @import("validate.zig");
|
||||
const compress = @import("compress.zig");
|
||||
const InvalidRecord = validate.InvalidRecord;
|
||||
|
||||
const mem = std.mem;
|
||||
const Allocator = mem.Allocator;
|
||||
const ArrayList = std.ArrayList;
|
||||
const BufSet = std.BufSet;
|
||||
|
||||
pub const Group = struct {
|
||||
gid: u32,
|
||||
name: []const u8,
|
||||
members: BufSet,
|
||||
|
||||
pub fn clone(self: *const Group, allocator: Allocator) Allocator.Error!Group {
|
||||
var name = try allocator.dupe(u8, self.name);
|
||||
return Group{
|
||||
.gid = self.gid,
|
||||
.name = name,
|
||||
.members = try self.members.cloneWithAllocator(allocator),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Group, allocator: Allocator) void {
|
||||
allocator.free(self.name);
|
||||
self.members.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub const GroupStored = struct {
|
||||
gid: u32,
|
||||
name: []const u8,
|
||||
members_offset: u64,
|
||||
};
|
||||
|
||||
pub const PackedGroup = struct {
|
||||
pub const alignment_bits = 3;
|
||||
|
||||
const Inner = packed struct {
|
||||
gid: u32,
|
||||
padding: u3 = 0,
|
||||
groupname_len: u5,
|
||||
|
||||
pub fn groupnameLen(self: *const Inner) usize {
|
||||
return @as(usize, self.groupname_len) + 1;
|
||||
}
|
||||
};
|
||||
|
||||
inner: *const Inner,
|
||||
groupdata: []const u8,
|
||||
members_offset: u64,
|
||||
|
||||
pub const Entry = struct {
|
||||
group: PackedGroup,
|
||||
next: ?[]const u8,
|
||||
};
|
||||
|
||||
pub fn fromBytes(bytes: []const u8) error{Overflow}!Entry {
|
||||
const inner = mem.bytesAsValue(Inner, bytes[0..@sizeOf(Inner)]);
|
||||
const start_blob = @sizeOf(Inner);
|
||||
const end_strings = @sizeOf(Inner) + inner.groupnameLen();
|
||||
const members_offset = try compress.uvarint(bytes[end_strings..]);
|
||||
const end_blob = end_strings + members_offset.bytes_read;
|
||||
const next_start = pad.roundUp(usize, alignment_bits, end_blob);
|
||||
|
||||
var next: ?[]const u8 = null;
|
||||
if (next_start < bytes.len)
|
||||
next = bytes[next_start..];
|
||||
|
||||
return Entry{
|
||||
.group = PackedGroup{
|
||||
.inner = inner,
|
||||
.groupdata = bytes[start_blob..end_strings],
|
||||
.members_offset = members_offset.value,
|
||||
},
|
||||
.next = next,
|
||||
};
|
||||
}
|
||||
|
||||
fn validateUtf8(s: []const u8) InvalidRecord!void {
|
||||
if (!std.unicode.utf8ValidateSlice(s))
|
||||
return error.InvalidRecord;
|
||||
}
|
||||
|
||||
pub const Iterator = struct {
|
||||
section: ?[]const u8,
|
||||
|
||||
pub fn next(it: *Iterator) error{Overflow}!?PackedGroup {
|
||||
if (it.section) |section| {
|
||||
const entry = try fromBytes(section);
|
||||
it.section = entry.next;
|
||||
return entry.group;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn iterator(section: []const u8) Iterator {
|
||||
return Iterator{ .section = section };
|
||||
}
|
||||
|
||||
pub fn gid(self: *const PackedGroup) u32 {
|
||||
return self.inner.gid;
|
||||
}
|
||||
|
||||
pub fn membersOffset(self: *const PackedGroup) u64 {
|
||||
return self.members_offset;
|
||||
}
|
||||
|
||||
pub fn name(self: *const PackedGroup) []const u8 {
|
||||
return self.groupdata;
|
||||
}
|
||||
|
||||
const packErr = validate.InvalidRecord || Allocator.Error || error{Overflow};
|
||||
pub fn packTo(
|
||||
arr: *ArrayList(u8),
|
||||
group: GroupStored,
|
||||
) packErr!void {
|
||||
std.debug.assert(arr.items.len & 7 == 0);
|
||||
try validate.utf8(group.name);
|
||||
const len = try validate.downCast(u5, group.name.len - 1);
|
||||
const inner = Inner{ .gid = group.gid, .groupname_len = len };
|
||||
try arr.*.appendSlice(mem.asBytes(&inner));
|
||||
try arr.*.appendSlice(group.name);
|
||||
try compress.appendUvarint(arr, group.members_offset);
|
||||
}
|
||||
};
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
// someMembers constructs a bufset from an allocator and a list of strings.
|
||||
pub fn someMembers(
|
||||
allocator: Allocator,
|
||||
members: []const []const u8,
|
||||
) Allocator.Error!BufSet {
|
||||
var bufset = BufSet.init(allocator);
|
||||
errdefer bufset.deinit();
|
||||
for (members) |member|
|
||||
try bufset.insert(member);
|
||||
return bufset;
|
||||
}
|
||||
|
||||
test "PackedGroup alignment" {
|
||||
try testing.expectEqual(@sizeOf(PackedGroup) * 8, @bitSizeOf(PackedGroup));
|
||||
}
|
||||
|
||||
test "construct PackedGroups" {
|
||||
var buf = ArrayList(u8).init(testing.allocator);
|
||||
defer buf.deinit();
|
||||
|
||||
const groups = [_]GroupStored{
|
||||
GroupStored{
|
||||
.gid = 1000,
|
||||
.name = "sudo",
|
||||
.members_offset = 1,
|
||||
},
|
||||
GroupStored{
|
||||
.gid = std.math.maxInt(u32),
|
||||
.name = "Name" ** 8, // 32
|
||||
.members_offset = std.math.maxInt(u64),
|
||||
},
|
||||
};
|
||||
|
||||
for (groups) |group| {
|
||||
try PackedGroup.packTo(&buf, group);
|
||||
try pad.arrayList(&buf, PackedGroup.alignment_bits);
|
||||
}
|
||||
|
||||
var i: u29 = 0;
|
||||
var it = PackedGroup.iterator(buf.items);
|
||||
while (try it.next()) |group| : (i += 1) {
|
||||
try testing.expectEqual(groups[i].gid, group.gid());
|
||||
try testing.expectEqualStrings(groups[i].name, group.name());
|
||||
try testing.expectEqual(groups[i].members_offset, group.membersOffset());
|
||||
}
|
||||
try testing.expectEqual(groups.len, i);
|
||||
}
|
||||
|
||||
test "Group.clone" {
|
||||
var allocator = testing.allocator;
|
||||
var arena = std.heap.ArenaAllocator.init(allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
var members = BufSet.init(allocator);
|
||||
try members.insert("member1");
|
||||
try members.insert("member2");
|
||||
defer members.deinit();
|
||||
|
||||
var cloned = try members.cloneWithAllocator(arena.allocator());
|
||||
|
||||
cloned.remove("member1");
|
||||
try cloned.insert("member4");
|
||||
try testing.expect(members.contains("member1"));
|
||||
try testing.expect(!members.contains("member4"));
|
||||
|
||||
try testing.expect(!cloned.contains("member1"));
|
||||
try testing.expect(cloned.contains("member4"));
|
||||
}
|
||||
105
src/header.zig
105
src/header.zig
@@ -1,105 +0,0 @@
|
||||
const std = @import("std");
|
||||
const native_endian = @import("builtin").target.cpu.arch.endian();
|
||||
const mem = std.mem;
|
||||
const max_shells = @import("shell.zig").max_shells;
|
||||
|
||||
const header_size = @sizeOf(Header);
|
||||
const magic = [4]u8{ 0xf0, 0x9f, 0xa4, 0xb7 };
|
||||
const version = 0;
|
||||
|
||||
const Endian = enum(u8) {
|
||||
big,
|
||||
little,
|
||||
|
||||
fn native() Endian {
|
||||
return switch (native_endian) {
|
||||
.Little => Endian.little,
|
||||
.Big => Endian.big,
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
pub const section_length_bits = 6;
|
||||
pub const section_length = 1 << section_length_bits;
|
||||
|
||||
pub const InvalidHeader = error{
|
||||
InvalidMagic,
|
||||
InvalidVersion,
|
||||
InvalidEndianess,
|
||||
TooManyShells,
|
||||
};
|
||||
|
||||
pub const Header = packed struct {
|
||||
magic: [4]u8 = magic,
|
||||
version: u8 = version,
|
||||
endian: Endian = Endian.native(),
|
||||
nblocks_shell_blob: u8,
|
||||
num_shells: u8,
|
||||
num_groups: u32,
|
||||
num_users: u32,
|
||||
nblocks_bdz_gid: u32,
|
||||
nblocks_bdz_groupname: u32,
|
||||
nblocks_bdz_uid: u32,
|
||||
nblocks_bdz_username: u32,
|
||||
nblocks_groups: u64,
|
||||
nblocks_users: u64,
|
||||
nblocks_groupmembers: u64,
|
||||
nblocks_additional_gids: u64,
|
||||
|
||||
pub fn fromBytes(blob: []const u8) InvalidHeader!Header {
|
||||
const self = mem.bytesAsValue(Header, blob);
|
||||
|
||||
if (!mem.eql(magic, blob[0..4]))
|
||||
return error.InvalidMagic;
|
||||
|
||||
if (self.version != 0)
|
||||
return error.InvalidVersion;
|
||||
|
||||
if (self.endian != Endian.native())
|
||||
return error.InvalidEndianess;
|
||||
|
||||
if (self.num_shells > max_shells)
|
||||
return error.TooManyShells;
|
||||
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn asBytes(self: *const Header) []const u8 {
|
||||
return mem.asBytes(self);
|
||||
}
|
||||
};
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
test "Section length is a power of two" {
|
||||
try testing.expect(std.math.isPowerOfTwo(section_length));
|
||||
}
|
||||
|
||||
test "bit header size is equal to @sizeOf(Header)" {
|
||||
try testing.expectEqual(@sizeOf(Header) * 8, @bitSizeOf(Header));
|
||||
}
|
||||
|
||||
test "header pack, unpack and validation" {
|
||||
//const goodHeader = Header{};
|
||||
|
||||
//const gotHeader = try Header.init(goodHeader.asArray());
|
||||
//try testing.expectEqual(goodHeader, gotHeader);
|
||||
|
||||
//{
|
||||
// var header = goodHeader;
|
||||
// header.magic[0] = 0;
|
||||
// try testing.expectError(error.InvalidMagic, Header.init(header.asArray()));
|
||||
//}
|
||||
|
||||
//{
|
||||
// var header = goodHeader;
|
||||
// header.bom = 0x3412;
|
||||
// try testing.expectError(error.InvalidBom, Header.init(header.asArray()));
|
||||
//}
|
||||
|
||||
//{
|
||||
// var header = goodHeader;
|
||||
// header.offset_bdz_uid2user = 65;
|
||||
// try testing.expectError(error.InvalidOffset, Header.init(header.asArray()));
|
||||
//}
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
pub fn main() !void {}
|
||||
@@ -1,53 +0,0 @@
|
||||
const std = @import("std");
|
||||
const assert = std.debug.assert;
|
||||
const Allocator = std.mem.Allocator;
|
||||
const ArrayList = std.ArrayList;
|
||||
|
||||
// rounds up an int to the nearest factor of nbits.
|
||||
pub fn roundUp(comptime T: type, comptime nbits: u8, n: T) T {
|
||||
comptime assert(nbits < @bitSizeOf(T));
|
||||
const factor = comptime (1 << nbits) - 1;
|
||||
return ((n + factor) & ~@as(T, factor));
|
||||
}
|
||||
|
||||
// rounds up an integer to the nearest factor of nbits and returns the
|
||||
// difference (padding)
|
||||
pub fn until(comptime T: type, comptime nbits: u8, n: T) T {
|
||||
return roundUp(T, nbits, n) - n;
|
||||
}
|
||||
|
||||
// arrayList adds padding to an ArrayList(u8) for a given number of nbits
|
||||
pub fn arrayList(arr: *ArrayList(u8), comptime nbits: u8) Allocator.Error!void {
|
||||
const padding = until(u64, nbits, arr.items.len);
|
||||
try arr.*.appendNTimes(0, padding);
|
||||
}
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
test "padding" {
|
||||
try testing.expectEqual(until(u12, 2, 0), 0);
|
||||
try testing.expectEqual(until(u12, 2, 1), 3);
|
||||
try testing.expectEqual(until(u12, 2, 2), 2);
|
||||
try testing.expectEqual(until(u12, 2, 3), 1);
|
||||
try testing.expectEqual(until(u12, 2, 4), 0);
|
||||
try testing.expectEqual(until(u12, 2, 40), 0);
|
||||
try testing.expectEqual(until(u12, 2, 41), 3);
|
||||
try testing.expectEqual(until(u12, 2, 42), 2);
|
||||
try testing.expectEqual(until(u12, 2, 43), 1);
|
||||
try testing.expectEqual(until(u12, 2, 44), 0);
|
||||
try testing.expectEqual(until(u12, 2, 4091), 1);
|
||||
try testing.expectEqual(until(u12, 2, 4092), 0);
|
||||
}
|
||||
|
||||
test "arrayList" {
|
||||
var buf = try ArrayList(u8).initCapacity(testing.allocator, 16);
|
||||
defer buf.deinit();
|
||||
|
||||
buf.appendAssumeCapacity(1);
|
||||
try arrayList(&buf, 3);
|
||||
try testing.expectEqual(buf.items.len, 8);
|
||||
|
||||
buf.appendAssumeCapacity(2);
|
||||
try arrayList(&buf, 10);
|
||||
try testing.expectEqual(buf.items.len, 1024);
|
||||
}
|
||||
850
src/sections.zig
850
src/sections.zig
@@ -1,850 +0,0 @@
|
||||
const std = @import("std");
|
||||
const os = std.os;
|
||||
const fmt = std.fmt;
|
||||
const mem = std.mem;
|
||||
const math = std.math;
|
||||
const sort = std.sort;
|
||||
const assert = std.debug.assert;
|
||||
const unicode = std.unicode;
|
||||
const Allocator = std.mem.Allocator;
|
||||
const ArenaAllocator = std.heap.ArenaAllocator;
|
||||
const ArrayListUnmanaged = std.ArrayListUnmanaged;
|
||||
const ArrayList = std.ArrayList;
|
||||
const MultiArrayList = std.MultiArrayList;
|
||||
const StringHashMap = std.StringHashMap;
|
||||
const AutoHashMap = std.AutoHashMap;
|
||||
const BufSet = std.BufSet;
|
||||
|
||||
const pad = @import("padding.zig");
|
||||
const compress = @import("compress.zig");
|
||||
const PackedUser = @import("user.zig").PackedUser;
|
||||
const User = @import("user.zig").User;
|
||||
const Group = @import("group.zig").Group;
|
||||
const GroupStored = @import("group.zig").GroupStored;
|
||||
const PackedGroup = @import("group.zig").PackedGroup;
|
||||
const ShellSections = @import("shell.zig").ShellWriter.ShellSections;
|
||||
const ShellReader = @import("shell.zig").ShellReader;
|
||||
const ShellWriter = @import("shell.zig").ShellWriter;
|
||||
const Header = @import("header.zig").Header;
|
||||
const max_shells = @import("shell.zig").max_shells;
|
||||
const section_length_bits = @import("header.zig").section_length_bits;
|
||||
const section_length = @import("header.zig").section_length;
|
||||
const cmph = @import("cmph.zig");
|
||||
const bdz = @import("bdz.zig");
|
||||
|
||||
const zeroes = &[_]u8{0} ** section_length;
|
||||
|
||||
const Corpus = struct {
|
||||
arena: ArenaAllocator,
|
||||
|
||||
// sorted by name, by unicode codepoint
|
||||
users: MultiArrayList(User),
|
||||
// sorted by gid
|
||||
groups: MultiArrayList(Group),
|
||||
|
||||
name2user: StringHashMap(u32),
|
||||
name2group: StringHashMap(u32),
|
||||
group2users: []const []const u32,
|
||||
user2groups: []const []const u32,
|
||||
|
||||
pub fn init(
|
||||
baseAllocator: Allocator,
|
||||
usersConst: []const User,
|
||||
groupsConst: []const Group,
|
||||
) error{ OutOfMemory, InvalidUtf8, Duplicate, NotFound }!Corpus {
|
||||
var arena = ArenaAllocator.init(baseAllocator);
|
||||
var allocator = arena.allocator();
|
||||
errdefer arena.deinit();
|
||||
|
||||
var users_arr = try allocator.alloc(User, usersConst.len);
|
||||
var groups_arr = try allocator.alloc(Group, groupsConst.len);
|
||||
for (usersConst) |*user, i|
|
||||
users_arr[i] = try user.clone(allocator);
|
||||
for (groupsConst) |*group, i|
|
||||
groups_arr[i] = try group.clone(allocator);
|
||||
|
||||
sort.sort(User, users_arr, {}, cmpUser);
|
||||
sort.sort(Group, groups_arr, {}, cmpGroup);
|
||||
|
||||
var users = MultiArrayList(User){};
|
||||
try users.ensureTotalCapacity(allocator, users_arr.len);
|
||||
for (users_arr) |user|
|
||||
users.appendAssumeCapacity(user);
|
||||
var groups = MultiArrayList(Group){};
|
||||
try groups.ensureTotalCapacity(allocator, groups_arr.len);
|
||||
for (groups_arr) |group|
|
||||
groups.appendAssumeCapacity(group);
|
||||
|
||||
var name2user = StringHashMap(u32).init(allocator);
|
||||
var name2group = StringHashMap(u32).init(allocator);
|
||||
for (users.items(.name)) |name, i| {
|
||||
var res1 = try name2user.getOrPut(name);
|
||||
if (res1.found_existing)
|
||||
return error.Duplicate;
|
||||
res1.value_ptr.* = @intCast(u32, i);
|
||||
}
|
||||
|
||||
for (groups.items(.name)) |name, i| {
|
||||
var res1 = try name2group.getOrPut(name);
|
||||
if (res1.found_existing)
|
||||
return error.Duplicate;
|
||||
res1.value_ptr.* = @intCast(u32, i);
|
||||
}
|
||||
|
||||
var group2users = try allocator.alloc([]u32, groups.len);
|
||||
|
||||
// uses baseAllocator, because it will be freed before
|
||||
// returning from this function. This keeps the arena clean.
|
||||
var user2groups = try baseAllocator.alloc(ArrayListUnmanaged(u32), users.len);
|
||||
defer baseAllocator.free(user2groups);
|
||||
mem.set(ArrayListUnmanaged(u32), user2groups, ArrayListUnmanaged(u32){});
|
||||
|
||||
for (groups.items(.members)) |groupmembers, i| {
|
||||
var members = try allocator.alloc(u32, groupmembers.count());
|
||||
members.len = 0;
|
||||
|
||||
var it = groupmembers.iterator();
|
||||
while (it.next()) |member_name| {
|
||||
if (name2user.get(member_name.*)) |user_idx| {
|
||||
members.len += 1;
|
||||
members[members.len - 1] = user_idx;
|
||||
try user2groups[user_idx].append(allocator, @intCast(u32, i));
|
||||
} else return error.NotFound;
|
||||
}
|
||||
|
||||
group2users[i] = members;
|
||||
}
|
||||
|
||||
for (group2users) |*groupusers|
|
||||
sort.sort(u32, groupusers.*, {}, comptime sort.asc(u32));
|
||||
|
||||
var user2groups_final = try allocator.alloc([]const u32, users.len);
|
||||
user2groups_final.len = users.len;
|
||||
for (user2groups) |*usergroups, i| {
|
||||
sort.sort(u32, usergroups.items, {}, comptime sort.asc(u32));
|
||||
user2groups_final[i] = usergroups.toOwnedSlice(allocator);
|
||||
}
|
||||
|
||||
return Corpus{
|
||||
.arena = arena,
|
||||
.users = users,
|
||||
.groups = groups,
|
||||
.name2user = name2user,
|
||||
.name2group = name2group,
|
||||
.group2users = group2users,
|
||||
.user2groups = user2groups_final,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Corpus) void {
|
||||
self.arena.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn shellSections(
|
||||
allocator: Allocator,
|
||||
corpus: *const Corpus,
|
||||
) error{ OutOfMemory, Overflow }!ShellSections {
|
||||
var popcon = ShellWriter.init(allocator);
|
||||
for (corpus.users.items(.shell)) |shell|
|
||||
try popcon.put(shell);
|
||||
return popcon.toOwnedSections(max_shells);
|
||||
}
|
||||
|
||||
pub const AdditionalGids = struct {
|
||||
// user index -> offset in blob
|
||||
idx2offset: []const u64,
|
||||
// compressed user gids blob. A blob contains N <= users.len items,
|
||||
// an item is:
|
||||
// len: varint
|
||||
// gid: [varint]varint,
|
||||
// ... and the gid list is delta-compressed.
|
||||
blob: []const u8,
|
||||
|
||||
pub fn deinit(self: *AdditionalGids, allocator: Allocator) void {
|
||||
allocator.free(self.idx2offset);
|
||||
allocator.free(self.blob);
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn userGids(
|
||||
allocator: Allocator,
|
||||
corpus: *const Corpus,
|
||||
) error{ OutOfMemory, Overflow }!AdditionalGids {
|
||||
var blob = ArrayList(u8).init(allocator);
|
||||
errdefer blob.deinit();
|
||||
var idx2offset = try allocator.alloc(u64, corpus.users.len);
|
||||
errdefer allocator.free(idx2offset);
|
||||
|
||||
// zero'th entry is empty, so groupless users can refer to it.
|
||||
try compress.appendUvarint(&blob, 0);
|
||||
|
||||
var scratch = try allocator.alloc(u32, 256);
|
||||
defer allocator.free(scratch);
|
||||
for (corpus.user2groups) |usergroups, user_idx| {
|
||||
if (usergroups.len == 0) {
|
||||
idx2offset[user_idx] = 0;
|
||||
continue;
|
||||
}
|
||||
idx2offset[user_idx] = blob.items.len;
|
||||
scratch = try allocator.realloc(scratch, usergroups.len);
|
||||
scratch.len = usergroups.len;
|
||||
const corpusGids = corpus.groups.items(.gid);
|
||||
for (usergroups) |group_idx, i|
|
||||
scratch[i] = corpusGids[group_idx];
|
||||
compress.deltaCompress(u32, scratch) catch |err| switch (err) {
|
||||
error.NotSorted => unreachable,
|
||||
};
|
||||
try compress.appendUvarint(&blob, usergroups.len);
|
||||
for (scratch) |gid|
|
||||
try compress.appendUvarint(&blob, gid);
|
||||
}
|
||||
|
||||
return AdditionalGids{
|
||||
.idx2offset = idx2offset,
|
||||
.blob = blob.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
pub const UsersSection = struct {
|
||||
// number of users in this section
|
||||
len: u32,
|
||||
// user index -> offset in blob
|
||||
idx2offset: []const u32,
|
||||
blob: []const u8,
|
||||
|
||||
pub fn deinit(self: *UsersSection, allocator: Allocator) void {
|
||||
allocator.free(self.idx2offset);
|
||||
allocator.free(self.blob);
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn usersSection(
|
||||
allocator: Allocator,
|
||||
corpus: *const Corpus,
|
||||
gids: *const AdditionalGids,
|
||||
shells: *const ShellSections,
|
||||
) error{ OutOfMemory, Overflow, InvalidRecord }!UsersSection {
|
||||
var idx2offset = try allocator.alloc(u32, corpus.users.len);
|
||||
errdefer allocator.free(idx2offset);
|
||||
// as of writing each user takes 12 bytes + blobs + padding, padded to
|
||||
// 8 bytes. 24 is an optimistic lower bound for an average record size.
|
||||
var blob = try ArrayList(u8).initCapacity(allocator, 24 * corpus.users.len);
|
||||
errdefer blob.deinit();
|
||||
var i: usize = 0;
|
||||
while (i < corpus.users.len) : (i += 1) {
|
||||
// TODO: this is inefficient by calling `.slice()` on every iteration
|
||||
const user = corpus.users.get(i);
|
||||
const user_offset = try math.cast(u35, blob.items.len);
|
||||
assert(user_offset & 7 == 0);
|
||||
idx2offset[i] = @truncate(u32, user_offset >> 3);
|
||||
try PackedUser.packTo(
|
||||
&blob,
|
||||
user,
|
||||
gids.idx2offset[i],
|
||||
shells.shell2idx,
|
||||
);
|
||||
try pad.arrayList(&blob, PackedUser.alignment_bits);
|
||||
}
|
||||
return UsersSection{
|
||||
.len = @intCast(u32, corpus.users.len),
|
||||
.idx2offset = idx2offset,
|
||||
.blob = blob.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
pub const GroupMembers = struct {
|
||||
// group index to it's offset in blob
|
||||
idx2offset: []const u64,
|
||||
// members are delta-varint encoded byte-offsets to the user struct
|
||||
blob: []const u8,
|
||||
|
||||
pub fn deinit(self: *GroupMembers, allocator: Allocator) void {
|
||||
allocator.free(self.idx2offset);
|
||||
allocator.free(self.blob);
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn groupMembers(
|
||||
allocator: Allocator,
|
||||
corpus: *const Corpus,
|
||||
user2offset: []const u32,
|
||||
) error{OutOfMemory}!GroupMembers {
|
||||
var idx2offset = try allocator.alloc(u64, corpus.groups.len);
|
||||
errdefer allocator.free(idx2offset);
|
||||
var blob = ArrayList(u8).init(allocator);
|
||||
errdefer blob.deinit();
|
||||
// zero'th entry is empty, so empty groups can refer to it
|
||||
try compress.appendUvarint(&blob, 0);
|
||||
|
||||
var scratch = try ArrayList(u32).initCapacity(allocator, 1024);
|
||||
defer scratch.deinit();
|
||||
|
||||
for (corpus.group2users) |members, group_idx| {
|
||||
if (members.len == 0) {
|
||||
idx2offset[group_idx] = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
idx2offset[group_idx] = blob.items.len;
|
||||
try scratch.ensureTotalCapacity(members.len);
|
||||
scratch.items.len = members.len;
|
||||
for (members) |user_idx, i|
|
||||
scratch.items[i] = user2offset[user_idx];
|
||||
|
||||
compress.deltaCompress(u32, scratch.items) catch |err| switch (err) {
|
||||
error.NotSorted => unreachable,
|
||||
};
|
||||
try compress.appendUvarint(&blob, members.len);
|
||||
for (scratch.items) |elem|
|
||||
try compress.appendUvarint(&blob, elem);
|
||||
}
|
||||
return GroupMembers{
|
||||
.idx2offset = idx2offset,
|
||||
.blob = blob.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
pub const GroupsSection = struct {
|
||||
// number of groups in this section
|
||||
len: u32,
|
||||
// group index -> offset in blob
|
||||
idx2offset: []const u32,
|
||||
blob: []const u8,
|
||||
|
||||
pub fn deinit(self: *GroupsSection, allocator: Allocator) void {
|
||||
allocator.free(self.idx2offset);
|
||||
allocator.free(self.blob);
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn groupsSection(
|
||||
allocator: Allocator,
|
||||
corpus: *const Corpus,
|
||||
members_offset: []const u64,
|
||||
) error{ OutOfMemory, Overflow, InvalidRecord }!GroupsSection {
|
||||
var idx2offset = try allocator.alloc(u32, corpus.groups.len);
|
||||
errdefer allocator.free(idx2offset);
|
||||
|
||||
var blob = try ArrayList(u8).initCapacity(allocator, 8 * corpus.groups.len);
|
||||
errdefer blob.deinit();
|
||||
|
||||
var i: usize = 0;
|
||||
while (i < corpus.groups.len) : (i += 1) {
|
||||
// TODO: this is inefficient; it's calling `.slice()` on every iteration
|
||||
const group = corpus.groups.get(i);
|
||||
const group_offset = try math.cast(u32, blob.items.len);
|
||||
assert(group_offset & 7 == 0);
|
||||
idx2offset[i] = @truncate(u32, group_offset >> 3);
|
||||
const group_stored = GroupStored{
|
||||
.gid = group.gid,
|
||||
.name = group.name,
|
||||
.members_offset = members_offset[i],
|
||||
};
|
||||
try PackedGroup.packTo(&blob, group_stored);
|
||||
try pad.arrayList(&blob, PackedGroup.alignment_bits);
|
||||
}
|
||||
|
||||
return GroupsSection{
|
||||
.len = @intCast(u32, corpus.groups.len),
|
||||
.idx2offset = idx2offset,
|
||||
.blob = blob.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
// creates a bdz index using packed_mphf.
|
||||
// hash = bdz_search(packed_mphf, keys[i]);
|
||||
// result[hash] = idx2offset[i];
|
||||
pub fn bdzIdx(
|
||||
comptime T: type,
|
||||
allocator: Allocator,
|
||||
packed_mphf: []const u8,
|
||||
keys: []const T,
|
||||
idx2offset: []const u32,
|
||||
) error{OutOfMemory}![]const u32 {
|
||||
const search_fn = comptime blk: {
|
||||
switch (T) {
|
||||
u32 => break :blk bdz.search_u32,
|
||||
[]const u8 => break :blk bdz.search,
|
||||
else => unreachable,
|
||||
}
|
||||
};
|
||||
assert(keys.len <= math.maxInt(u32));
|
||||
var result = try allocator.alloc(u32, keys.len);
|
||||
for (keys) |key, i|
|
||||
result[search_fn(packed_mphf, key)] = idx2offset[i];
|
||||
return result;
|
||||
}
|
||||
|
||||
// cmpUser compares two users for sorting. By username's utf8 codepoints, ascending.
|
||||
fn cmpUser(_: void, a: User, b: User) bool {
|
||||
var utf8_a = (unicode.Utf8View.init(a.name) catch unreachable).iterator();
|
||||
var utf8_b = (unicode.Utf8View.init(b.name) catch unreachable).iterator();
|
||||
while (utf8_a.nextCodepoint()) |codepoint_a| {
|
||||
if (utf8_b.nextCodepoint()) |codepoint_b| {
|
||||
if (codepoint_a == codepoint_b) {
|
||||
continue;
|
||||
} else return codepoint_a < codepoint_b;
|
||||
}
|
||||
|
||||
// a is a prefix of b. It is thus shorter.
|
||||
return false;
|
||||
}
|
||||
// b is a prefix of a
|
||||
return true;
|
||||
}
|
||||
|
||||
fn cmpGroup(_: void, a: Group, b: Group) bool {
|
||||
return a.gid < b.gid;
|
||||
}
|
||||
|
||||
// nblocks returns how many blocks a particular slice will take.
|
||||
fn nblocks(comptime T: type, arr: []const u8) T {
|
||||
const B = switch (T) {
|
||||
u8 => u14,
|
||||
u32 => u38,
|
||||
u64 => u70,
|
||||
else => @compileError("only u8, u32 and u64 are supported"),
|
||||
};
|
||||
const upper = pad.roundUp(B, section_length_bits, @intCast(B, arr.len));
|
||||
assert(upper & (section_length - 1) == 0);
|
||||
return @truncate(T, upper >> 6);
|
||||
}
|
||||
|
||||
pub const AllSections = struct {
|
||||
allocator: Allocator,
|
||||
|
||||
bdz_gid: []const u8,
|
||||
bdz_groupname: []const u8,
|
||||
bdz_uid: []const u8,
|
||||
bdz_username: []const u8,
|
||||
users: UsersSection,
|
||||
shell_sections: ShellSections,
|
||||
shell_reader: ShellReader,
|
||||
additional_gids: AdditionalGids,
|
||||
groupmembers: GroupMembers,
|
||||
groups: GroupsSection,
|
||||
idx_gid2group: []const u32,
|
||||
idx_groupname2group: []const u32,
|
||||
idx_uid2user: []const u32,
|
||||
idx_name2user: []const u32,
|
||||
header: []const u8,
|
||||
|
||||
pub fn init(
|
||||
allocator: Allocator,
|
||||
corpus: *const Corpus,
|
||||
) error{ Overflow, OutOfMemory, InvalidRecord }!AllSections {
|
||||
const gids = corpus.groups.items(.gid);
|
||||
const gnames = corpus.groups.items(.name);
|
||||
const uids = corpus.users.items(.uid);
|
||||
const unames = corpus.users.items(.name);
|
||||
|
||||
var bdz_gid = try cmph.packU32(allocator, gids);
|
||||
errdefer allocator.free(bdz_gid);
|
||||
|
||||
var bdz_groupname = try cmph.packStr(allocator, gnames);
|
||||
errdefer allocator.free(bdz_groupname);
|
||||
|
||||
var bdz_uid = try cmph.packU32(allocator, uids);
|
||||
errdefer allocator.free(bdz_uid);
|
||||
|
||||
const bdz_username = try cmph.packStr(allocator, unames);
|
||||
errdefer allocator.free(bdz_username);
|
||||
|
||||
var shell = try shellSections(allocator, corpus);
|
||||
errdefer shell.deinit();
|
||||
|
||||
var additional_gids = try userGids(allocator, corpus);
|
||||
errdefer additional_gids.deinit(allocator);
|
||||
|
||||
var users = try usersSection(allocator, corpus, &additional_gids, &shell);
|
||||
errdefer users.deinit(allocator);
|
||||
|
||||
var groupmembers = try groupMembers(allocator, corpus, users.idx2offset);
|
||||
errdefer groupmembers.deinit(allocator);
|
||||
|
||||
var groups = try groupsSection(allocator, corpus, groupmembers.idx2offset);
|
||||
errdefer groups.deinit(allocator);
|
||||
|
||||
var idx_gid2group = try bdzIdx(u32, allocator, bdz_gid, gids, groups.idx2offset);
|
||||
errdefer allocator.free(idx_gid2group);
|
||||
|
||||
var idx_groupname2group = try bdzIdx([]const u8, allocator, bdz_groupname, gnames, groups.idx2offset);
|
||||
errdefer allocator.free(idx_groupname2group);
|
||||
|
||||
var idx_uid2user = try bdzIdx(u32, allocator, bdz_uid, uids, users.idx2offset);
|
||||
errdefer allocator.free(idx_uid2user);
|
||||
|
||||
var idx_name2user = try bdzIdx([]const u8, allocator, bdz_username, unames, users.idx2offset);
|
||||
errdefer allocator.free(idx_name2user);
|
||||
|
||||
const header = Header{
|
||||
.nblocks_shell_blob = nblocks(u8, shell.blob.constSlice()),
|
||||
.num_shells = shell.len,
|
||||
.num_groups = groups.len,
|
||||
.num_users = users.len,
|
||||
.nblocks_bdz_gid = nblocks(u32, bdz_gid),
|
||||
.nblocks_bdz_groupname = nblocks(u32, bdz_groupname),
|
||||
.nblocks_bdz_uid = nblocks(u32, bdz_uid),
|
||||
.nblocks_bdz_username = nblocks(u32, bdz_username),
|
||||
.nblocks_groups = nblocks(u64, groups.blob),
|
||||
.nblocks_users = nblocks(u64, users.blob),
|
||||
.nblocks_groupmembers = nblocks(u64, groupmembers.blob),
|
||||
.nblocks_additional_gids = nblocks(u64, additional_gids.blob),
|
||||
};
|
||||
|
||||
return AllSections{
|
||||
.allocator = allocator,
|
||||
.bdz_gid = bdz_gid,
|
||||
.bdz_groupname = bdz_groupname,
|
||||
.bdz_uid = bdz_uid,
|
||||
.bdz_username = bdz_username,
|
||||
.shell_sections = shell,
|
||||
.shell_reader = ShellReader.init(
|
||||
mem.sliceAsBytes(shell.index.constSlice()),
|
||||
mem.sliceAsBytes(shell.blob.constSlice()),
|
||||
),
|
||||
.additional_gids = additional_gids,
|
||||
.users = users,
|
||||
.groupmembers = groupmembers,
|
||||
.groups = groups,
|
||||
.idx_gid2group = idx_gid2group,
|
||||
.idx_groupname2group = idx_groupname2group,
|
||||
.idx_uid2user = idx_uid2user,
|
||||
.idx_name2user = idx_name2user,
|
||||
.header = header.asBytes(),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn iov(self: *const AllSections) error{OutOfMemory}![]os.iovec_const {
|
||||
const sections = &[_][]const u8{
|
||||
self.header,
|
||||
self.bdz_gid,
|
||||
self.bdz_groupname,
|
||||
self.bdz_uid,
|
||||
self.bdz_username,
|
||||
mem.sliceAsBytes(self.idx_gid2group),
|
||||
mem.sliceAsBytes(self.idx_groupname2group),
|
||||
mem.sliceAsBytes(self.idx_uid2user),
|
||||
mem.sliceAsBytes(self.idx_name2user),
|
||||
mem.sliceAsBytes(self.shell_sections.index.constSlice()),
|
||||
mem.sliceAsBytes(self.shell_sections.blob.constSlice()),
|
||||
self.groups.blob,
|
||||
self.users.blob,
|
||||
self.groupmembers.blob,
|
||||
self.additional_gids.blob,
|
||||
};
|
||||
var result = try ArrayList(os.iovec_const).initCapacity(
|
||||
self.allocator,
|
||||
sections.len * 2,
|
||||
);
|
||||
errdefer result.deinit();
|
||||
|
||||
for (sections) |section| {
|
||||
result.appendAssumeCapacity(os.iovec_const{
|
||||
.iov_base = section.ptr,
|
||||
.iov_len = section.len,
|
||||
});
|
||||
const padding = pad.until(usize, section_length_bits, section.len);
|
||||
if (padding != 0)
|
||||
result.appendAssumeCapacity(.{
|
||||
.iov_base = zeroes,
|
||||
.iov_len = padding,
|
||||
});
|
||||
}
|
||||
|
||||
return result.toOwnedSlice();
|
||||
}
|
||||
|
||||
pub fn deinit(self: *AllSections) void {
|
||||
self.allocator.free(self.bdz_gid);
|
||||
self.allocator.free(self.bdz_groupname);
|
||||
self.allocator.free(self.bdz_uid);
|
||||
self.allocator.free(self.bdz_username);
|
||||
self.shell_sections.deinit();
|
||||
self.additional_gids.deinit(self.allocator);
|
||||
self.users.deinit(self.allocator);
|
||||
self.groupmembers.deinit(self.allocator);
|
||||
self.groups.deinit(self.allocator);
|
||||
self.allocator.free(self.idx_gid2group);
|
||||
self.allocator.free(self.idx_groupname2group);
|
||||
self.allocator.free(self.idx_uid2user);
|
||||
self.allocator.free(self.idx_name2user);
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
const testing = std.testing;
|
||||
const someMembers = @import("group.zig").someMembers;
|
||||
|
||||
fn testCorpus(allocator: Allocator) !Corpus {
|
||||
const users = [_]User{ User{
|
||||
.uid = 0,
|
||||
.gid = 0,
|
||||
.name = "root",
|
||||
.gecos = "",
|
||||
.home = "/root",
|
||||
.shell = "/bin/bash",
|
||||
}, User{
|
||||
.uid = 128,
|
||||
.gid = 128,
|
||||
.name = "vidmantas",
|
||||
.gecos = "Vidmantas Kaminskas",
|
||||
.home = "/home/vidmantas",
|
||||
.shell = "/bin/bash",
|
||||
}, User{
|
||||
.uid = 1000,
|
||||
.gid = math.maxInt(u32),
|
||||
.name = "Name" ** 8,
|
||||
.gecos = "Gecos" ** 51,
|
||||
.home = "Home" ** 16,
|
||||
.shell = "She.LllL" ** 8,
|
||||
}, User{
|
||||
.uid = 100000,
|
||||
.gid = 1002,
|
||||
.name = "svc-bar",
|
||||
.gecos = "",
|
||||
.home = "/",
|
||||
.shell = "/",
|
||||
}, User{
|
||||
.uid = 65534,
|
||||
.gid = 65534,
|
||||
.name = "nobody",
|
||||
.gecos = "nobody",
|
||||
.home = "/nonexistent",
|
||||
.shell = "/usr/sbin/nologin",
|
||||
} };
|
||||
|
||||
var members0 = try someMembers(
|
||||
allocator,
|
||||
&[_][]const u8{"root"},
|
||||
);
|
||||
defer members0.deinit();
|
||||
|
||||
var members1 = try someMembers(
|
||||
allocator,
|
||||
&[_][]const u8{"vidmantas"},
|
||||
);
|
||||
defer members1.deinit();
|
||||
|
||||
var members2 = try someMembers(
|
||||
allocator,
|
||||
&[_][]const u8{ "svc-bar", "vidmantas" },
|
||||
);
|
||||
defer members2.deinit();
|
||||
|
||||
var members3 = try someMembers(
|
||||
allocator,
|
||||
&[_][]const u8{ "svc-bar", "Name" ** 8, "vidmantas", "root" },
|
||||
);
|
||||
defer members3.deinit();
|
||||
|
||||
const groups = [_]Group{
|
||||
Group{ .gid = 0, .name = "root", .members = members0 },
|
||||
Group{ .gid = 128, .name = "vidmantas", .members = members1 },
|
||||
Group{ .gid = 9999, .name = "all", .members = members3 },
|
||||
Group{ .gid = 100000, .name = "service-account", .members = members2 },
|
||||
};
|
||||
|
||||
return try Corpus.init(allocator, users[0..], groups[0..]);
|
||||
}
|
||||
|
||||
test "test corpus" {
|
||||
var corpus = try testCorpus(testing.allocator);
|
||||
defer corpus.deinit();
|
||||
|
||||
const name_name = 0;
|
||||
const nobody = 1;
|
||||
const root = 2;
|
||||
const svc_bar = 3;
|
||||
const vidmantas = 4;
|
||||
|
||||
const usernames = corpus.users.items(.name);
|
||||
try testing.expectEqualStrings(usernames[name_name], "Name" ** 8);
|
||||
try testing.expectEqualStrings(usernames[nobody], "nobody");
|
||||
try testing.expectEqualStrings(usernames[root], "root");
|
||||
try testing.expectEqualStrings(usernames[svc_bar], "svc-bar");
|
||||
try testing.expectEqualStrings(usernames[vidmantas], "vidmantas");
|
||||
|
||||
const g_root = 0;
|
||||
const g_vidmantas = 1;
|
||||
const g_all = 2;
|
||||
const g_service_account = 3;
|
||||
|
||||
const groupnames = corpus.groups.items(.name);
|
||||
try testing.expectEqualStrings(groupnames[g_root], "root");
|
||||
try testing.expectEqualStrings(groupnames[g_service_account], "service-account");
|
||||
try testing.expectEqualStrings(groupnames[g_vidmantas], "vidmantas");
|
||||
try testing.expectEqualStrings(groupnames[g_all], "all");
|
||||
|
||||
try testing.expectEqual(corpus.name2user.get("404"), null);
|
||||
try testing.expectEqual(corpus.name2user.get("vidmantas").?, vidmantas);
|
||||
try testing.expectEqual(corpus.name2group.get("404"), null);
|
||||
try testing.expectEqual(corpus.name2group.get("vidmantas").?, g_vidmantas);
|
||||
|
||||
const membersOfAll = corpus.group2users[g_all];
|
||||
try testing.expectEqual(membersOfAll[0], name_name);
|
||||
try testing.expectEqual(membersOfAll[1], root);
|
||||
try testing.expectEqual(membersOfAll[2], svc_bar);
|
||||
try testing.expectEqual(membersOfAll[3], vidmantas);
|
||||
|
||||
const groupsOfVidmantas = corpus.user2groups[vidmantas];
|
||||
try testing.expectEqual(groupsOfVidmantas[0], g_vidmantas);
|
||||
try testing.expectEqual(groupsOfVidmantas[1], g_all);
|
||||
try testing.expectEqual(groupsOfVidmantas[2], g_service_account);
|
||||
}
|
||||
|
||||
test "test groups, group members and users" {
|
||||
const allocator = testing.allocator;
|
||||
var corpus = try testCorpus(allocator);
|
||||
defer corpus.deinit();
|
||||
|
||||
var sections = try AllSections.init(allocator, &corpus);
|
||||
defer sections.deinit();
|
||||
|
||||
const blob = sections.groupmembers.blob;
|
||||
var i: usize = 0;
|
||||
while (i < corpus.groups.len) : (i += 1) {
|
||||
const offset = sections.groupmembers.idx2offset[i];
|
||||
var vit = try compress.VarintSliceIterator(blob[offset..]);
|
||||
var it = compress.DeltaDecompressionIterator(&vit);
|
||||
for (corpus.group2users[i]) |user_idx| {
|
||||
const got_user_offset = (try it.next()).?;
|
||||
const want_user_offset = sections.users.idx2offset[user_idx];
|
||||
try testing.expectEqual(got_user_offset, want_user_offset);
|
||||
}
|
||||
try testing.expectEqual(it.next(), null);
|
||||
}
|
||||
|
||||
var it = PackedUser.iterator(sections.users.blob, sections.shell_reader);
|
||||
i = 0;
|
||||
while (i < corpus.users.len) : (i += 1) {
|
||||
const got = (try it.next()).?;
|
||||
const user = corpus.users.get(i);
|
||||
try testing.expectEqual(user.uid, got.uid());
|
||||
try testing.expectEqual(user.gid, got.gid());
|
||||
try testing.expectEqualStrings(user.name, got.name());
|
||||
try testing.expectEqualStrings(user.gecos, got.gecos());
|
||||
try testing.expectEqualStrings(user.home, got.home());
|
||||
try testing.expectEqualStrings(user.shell, got.shell(sections.shell_reader));
|
||||
}
|
||||
|
||||
var iovec = try sections.iov();
|
||||
allocator.free(iovec);
|
||||
}
|
||||
|
||||
test "userGids" {
|
||||
const allocator = testing.allocator;
|
||||
var corpus = try testCorpus(allocator);
|
||||
defer corpus.deinit();
|
||||
|
||||
var additional_gids = try userGids(allocator, &corpus);
|
||||
defer additional_gids.deinit(allocator);
|
||||
|
||||
var user_idx: usize = 0;
|
||||
while (user_idx < corpus.users.len) : (user_idx += 1) {
|
||||
const groups = corpus.user2groups[user_idx];
|
||||
const offset = additional_gids.idx2offset[user_idx];
|
||||
if (groups.len == 0) {
|
||||
try testing.expect(offset == 0);
|
||||
continue;
|
||||
}
|
||||
var vit = try compress.VarintSliceIterator(additional_gids.blob[offset..]);
|
||||
var it = compress.DeltaDecompressionIterator(&vit);
|
||||
try testing.expectEqual(it.remaining(), groups.len);
|
||||
var i: u64 = 0;
|
||||
const corpusGids = corpus.groups.items(.gid);
|
||||
while (try it.next()) |gid| : (i += 1) {
|
||||
try testing.expectEqual(gid, corpusGids[groups[i]]);
|
||||
}
|
||||
try testing.expectEqual(i, groups.len);
|
||||
}
|
||||
}
|
||||
|
||||
test "pack gids" {
|
||||
const allocator = testing.allocator;
|
||||
var corpus = try testCorpus(allocator);
|
||||
defer corpus.deinit();
|
||||
|
||||
const cmph_gid = try cmph.packU32(allocator, corpus.groups.items(.gid));
|
||||
defer allocator.free(cmph_gid);
|
||||
|
||||
const k1 = bdz.search_u32(cmph_gid, 0);
|
||||
const k2 = bdz.search_u32(cmph_gid, 128);
|
||||
const k3 = bdz.search_u32(cmph_gid, 9999);
|
||||
const k4 = bdz.search_u32(cmph_gid, 100000);
|
||||
var hashes = &[_]u32{ k1, k2, k3, k4 };
|
||||
sort.sort(u32, hashes, {}, comptime sort.asc(u32));
|
||||
for (hashes) |hash, i|
|
||||
try testing.expectEqual(i, hash);
|
||||
}
|
||||
|
||||
fn testUser(name: []const u8) User {
|
||||
var result = mem.zeroes(User);
|
||||
result.name = name;
|
||||
return result;
|
||||
}
|
||||
|
||||
test "users compare function" {
|
||||
const a = testUser("a");
|
||||
const b = testUser("b");
|
||||
const bb = testUser("bb");
|
||||
try testing.expect(cmpUser({}, a, b));
|
||||
try testing.expect(!cmpUser({}, b, a));
|
||||
try testing.expect(cmpUser({}, a, bb));
|
||||
try testing.expect(!cmpUser({}, bb, a));
|
||||
try testing.expect(cmpUser({}, b, bb));
|
||||
try testing.expect(!cmpUser({}, bb, b));
|
||||
}
|
||||
|
||||
const hash_offsets = &[_]u32{ 0, 10, 20, 30 };
|
||||
|
||||
fn expectUsedHashes(allocator: Allocator, arr: []const u32) !void {
|
||||
var used = AutoHashMap(u32, void).init(allocator);
|
||||
defer used.deinit();
|
||||
|
||||
for (arr) |elem|
|
||||
try used.putNoClobber(elem, {});
|
||||
for (hash_offsets) |item|
|
||||
try testing.expect(used.get(item) != null);
|
||||
}
|
||||
|
||||
test "bdzIdx on u32" {
|
||||
const keys = [_]u32{ 42, 1, 2, 3 };
|
||||
const mphf = try cmph.packU32(testing.allocator, keys[0..]);
|
||||
defer testing.allocator.free(mphf);
|
||||
var result = try bdzIdx(u32, testing.allocator, mphf, keys[0..], hash_offsets);
|
||||
defer testing.allocator.free(result);
|
||||
try expectUsedHashes(testing.allocator, result);
|
||||
}
|
||||
|
||||
test "bdzIdx on str" {
|
||||
const keys = [_][]const u8{ "42", "1", "2", "3" };
|
||||
const mphf = try cmph.packStr(testing.allocator, keys[0..]);
|
||||
defer testing.allocator.free(mphf);
|
||||
var result = try bdzIdx([]const u8, testing.allocator, mphf, keys[0..], hash_offsets);
|
||||
defer testing.allocator.free(result);
|
||||
try expectUsedHashes(testing.allocator, result);
|
||||
}
|
||||
|
||||
test "nblocks" {
|
||||
const tests = .{
|
||||
.{ 0, &[_]u8{} },
|
||||
.{ 1, &[_]u8{ 1, 2, 42 } },
|
||||
.{ 1, &[_]u8{1} ** 63 },
|
||||
.{ 1, &[_]u8{1} ** 64 },
|
||||
.{ 2, &[_]u8{1} ** 65 },
|
||||
.{ 255, &[_]u8{1} ** (255 * 64) },
|
||||
};
|
||||
|
||||
inline for (tests) |tt| {
|
||||
try testing.expectEqual(nblocks(u8, tt[1]), tt[0]);
|
||||
try testing.expectEqual(nblocks(u32, tt[1]), tt[0]);
|
||||
try testing.expectEqual(nblocks(u64, tt[1]), tt[0]);
|
||||
}
|
||||
}
|
||||
196
src/shell.zig
196
src/shell.zig
@@ -1,196 +0,0 @@
|
||||
const std = @import("std");
|
||||
const Allocator = std.mem.Allocator;
|
||||
const PriorityDequeue = std.PriorityDequeue;
|
||||
const StringArrayHashMap = std.StringArrayHashMap;
|
||||
const StringHashMap = std.StringHashMap;
|
||||
const BoundedArray = std.BoundedArray;
|
||||
const StringContext = std.hash_map.StringContext;
|
||||
|
||||
pub const max_shells = 255;
|
||||
pub const max_shell_len = 256;
|
||||
|
||||
// ShellReader interprets "Shell Index" and "Shell Blob" sections.
|
||||
pub const ShellReader = struct {
|
||||
index: []const u16,
|
||||
blob: []const u8,
|
||||
|
||||
pub fn init(index: []align(2) const u8, blob: []const u8) ShellReader {
|
||||
return ShellReader{
|
||||
.index = std.mem.bytesAsSlice(u16, index),
|
||||
.blob = blob,
|
||||
};
|
||||
}
|
||||
|
||||
// get returns a shell at the given index.
|
||||
pub fn get(self: *const ShellReader, idx: u8) []const u8 {
|
||||
return self.blob[self.index[idx]..self.index[idx + 1]];
|
||||
}
|
||||
};
|
||||
|
||||
// ShellWriter is a shell popularity contest: collect shells and return the
|
||||
// popular ones, sorted by score. score := len(shell) * number_of_shells.
|
||||
pub const ShellWriter = struct {
|
||||
counts: std.StringHashMap(u32),
|
||||
allocator: Allocator,
|
||||
const KV = struct {
|
||||
shell: []const u8,
|
||||
score: u64,
|
||||
};
|
||||
|
||||
pub const ShellSections = struct {
|
||||
// len is the number of shells in this section.
|
||||
len: u8,
|
||||
// index points the i'th shell to it's offset in blob. The last
|
||||
// byte of the i'th shell is index[i+1].
|
||||
index: BoundedArray(u16, max_shells),
|
||||
// blob contains `index.len+1` number of records. The last record is
|
||||
// pointing to the end of the blob, so length of the last shell can be
|
||||
// calculated from the index array.
|
||||
blob: BoundedArray(u8, (max_shells + 1) * max_shell_len),
|
||||
// shell2idx helps translate a shell (string) to it's index.
|
||||
shell2idx: StringHashMap(u8),
|
||||
|
||||
// initializes and populates shell sections. All strings are copied,
|
||||
// nothing is owned.
|
||||
pub fn init(
|
||||
allocator: Allocator,
|
||||
shells: BoundedArray([]const u8, max_shells),
|
||||
) error{ Overflow, OutOfMemory }!ShellSections {
|
||||
var self = ShellSections{
|
||||
.len = @intCast(u8, shells.len),
|
||||
.index = try BoundedArray(u16, max_shells).init(shells.len),
|
||||
.blob = try BoundedArray(u8, (max_shells + 1) * max_shell_len).init(0),
|
||||
.shell2idx = StringHashMap(u8).init(allocator),
|
||||
};
|
||||
if (shells.len == 0) return self;
|
||||
|
||||
errdefer self.shell2idx.deinit();
|
||||
for (shells.constSlice()) |shell, idx| {
|
||||
const idx8 = @intCast(u8, idx);
|
||||
const offset = @intCast(u16, self.blob.len);
|
||||
try self.blob.appendSlice(shell);
|
||||
try self.shell2idx.put(self.blob.constSlice()[offset..], idx8);
|
||||
self.index.set(idx8, offset);
|
||||
}
|
||||
try self.index.append(@intCast(u8, self.blob.len));
|
||||
return self;
|
||||
}
|
||||
|
||||
pub fn section_index(self: *const ShellSections) []align(2) const u8 {
|
||||
return std.mem.sliceAsBytes(self.index.constSlice());
|
||||
}
|
||||
|
||||
pub fn section_blob(self: *const ShellSections) []const u8 {
|
||||
return self.blob.constSlice();
|
||||
}
|
||||
|
||||
pub fn deinit(self: *ShellSections) void {
|
||||
self.shell2idx.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
|
||||
pub fn getIndex(self: *const ShellSections, shell: []const u8) ?u8 {
|
||||
return self.shell2idx.get(shell);
|
||||
}
|
||||
};
|
||||
|
||||
pub fn init(allocator: Allocator) ShellWriter {
|
||||
return ShellWriter{
|
||||
.counts = std.StringHashMap(u32).init(allocator),
|
||||
.allocator = allocator,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: *ShellWriter) void {
|
||||
var it = self.counts.keyIterator();
|
||||
while (it.next()) |key_ptr|
|
||||
self.counts.allocator.free(key_ptr.*);
|
||||
self.counts.deinit();
|
||||
self.* = undefined;
|
||||
}
|
||||
|
||||
pub fn put(self: *ShellWriter, shell: []const u8) !void {
|
||||
const res = try self.counts.getOrPutAdapted(shell, self.counts.ctx);
|
||||
if (!res.found_existing) {
|
||||
res.key_ptr.* = try self.allocator.dupe(u8, shell);
|
||||
res.value_ptr.* = 1;
|
||||
} else {
|
||||
res.value_ptr.* += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn cmpShells(_: void, a: KV, b: KV) std.math.Order {
|
||||
return std.math.order(a.score, b.score);
|
||||
}
|
||||
|
||||
// toOwnedSections returns the analyzed ShellSections. Resets the shell
|
||||
// popularity contest. ShellSections memory is allocated by the ShellWriter
|
||||
// allocator, and must be deInit'ed by the caller.
|
||||
pub fn toOwnedSections(
|
||||
self: *ShellWriter,
|
||||
limit: u10,
|
||||
) error{ Overflow, OutOfMemory }!ShellSections {
|
||||
var deque = PriorityDequeue(KV, void, cmpShells).init(self.allocator, {});
|
||||
defer deque.deinit();
|
||||
|
||||
var it = self.counts.iterator();
|
||||
while (it.next()) |entry| {
|
||||
if (entry.value_ptr.* == 1)
|
||||
continue;
|
||||
const score = entry.key_ptr.*.len * entry.value_ptr.*;
|
||||
try deque.add(KV{ .shell = entry.key_ptr.*, .score = score });
|
||||
}
|
||||
|
||||
const total = std.math.min(deque.count(), limit);
|
||||
var topShells = try BoundedArray([]const u8, max_shells).init(total);
|
||||
|
||||
var i: u32 = 0;
|
||||
while (i < total) : (i += 1)
|
||||
topShells.set(i, deque.removeMax().shell);
|
||||
|
||||
const result = ShellSections.init(self.allocator, topShells);
|
||||
self.deinit();
|
||||
self.* = init(self.allocator);
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
test "basic shellpopcon" {
|
||||
var popcon = ShellWriter.init(testing.allocator);
|
||||
|
||||
const bash = "/bin/bash"; // 9 chars
|
||||
const zsh = "/bin/zsh"; // 8 chars
|
||||
const long = "/bin/very-long-shell-name-ought-to-be-first"; // 43 chars
|
||||
const nobody = "/bin/nobody"; // only 1 instance, ought to ignore
|
||||
const input = [_][]const u8{
|
||||
zsh, zsh, zsh, zsh, // zsh score 8*4=32
|
||||
bash, bash, bash, nobody, // bash score 3*9=27
|
||||
long, long, // long score 2*43=86
|
||||
};
|
||||
|
||||
for (input) |shell| {
|
||||
try popcon.put(shell);
|
||||
}
|
||||
|
||||
var sections = try popcon.toOwnedSections(max_shells);
|
||||
defer sections.deinit();
|
||||
try testing.expectEqual(sections.index.len, 4); // all but "nobody" qualify
|
||||
|
||||
try testing.expectEqual(sections.getIndex(long).?, 0);
|
||||
try testing.expectEqual(sections.getIndex(zsh).?, 1);
|
||||
try testing.expectEqual(sections.getIndex(bash).?, 2);
|
||||
try testing.expectEqual(sections.getIndex(nobody), null);
|
||||
try testing.expectEqual(sections.section_blob().len, bash.len + zsh.len + long.len);
|
||||
|
||||
const shellReader = ShellReader.init(
|
||||
sections.section_index(),
|
||||
sections.section_blob(),
|
||||
);
|
||||
try testing.expectEqualStrings(shellReader.get(0), long);
|
||||
try testing.expectEqualStrings(shellReader.get(1), zsh);
|
||||
try testing.expectEqualStrings(shellReader.get(2), bash);
|
||||
|
||||
try testing.expectEqual(shellReader.index.len, 4);
|
||||
}
|
||||
20
src/so.zig
20
src/so.zig
@@ -1,20 +0,0 @@
|
||||
const Passwd = extern struct {
|
||||
// zig fmt: off
|
||||
pw_name: [*:0]u8, // username
|
||||
pw_passwd: [*:0]const u8, // user password, always '*'
|
||||
pw_uid: u32, // user ID
|
||||
pw_gid: u32, // group ID
|
||||
pw_gecos: [*:0]const u8, // user information
|
||||
pw_dir: [*:0]const u8, // home directory
|
||||
pw_shell: [*:0]const u8, // shell program
|
||||
// zig fmt: on
|
||||
};
|
||||
|
||||
const Group = extern struct {
|
||||
// zig fmt: off
|
||||
gr_name: [*:0]u8, // group name
|
||||
gr_passwd: [*:0]u8, // group password, always '*'
|
||||
gr_gid: u32, // group ID
|
||||
gr_mem: [*:0][*:0] const u8, // NULL-terminated array of pointers to group members
|
||||
// zig fmt: off
|
||||
};
|
||||
@@ -1,14 +0,0 @@
|
||||
test "turbonss test suite" {
|
||||
_ = @import("main.zig");
|
||||
_ = @import("header.zig");
|
||||
_ = @import("so.zig");
|
||||
_ = @import("sections.zig");
|
||||
_ = @import("shell.zig");
|
||||
_ = @import("user.zig");
|
||||
_ = @import("group.zig");
|
||||
_ = @import("validate.zig");
|
||||
_ = @import("padding.zig");
|
||||
_ = @import("compress.zig");
|
||||
_ = @import("cmph.zig");
|
||||
_ = @import("bdz.zig");
|
||||
}
|
||||
353
src/user.zig
353
src/user.zig
@@ -1,353 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
const pad = @import("padding.zig");
|
||||
const validate = @import("validate.zig");
|
||||
const compress = @import("compress.zig");
|
||||
const shellImport = @import("shell.zig");
|
||||
const InvalidRecord = validate.InvalidRecord;
|
||||
|
||||
const assert = std.debug.assert;
|
||||
const mem = std.mem;
|
||||
const math = std.math;
|
||||
const Allocator = mem.Allocator;
|
||||
const ArrayList = std.ArrayList;
|
||||
const StringHashMap = std.StringHashMap;
|
||||
|
||||
// User is a convenient public struct for record construction and
|
||||
// serialization.
|
||||
pub const User = struct {
|
||||
uid: u32,
|
||||
gid: u32,
|
||||
name: []const u8,
|
||||
gecos: []const u8,
|
||||
home: []const u8,
|
||||
shell: []const u8,
|
||||
|
||||
// deep-clones a User record with a given Allocator.
|
||||
pub fn clone(
|
||||
self: *const User,
|
||||
allocator: Allocator,
|
||||
) Allocator.Error!User {
|
||||
const stringdata = try allocator.alloc(u8, self.strlen());
|
||||
const gecos_start = self.name.len;
|
||||
const home_start = gecos_start + self.gecos.len;
|
||||
const shell_start = home_start + self.home.len;
|
||||
mem.copy(u8, stringdata[0..self.name.len], self.name);
|
||||
mem.copy(u8, stringdata[gecos_start..], self.gecos);
|
||||
mem.copy(u8, stringdata[home_start..], self.home);
|
||||
mem.copy(u8, stringdata[shell_start..], self.shell);
|
||||
|
||||
return User{
|
||||
.uid = self.uid,
|
||||
.gid = self.gid,
|
||||
.name = stringdata[0..self.name.len],
|
||||
.gecos = stringdata[gecos_start .. gecos_start + self.gecos.len],
|
||||
.home = stringdata[home_start .. home_start + self.home.len],
|
||||
.shell = stringdata[shell_start .. shell_start + self.shell.len],
|
||||
};
|
||||
}
|
||||
|
||||
fn strlen(self: *const User) usize {
|
||||
return self.name.len +
|
||||
self.gecos.len +
|
||||
self.home.len +
|
||||
self.shell.len;
|
||||
}
|
||||
|
||||
pub fn deinit(self: *User, allocator: Allocator) void {
|
||||
const slice = self.home.ptr[0..self.strlen()];
|
||||
allocator.free(slice);
|
||||
self.* = undefined;
|
||||
}
|
||||
};
|
||||
|
||||
pub const PackedUser = struct {
|
||||
const Self = @This();
|
||||
|
||||
pub const alignment_bits = 3;
|
||||
|
||||
const Inner = packed struct {
|
||||
uid: u32,
|
||||
gid: u32,
|
||||
shell_len_or_idx: u8,
|
||||
shell_here: bool,
|
||||
name_is_a_suffix: bool,
|
||||
home_len: u6,
|
||||
name_len: u5,
|
||||
gecos_len: u11,
|
||||
|
||||
fn homeLen(self: *const Inner) usize {
|
||||
return @as(u32, self.home_len) + 1;
|
||||
}
|
||||
|
||||
fn nameStart(self: *const Inner) usize {
|
||||
const name_len = self.nameLen();
|
||||
if (self.name_is_a_suffix) {
|
||||
return self.homeLen() - name_len;
|
||||
} else return self.homeLen();
|
||||
}
|
||||
|
||||
fn nameLen(self: *const Inner) usize {
|
||||
return @as(u32, self.name_len) + 1;
|
||||
}
|
||||
|
||||
fn gecosStart(self: *const Inner) usize {
|
||||
if (self.name_is_a_suffix) {
|
||||
return self.homeLen();
|
||||
} else return self.homeLen() + self.nameLen();
|
||||
}
|
||||
|
||||
fn gecosLen(self: *const Inner) usize {
|
||||
return self.gecos_len;
|
||||
}
|
||||
|
||||
fn maybeShellStart(self: *const Inner) usize {
|
||||
assert(self.shell_here);
|
||||
return self.gecosStart() + self.gecosLen();
|
||||
}
|
||||
|
||||
fn shellLen(self: *const Inner) usize {
|
||||
return @as(u32, self.shell_len_or_idx) + 1;
|
||||
}
|
||||
|
||||
// stringLength returns the length of the blob storing string values.
|
||||
fn stringLength(self: *const Inner) usize {
|
||||
var result: usize = self.homeLen() + self.gecosLen();
|
||||
if (!self.name_is_a_suffix)
|
||||
result += self.nameLen();
|
||||
if (self.shell_here)
|
||||
result += self.shellLen();
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
// PackedUser does not allocate; it re-interprets the "bytes" blob
|
||||
// field. Both of those fields are pointers to "our representation" of
|
||||
// that field.
|
||||
inner: *const Inner,
|
||||
bytes: []const u8,
|
||||
additional_gids_offset: u64,
|
||||
|
||||
pub const Entry = struct {
|
||||
user: Self,
|
||||
next: ?[]const u8,
|
||||
};
|
||||
|
||||
// TODO(motiejus) provide a way to return an entry without decoding the
|
||||
// additional_gids_offset:
|
||||
// - will not return the 'next' slice.
|
||||
// - cannot throw an Overflow error.
|
||||
pub fn fromBytes(bytes: []const u8) error{Overflow}!Entry {
|
||||
const inner = mem.bytesAsValue(Inner, bytes[0..@sizeOf(Inner)]);
|
||||
const start_blob = @sizeOf(Inner);
|
||||
const end_strings = start_blob + inner.stringLength();
|
||||
const gids_offset = try compress.uvarint(bytes[end_strings..]);
|
||||
const end_blob = end_strings + gids_offset.bytes_read;
|
||||
|
||||
const nextStart = pad.roundUp(usize, alignment_bits, end_blob);
|
||||
var next: ?[]const u8 = null;
|
||||
if (nextStart < bytes.len)
|
||||
next = bytes[nextStart..];
|
||||
|
||||
return Entry{
|
||||
.user = Self{
|
||||
.inner = inner,
|
||||
.bytes = bytes[start_blob..end_blob],
|
||||
.additional_gids_offset = gids_offset.value,
|
||||
},
|
||||
.next = next,
|
||||
};
|
||||
}
|
||||
|
||||
pub const Iterator = struct {
|
||||
section: ?[]const u8,
|
||||
shell_reader: shellImport.ShellReader,
|
||||
|
||||
pub fn next(it: *Iterator) error{Overflow}!?Self {
|
||||
if (it.section) |section| {
|
||||
const entry = try Self.fromBytes(section);
|
||||
it.section = entry.next;
|
||||
return entry.user;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
pub fn iterator(section: []const u8, shell_reader: shellImport.ShellReader) Iterator {
|
||||
return Iterator{ .section = section, .shell_reader = shell_reader };
|
||||
}
|
||||
|
||||
// packTo packs the User record and copies it to the given byte slice.
|
||||
// The slice must have at least maxRecordSize() bytes available. The
|
||||
// slice is passed as a pointer, so it can be mutated.
|
||||
pub fn packTo(
|
||||
arr: *ArrayList(u8),
|
||||
user: User,
|
||||
additional_gids_offset: u64,
|
||||
idxFn: StringHashMap(u8),
|
||||
) error{ InvalidRecord, OutOfMemory }!void {
|
||||
std.debug.assert(arr.items.len & 7 == 0);
|
||||
// function arguments are consts. We need to mutate the underlying
|
||||
// slice, so passing it via pointer instead.
|
||||
const home_len = try validate.downCast(u6, user.home.len - 1);
|
||||
const name_len = try validate.downCast(u5, user.name.len - 1);
|
||||
const shell_len = try validate.downCast(u8, user.shell.len - 1);
|
||||
const gecos_len = try validate.downCast(u8, user.gecos.len);
|
||||
|
||||
try validate.utf8(user.home);
|
||||
try validate.utf8(user.name);
|
||||
try validate.utf8(user.shell);
|
||||
try validate.utf8(user.gecos);
|
||||
|
||||
const inner = Inner{
|
||||
.uid = user.uid,
|
||||
.gid = user.gid,
|
||||
.shell_here = idxFn.get(user.shell) == null,
|
||||
.shell_len_or_idx = idxFn.get(user.shell) orelse shell_len,
|
||||
.home_len = home_len,
|
||||
.name_is_a_suffix = mem.endsWith(u8, user.home, user.name),
|
||||
.name_len = name_len,
|
||||
.gecos_len = gecos_len,
|
||||
};
|
||||
const innerBytes = mem.asBytes(&inner);
|
||||
|
||||
try arr.*.appendSlice(innerBytes[0..@sizeOf(Inner)]);
|
||||
try arr.*.appendSlice(user.home);
|
||||
|
||||
if (!inner.name_is_a_suffix)
|
||||
try arr.*.appendSlice(user.name);
|
||||
try arr.*.appendSlice(user.gecos);
|
||||
if (inner.shell_here)
|
||||
try arr.*.appendSlice(user.shell);
|
||||
try compress.appendUvarint(arr, additional_gids_offset);
|
||||
}
|
||||
|
||||
pub fn uid(self: Self) u32 {
|
||||
return self.inner.uid;
|
||||
}
|
||||
|
||||
pub fn gid(self: Self) u32 {
|
||||
return self.inner.gid;
|
||||
}
|
||||
|
||||
pub fn additionalGidsOffset(self: Self) u64 {
|
||||
return self.additional_gids_offset;
|
||||
}
|
||||
|
||||
pub fn home(self: Self) []const u8 {
|
||||
return self.bytes[0..self.inner.homeLen()];
|
||||
}
|
||||
|
||||
pub fn name(self: Self) []const u8 {
|
||||
const name_pos = self.inner.nameStart();
|
||||
const name_len = self.inner.nameLen();
|
||||
return self.bytes[name_pos .. name_pos + name_len];
|
||||
}
|
||||
|
||||
pub fn gecos(self: Self) []const u8 {
|
||||
const gecos_pos = self.inner.gecosStart();
|
||||
const gecos_len = self.inner.gecosLen();
|
||||
return self.bytes[gecos_pos .. gecos_pos + gecos_len];
|
||||
}
|
||||
|
||||
pub fn shell(self: Self, shell_reader: shellImport.ShellReader) []const u8 {
|
||||
if (self.inner.shell_here) {
|
||||
const shell_pos = self.inner.maybeShellStart();
|
||||
const shell_len = self.inner.shellLen();
|
||||
return self.bytes[shell_pos .. shell_pos + shell_len];
|
||||
}
|
||||
return shell_reader.get(self.inner.shell_len_or_idx);
|
||||
}
|
||||
};
|
||||
|
||||
const testing = std.testing;
|
||||
|
||||
test "PackedUser internal and external alignment" {
|
||||
try testing.expectEqual(
|
||||
@sizeOf(PackedUser.Inner) * 8,
|
||||
@bitSizeOf(PackedUser.Inner),
|
||||
);
|
||||
}
|
||||
|
||||
fn testShellIndex(allocator: Allocator) StringHashMap(u8) {
|
||||
var result = StringHashMap(u8).init(allocator);
|
||||
result.put("/bin/bash", 0) catch unreachable;
|
||||
result.put("/bin/zsh", 1) catch unreachable;
|
||||
return result;
|
||||
}
|
||||
|
||||
const test_shell_reader = shellImport.ShellReader{
|
||||
.blob = "/bin/bash/bin/zsh",
|
||||
.index = &[_]u16{ 0, 9, 17 },
|
||||
};
|
||||
|
||||
test "construct PackedUser section" {
|
||||
var buf = ArrayList(u8).init(testing.allocator);
|
||||
defer buf.deinit();
|
||||
|
||||
const users = [_]User{ User{
|
||||
.uid = 1000,
|
||||
.gid = 1000,
|
||||
.name = "vidmantas",
|
||||
.gecos = "Vidmantas Kaminskas",
|
||||
.home = "/home/vidmantas",
|
||||
.shell = "/bin/bash",
|
||||
}, User{
|
||||
.uid = 1001,
|
||||
.gid = 1001,
|
||||
.name = "svc-foo",
|
||||
.gecos = "Service Account",
|
||||
.home = "/home/service1",
|
||||
.shell = "/usr/bin/nologin",
|
||||
}, User{
|
||||
.uid = 0,
|
||||
.gid = math.maxInt(u32),
|
||||
.name = "Name" ** 8,
|
||||
.gecos = "Gecos" ** 51,
|
||||
.home = "Home" ** 16,
|
||||
.shell = "She.LllL" ** 32,
|
||||
}, User{
|
||||
.uid = 1002,
|
||||
.gid = 1002,
|
||||
.name = "svc-bar",
|
||||
.gecos = "",
|
||||
.home = "/",
|
||||
.shell = "/bin/zsh",
|
||||
} };
|
||||
var shellIndex = testShellIndex(testing.allocator);
|
||||
const additional_gids = math.maxInt(u64);
|
||||
defer shellIndex.deinit();
|
||||
for (users) |user| {
|
||||
try PackedUser.packTo(&buf, user, additional_gids, shellIndex);
|
||||
try pad.arrayList(&buf, PackedUser.alignment_bits);
|
||||
}
|
||||
|
||||
var i: u29 = 0;
|
||||
var it1 = PackedUser.iterator(buf.items, test_shell_reader);
|
||||
while (try it1.next()) |user| : (i += 1) {
|
||||
try testing.expectEqual(users[i].uid, user.uid());
|
||||
try testing.expectEqual(users[i].gid, user.gid());
|
||||
try testing.expectEqual(user.additionalGidsOffset(), additional_gids);
|
||||
try testing.expectEqualStrings(users[i].name, user.name());
|
||||
try testing.expectEqualStrings(users[i].gecos, user.gecos());
|
||||
try testing.expectEqualStrings(users[i].home, user.home());
|
||||
try testing.expectEqualStrings(users[i].shell, user.shell(test_shell_reader));
|
||||
}
|
||||
try testing.expectEqual(users.len, i);
|
||||
}
|
||||
|
||||
test "User.clone" {
|
||||
var allocator = testing.allocator;
|
||||
const user = User{
|
||||
.uid = 1000,
|
||||
.gid = 1000,
|
||||
.name = "vidmantas",
|
||||
.gecos = "Vidmantas Kaminskas",
|
||||
.home = "/home/vidmantas",
|
||||
.shell = "/bin/bash",
|
||||
};
|
||||
var user2 = try user.clone(allocator);
|
||||
defer user2.deinit(allocator);
|
||||
|
||||
try testing.expectEqualStrings(user.shell, "/bin/bash");
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
const std = @import("std");
|
||||
|
||||
pub const InvalidRecord = error{InvalidRecord};
|
||||
|
||||
pub fn downCast(comptime T: type, n: u64) InvalidRecord!T {
|
||||
return std.math.cast(T, n) catch |err| switch (err) {
|
||||
error.Overflow => {
|
||||
return error.InvalidRecord;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
pub fn utf8(s: []const u8) InvalidRecord!void {
|
||||
if (!std.unicode.utf8ValidateSlice(s)) {
|
||||
return error.InvalidRecord;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user