turbonss/src/libnss.zig

const std = @import("std");
const os = std.os;
const fmt = std.fmt;
const log = std.log;
const mem = std.mem;
const process = std.process;
const once = std.once;

const DB = @import("DB.zig");
const File = @import("File.zig");
const ErrCtx = @import("ErrCtx.zig");
const CGroup = @import("Group.zig").CGroup;
const PackedGroup = @import("PackedGroup.zig");
const CUser = @import("User.zig").CUser;
const PackedUser = @import("PackedUser.zig");

const c = @cImport({
    @cInclude("nss.h");
});

const ENV_DB = "TURBONSS_DB";
const ENV_LOGLEVEL = "TURBONSS_LOGLEVEL";
const ENV_OMIT_MEMBERS = "TURBONSS_OMIT_MEMBERS";

var turbonss_db_path: [:0]const u8 = "/etc/turbonss/db.turbo";

pub var log_level: std.log.Level = .err;

// State is a type of the global variable holding the process state:
// the DB handle and all the iterators.
const State = struct {
    file: ?File,
    getpwent_iterator: ?PackedUser.Iterator = null,
    getgrent_iterator: ?PackedGroup.Iterator = null,
    omit_members: bool,
};

// global_state is initialized on first call to an nss function
var global_state: State = undefined;
var global_init = once(init);

// assigns State from environment variables et al
fn init() void {
    if (os.getenvZ(ENV_LOGLEVEL)) |env| {
        const got = mem.sliceTo(env, 0);
        if (mem.eql(u8, got, "0")) {
            log_level = .err;
        } else if (mem.eql(u8, got, "1")) {
            log_level = .warn;
        } else if (mem.eql(u8, got, "2")) {
            log_level = .info;
        } else if (mem.eql(u8, got, "3")) {
            log_level = .debug;
        } else {
            std.debug.print(
                "warning: unrecognized {s}={s}. Expected between 0 and 3\n",
                .{ ENV_LOGLEVEL, got },
            );
        }
    }

    const omit_members = blk: {
        if (os.getenvZ(ENV_OMIT_MEMBERS)) |env| {
            const got = mem.sliceTo(env, 0);
            if (mem.eql(u8, got, "1")) {
                break :blk true;
            } else if (mem.eql(u8, got, "0")) {
                break :blk false;
            } else if (mem.eql(u8, got, "auto")) {
                // not set, do autodiscover
            } else {
                std.debug.print(
                    "warning: unrecognized {s}={s}. Expected 0, 1 or auto\n",
                    .{ ENV_OMIT_MEMBERS, got },
                );
            }
        }
        if (os.argv.len == 0) break :blk false;
        break :blk mem.eql(u8, mem.sliceTo(os.argv[0], 0), "id");
    };
    log.debug("omitting members from getgr* calls: {any}\n", .{omit_members});

    const fname = os.getenvZ(ENV_DB) orelse turbonss_db_path[0..];
    log.debug("opening '{s}'", .{fname});

    const file = File.open(fname) catch |err| {
        log.warn("open '{s}': {s}", .{ fname, @errorName(err) });
        return;
    };
    log.debug("turbonss database opened", .{});

    global_state = State{
        .file = file,
        .omit_members = omit_members,
    };
}

fn shouldOmitMembers(envvar: []const u8, argv: [][*:0]u8) bool {
    if (mem.eql(u8, envvar, "1")) return true;
    if (mem.eql(u8, envvar, "0")) return false;
    if (argv.len == 0) return false;
    return mem.eql(u8, mem.sliceTo(argv[0], 0), "id");
}

export fn _nss_turbo_getpwuid_r(
    uid: c_uint,
    passwd: *CUser,
    buffer: [*]u8,
    buflen: usize,
    errnop: *c_int,
) c.enum_nss_status {
    const db = get_db(errnop) orelse return c.NSS_STATUS_UNAVAIL;
    if (db.getpwuid(uid, buffer[0..buflen])) |maybe_cuser| {
        if (maybe_cuser) |cuser| {
            passwd.* = cuser;
            return c.NSS_STATUS_SUCCESS;
        } else {
            errnop.* = @enumToInt(os.E.NOENT);
            return c.NSS_STATUS_NOTFOUND;
        }
    } else |err| switch (err) {
        error.BufferTooSmall => {
            errnop.* = @enumToInt(os.E.RANGE);
            return c.NSS_STATUS_TRYAGAIN;
        },
    }
}

export fn _nss_turbo_getpwnam_r(
    name: [*:0]u8,
    passwd: *CUser,
    buffer: [*]u8,
    buflen: usize,
    errnop: *c_int,
) c.enum_nss_status {
    const db = get_db(errnop) orelse return c.NSS_STATUS_UNAVAIL;
    const nameSlice = mem.sliceTo(name, 0);
    if (db.getpwnam(nameSlice, buffer[0..buflen])) |maybe_cuser| {
        if (maybe_cuser) |cuser| {
            passwd.* = cuser;
            return c.NSS_STATUS_SUCCESS;
        } else {
            errnop.* = @enumToInt(os.E.NOENT);
            return c.NSS_STATUS_NOTFOUND;
        }
    } else |err| switch (err) {
        error.BufferTooSmall => {
            errnop.* = @enumToInt(os.E.RANGE);
            return c.NSS_STATUS_TRYAGAIN;
        },
    }
}

fn get_db(errnop: *c_int) ?DB {
    global_init.call();

    if (global_state.file) |file| {
        return file.db;
    } else {
        errnop.* = @enumToInt(os.E.AGAIN);
        return null;
    }
}

const testing = std.testing;

test "nss_turbo_getpwuid_r" {
    const allocator = testing.allocator;

    var errc = ErrCtx{};
    var tf = try File.TestDB.init(allocator, &errc);
    defer tf.deinit();
    std.debug.print("tf.path: {s}\n", .{tf.path});
    turbonss_db_path = tf.path;

    var passwd: CUser = undefined;
    var buffer: [1024]u8 = undefined;
    var errno: c_int = 0;

    const status = _nss_turbo_getpwuid_r(0, &passwd, &buffer, buffer.len, &errno);
    if (true) return error.SkipZigTest;
    try testing.expectEqual(@as(c_int, 0), errno);
    try testing.expectEqual(c.NSS_STATUS_SUCCESS, status);
}