[thirdparty/systemd.git] / src / test / test-user-util.c

/* SPDX-License-Identifier: LGPL-2.1+ */

#include "alloc-util.h"
#include "format-util.h"
#include "log.h"
#include "macro.h"
#include "path-util.h"
#include "string-util.h"
#include "user-util.h"

static void test_uid_to_name_one(uid_t uid, const char *name) {
        _cleanup_free_ char *t = NULL;

        log_info("/* %s("UID_FMT", \"%s\") */", __func__, uid, name);

        assert_se(t = uid_to_name(uid));
        if (!synthesize_nobody() && streq(name, NOBODY_USER_NAME)) {
                log_info("(skipping detailed tests because nobody is not synthesized)");
                return;
        }
        assert_se(streq_ptr(t, name));
}

static void test_gid_to_name_one(gid_t gid, const char *name) {
        _cleanup_free_ char *t = NULL;

        log_info("/* %s("GID_FMT", \"%s\") */", __func__, gid, name);

        assert_se(t = gid_to_name(gid));
        if (!synthesize_nobody() && streq(name, NOBODY_GROUP_NAME)) {
                log_info("(skipping detailed tests because nobody is not synthesized)");
                return;
        }
        assert_se(streq_ptr(t, name));
}

static void test_parse_uid(void) {
        int r;
        uid_t uid;

        log_info("/* %s */", __func__);

        r = parse_uid("100", &uid);
        assert_se(r == 0);
        assert_se(uid == 100);

        r = parse_uid("65535", &uid);
        assert_se(r == -ENXIO);

        r = parse_uid("asdsdas", &uid);
        assert_se(r == -EINVAL);
}

static void test_uid_ptr(void) {
        log_info("/* %s */", __func__);

        assert_se(UID_TO_PTR(0) != NULL);
        assert_se(UID_TO_PTR(1000) != NULL);

        assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
        assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
}

static void test_valid_user_group_name_compat(void) {
        log_info("/* %s */", __func__);

        assert_se(!valid_user_group_name_compat(NULL));
        assert_se(!valid_user_group_name_compat(""));
        assert_se(!valid_user_group_name_compat("1"));
        assert_se(!valid_user_group_name_compat("65535"));
        assert_se(!valid_user_group_name_compat("-1"));
        assert_se(!valid_user_group_name_compat("-kkk"));
        assert_se(!valid_user_group_name_compat("rööt"));
        assert_se(!valid_user_group_name_compat("."));
        assert_se(!valid_user_group_name_compat(".eff"));
        assert_se(!valid_user_group_name_compat("foo\nbar"));
        assert_se(!valid_user_group_name_compat("0123456789012345678901234567890123456789"));
        assert_se(!valid_user_group_name_or_id_compat("aaa:bbb"));
        assert_se(!valid_user_group_name_compat("."));
        assert_se(!valid_user_group_name_compat(".1"));
        assert_se(!valid_user_group_name_compat(".65535"));
        assert_se(!valid_user_group_name_compat(".-1"));
        assert_se(!valid_user_group_name_compat(".-kkk"));
        assert_se(!valid_user_group_name_compat(".rööt"));
        assert_se(!valid_user_group_name_or_id_compat(".aaa:bbb"));

        assert_se(valid_user_group_name_compat("root"));
        assert_se(valid_user_group_name_compat("lennart"));
        assert_se(valid_user_group_name_compat("LENNART"));
        assert_se(valid_user_group_name_compat("_kkk"));
        assert_se(valid_user_group_name_compat("kkk-"));
        assert_se(valid_user_group_name_compat("kk-k"));
        assert_se(valid_user_group_name_compat("eff.eff"));
        assert_se(valid_user_group_name_compat("eff."));

        assert_se(valid_user_group_name_compat("some5"));
        assert_se(!valid_user_group_name_compat("5some"));
        assert_se(valid_user_group_name_compat("INNER5NUMBER"));
}

static void test_valid_user_group_name(void) {
        log_info("/* %s */", __func__);

        assert_se(!valid_user_group_name(NULL));
        assert_se(!valid_user_group_name(""));
        assert_se(!valid_user_group_name("1"));
        assert_se(!valid_user_group_name("65535"));
        assert_se(!valid_user_group_name("-1"));
        assert_se(!valid_user_group_name("-kkk"));
        assert_se(!valid_user_group_name("rööt"));
        assert_se(!valid_user_group_name("."));
        assert_se(!valid_user_group_name(".eff"));
        assert_se(!valid_user_group_name("foo\nbar"));
        assert_se(!valid_user_group_name("0123456789012345678901234567890123456789"));
        assert_se(!valid_user_group_name_or_id("aaa:bbb"));
        assert_se(!valid_user_group_name("."));
        assert_se(!valid_user_group_name(".1"));
        assert_se(!valid_user_group_name(".65535"));
        assert_se(!valid_user_group_name(".-1"));
        assert_se(!valid_user_group_name(".-kkk"));
        assert_se(!valid_user_group_name(".rööt"));
        assert_se(!valid_user_group_name_or_id(".aaa:bbb"));

        assert_se(valid_user_group_name("root"));
        assert_se(valid_user_group_name("lennart"));
        assert_se(valid_user_group_name("LENNART"));
        assert_se(valid_user_group_name("_kkk"));
        assert_se(valid_user_group_name("kkk-"));
        assert_se(valid_user_group_name("kk-k"));
        assert_se(!valid_user_group_name("eff.eff"));
        assert_se(!valid_user_group_name("eff."));

        assert_se(valid_user_group_name("some5"));
        assert_se(!valid_user_group_name("5some"));
        assert_se(valid_user_group_name("INNER5NUMBER"));
}

static void test_valid_user_group_name_or_id_compat(void) {
        log_info("/* %s */", __func__);

        assert_se(!valid_user_group_name_or_id_compat(NULL));
        assert_se(!valid_user_group_name_or_id_compat(""));
        assert_se(valid_user_group_name_or_id_compat("0"));
        assert_se(valid_user_group_name_or_id_compat("1"));
        assert_se(valid_user_group_name_or_id_compat("65534"));
        assert_se(!valid_user_group_name_or_id_compat("65535"));
        assert_se(valid_user_group_name_or_id_compat("65536"));
        assert_se(!valid_user_group_name_or_id_compat("-1"));
        assert_se(!valid_user_group_name_or_id_compat("-kkk"));
        assert_se(!valid_user_group_name_or_id_compat("rööt"));
        assert_se(!valid_user_group_name_or_id_compat("."));
        assert_se(!valid_user_group_name_or_id_compat(".eff"));
        assert_se(valid_user_group_name_or_id_compat("eff.eff"));
        assert_se(valid_user_group_name_or_id_compat("eff."));
        assert_se(!valid_user_group_name_or_id_compat("foo\nbar"));
        assert_se(!valid_user_group_name_or_id_compat("0123456789012345678901234567890123456789"));
        assert_se(!valid_user_group_name_or_id_compat("aaa:bbb"));

        assert_se(valid_user_group_name_or_id_compat("root"));
        assert_se(valid_user_group_name_or_id_compat("lennart"));
        assert_se(valid_user_group_name_or_id_compat("LENNART"));
        assert_se(valid_user_group_name_or_id_compat("_kkk"));
        assert_se(valid_user_group_name_or_id_compat("kkk-"));
        assert_se(valid_user_group_name_or_id_compat("kk-k"));

        assert_se(valid_user_group_name_or_id_compat("some5"));
        assert_se(!valid_user_group_name_or_id_compat("5some"));
        assert_se(valid_user_group_name_or_id_compat("INNER5NUMBER"));
}

static void test_valid_user_group_name_or_id(void) {
        log_info("/* %s */", __func__);

        assert_se(!valid_user_group_name_or_id(NULL));
        assert_se(!valid_user_group_name_or_id(""));
        assert_se(valid_user_group_name_or_id("0"));
        assert_se(valid_user_group_name_or_id("1"));
        assert_se(valid_user_group_name_or_id("65534"));
        assert_se(!valid_user_group_name_or_id("65535"));
        assert_se(valid_user_group_name_or_id("65536"));
        assert_se(!valid_user_group_name_or_id("-1"));
        assert_se(!valid_user_group_name_or_id("-kkk"));
        assert_se(!valid_user_group_name_or_id("rööt"));
        assert_se(!valid_user_group_name_or_id("."));
        assert_se(!valid_user_group_name_or_id(".eff"));
        assert_se(!valid_user_group_name_or_id("eff.eff"));
        assert_se(!valid_user_group_name_or_id("eff."));
        assert_se(!valid_user_group_name_or_id("foo\nbar"));
        assert_se(!valid_user_group_name_or_id("0123456789012345678901234567890123456789"));
        assert_se(!valid_user_group_name_or_id("aaa:bbb"));

        assert_se(valid_user_group_name_or_id("root"));
        assert_se(valid_user_group_name_or_id("lennart"));
        assert_se(valid_user_group_name_or_id("LENNART"));
        assert_se(valid_user_group_name_or_id("_kkk"));
        assert_se(valid_user_group_name_or_id("kkk-"));
        assert_se(valid_user_group_name_or_id("kk-k"));

        assert_se(valid_user_group_name_or_id("some5"));
        assert_se(!valid_user_group_name_or_id("5some"));
        assert_se(valid_user_group_name_or_id("INNER5NUMBER"));
}

static void test_valid_gecos(void) {
        log_info("/* %s */", __func__);

        assert_se(!valid_gecos(NULL));
        assert_se(valid_gecos(""));
        assert_se(valid_gecos("test"));
        assert_se(valid_gecos("Ümläüt"));
        assert_se(!valid_gecos("In\nvalid"));
        assert_se(!valid_gecos("In:valid"));
}

static void test_valid_home(void) {
        log_info("/* %s */", __func__);

        assert_se(!valid_home(NULL));
        assert_se(!valid_home(""));
        assert_se(!valid_home("."));
        assert_se(!valid_home("/home/.."));
        assert_se(!valid_home("/home/../"));
        assert_se(!valid_home("/home\n/foo"));
        assert_se(!valid_home("./piep"));
        assert_se(!valid_home("piep"));
        assert_se(!valid_home("/home/user:lennart"));

        assert_se(valid_home("/"));
        assert_se(valid_home("/home"));
        assert_se(valid_home("/home/foo"));
}

static void test_get_user_creds_one(const char *id, const char *name, uid_t uid, gid_t gid, const char *home, const char *shell) {
        const char *rhome = NULL;
        const char *rshell = NULL;
        uid_t ruid = UID_INVALID;
        gid_t rgid = GID_INVALID;
        int r;

        log_info("/* %s(\"%s\", \"%s\", "UID_FMT", "GID_FMT", \"%s\", \"%s\") */",
                 __func__, id, name, uid, gid, home, shell);

        r = get_user_creds(&id, &ruid, &rgid, &rhome, &rshell, 0);
        log_info_errno(r, "got \"%s\", "UID_FMT", "GID_FMT", \"%s\", \"%s\": %m",
                       id, ruid, rgid, strnull(rhome), strnull(rshell));
        if (!synthesize_nobody() && streq(name, NOBODY_USER_NAME)) {
                log_info("(skipping detailed tests because nobody is not synthesized)");
                return;
        }
        assert_se(r == 0);
        assert_se(streq_ptr(id, name));
        assert_se(ruid == uid);
        assert_se(rgid == gid);
        assert_se(path_equal(rhome, home));
        assert_se(path_equal(rshell, shell));
}

static void test_get_group_creds_one(const char *id, const char *name, gid_t gid) {
        gid_t rgid = GID_INVALID;
        int r;

        log_info("/* %s(\"%s\", \"%s\", "GID_FMT") */", __func__, id, name, gid);

        r = get_group_creds(&id, &rgid, 0);
        log_info_errno(r, "got \"%s\", "GID_FMT": %m", id, rgid);
        if (!synthesize_nobody() && streq(name, NOBODY_GROUP_NAME)) {
                log_info("(skipping detailed tests because nobody is not synthesized)");
                return;
        }
        assert_se(r == 0);
        assert_se(streq_ptr(id, name));
        assert_se(rgid == gid);
}

static void test_make_salt(void) {
        log_info("/* %s */", __func__);

        _cleanup_free_ char *s, *t;

        assert_se(make_salt(&s) == 0);
        log_info("got %s", s);

        assert_se(make_salt(&t) == 0);
        log_info("got %s", t);

        assert(!streq(s, t));
}

static void test_in_gid(void) {

        assert(in_gid(getgid()) >= 0);
        assert(in_gid(getegid()) >= 0);

        assert(in_gid(GID_INVALID) < 0);
        assert(in_gid(TTY_GID) == 0); /* The TTY gid is for owning ttys, it would be really really weird if we were in it. */
}

int main(int argc, char *argv[]) {
        test_uid_to_name_one(0, "root");
        test_uid_to_name_one(UID_NOBODY, NOBODY_USER_NAME);
        test_uid_to_name_one(0xFFFF, "65535");
        test_uid_to_name_one(0xFFFFFFFF, "4294967295");

        test_gid_to_name_one(0, "root");
        test_gid_to_name_one(GID_NOBODY, NOBODY_GROUP_NAME);
        test_gid_to_name_one(TTY_GID, "tty");
        test_gid_to_name_one(0xFFFF, "65535");
        test_gid_to_name_one(0xFFFFFFFF, "4294967295");

        test_get_user_creds_one("root", "root", 0, 0, "/root", "/bin/sh");
        test_get_user_creds_one("0", "root", 0, 0, "/root", "/bin/sh");
        test_get_user_creds_one(NOBODY_USER_NAME, NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
        test_get_user_creds_one("65534", NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);

        test_get_group_creds_one("root", "root", 0);
        test_get_group_creds_one("0", "root", 0);
        test_get_group_creds_one(NOBODY_GROUP_NAME, NOBODY_GROUP_NAME, GID_NOBODY);
        test_get_group_creds_one("65534", NOBODY_GROUP_NAME, GID_NOBODY);

        test_parse_uid();
        test_uid_ptr();

        test_valid_user_group_name_compat();
        test_valid_user_group_name();
        test_valid_user_group_name_or_id_compat();
        test_valid_user_group_name_or_id();
        test_valid_gecos();
        test_valid_home();

        test_make_salt();

        test_in_gid();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
d0260817	2
b5efdb8a	3	#include "alloc-util.h"
ca78ad1d	4	#include "format-util.h"
52c6e6a8	5	#include "log.h"
d0260817	6	#include "macro.h"
ca78ad1d	7	#include "path-util.h"
d0260817 LP	8	#include "string-util.h"
d0260817 LP	9	#include "user-util.h"
d0260817 LP	10
	11	static void test_uid_to_name_one(uid_t uid, const char *name) {
	12	_cleanup_free_ char *t = NULL;
	13
52c6e6a8 ZJS	14	log_info("/* %s("UID_FMT", \"%s\") */", __func__, uid, name);
52c6e6a8 ZJS	15
d0260817	16	assert_se(t = uid_to_name(uid));
7559b2da ZJS	17	if (!synthesize_nobody() && streq(name, NOBODY_USER_NAME)) {
	18	log_info("(skipping detailed tests because nobody is not synthesized)");
	19	return;
	20	}
d0260817 LP	21	assert_se(streq_ptr(t, name));
	22	}
	23
	24	static void test_gid_to_name_one(gid_t gid, const char *name) {
	25	_cleanup_free_ char *t = NULL;
	26
52c6e6a8 ZJS	27	log_info("/* %s("GID_FMT", \"%s\") */", __func__, gid, name);
52c6e6a8 ZJS	28
d0260817	29	assert_se(t = gid_to_name(gid));
7559b2da ZJS	30	if (!synthesize_nobody() && streq(name, NOBODY_GROUP_NAME)) {
	31	log_info("(skipping detailed tests because nobody is not synthesized)");
	32	return;
	33	}
d0260817 LP	34	assert_se(streq_ptr(t, name));
	35	}
	36
d5b29bb5 RC	37	static void test_parse_uid(void) {
	38	int r;
	39	uid_t uid;
	40
52c6e6a8 ZJS	41	log_info("/* %s */", __func__);
52c6e6a8 ZJS	42
d5b29bb5 RC	43	r = parse_uid("100", &uid);
	44	assert_se(r == 0);
	45	assert_se(uid == 100);
	46
	47	r = parse_uid("65535", &uid);
	48	assert_se(r == -ENXIO);
	49
	50	r = parse_uid("asdsdas", &uid);
	51	assert_se(r == -EINVAL);
	52	}
	53
	54	static void test_uid_ptr(void) {
52c6e6a8	55	log_info("/* %s */", __func__);
d5b29bb5 RC	56
	57	assert_se(UID_TO_PTR(0) != NULL);
	58	assert_se(UID_TO_PTR(1000) != NULL);
	59
	60	assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
	61	assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
	62	}
	63
1a29610f ZJS	64	static void test_valid_user_group_name_compat(void) {
	65	log_info("/* %s */", __func__);
	66
	67	assert_se(!valid_user_group_name_compat(NULL));
	68	assert_se(!valid_user_group_name_compat(""));
	69	assert_se(!valid_user_group_name_compat("1"));
	70	assert_se(!valid_user_group_name_compat("65535"));
	71	assert_se(!valid_user_group_name_compat("-1"));
	72	assert_se(!valid_user_group_name_compat("-kkk"));
	73	assert_se(!valid_user_group_name_compat("rööt"));
	74	assert_se(!valid_user_group_name_compat("."));
	75	assert_se(!valid_user_group_name_compat(".eff"));
	76	assert_se(!valid_user_group_name_compat("foo\nbar"));
	77	assert_se(!valid_user_group_name_compat("0123456789012345678901234567890123456789"));
	78	assert_se(!valid_user_group_name_or_id_compat("aaa:bbb"));
	79	assert_se(!valid_user_group_name_compat("."));
	80	assert_se(!valid_user_group_name_compat(".1"));
	81	assert_se(!valid_user_group_name_compat(".65535"));
	82	assert_se(!valid_user_group_name_compat(".-1"));
	83	assert_se(!valid_user_group_name_compat(".-kkk"));
	84	assert_se(!valid_user_group_name_compat(".rööt"));
	85	assert_se(!valid_user_group_name_or_id_compat(".aaa:bbb"));
	86
	87	assert_se(valid_user_group_name_compat("root"));
	88	assert_se(valid_user_group_name_compat("lennart"));
	89	assert_se(valid_user_group_name_compat("LENNART"));
	90	assert_se(valid_user_group_name_compat("_kkk"));
	91	assert_se(valid_user_group_name_compat("kkk-"));
	92	assert_se(valid_user_group_name_compat("kk-k"));
	93	assert_se(valid_user_group_name_compat("eff.eff"));
	94	assert_se(valid_user_group_name_compat("eff."));
	95
	96	assert_se(valid_user_group_name_compat("some5"));
	97	assert_se(!valid_user_group_name_compat("5some"));
	98	assert_se(valid_user_group_name_compat("INNER5NUMBER"));
	99	}
	100
e4631b48	101	static void test_valid_user_group_name(void) {
52c6e6a8 ZJS	102	log_info("/* %s */", __func__);
52c6e6a8 ZJS	103
e4631b48 LP	104	assert_se(!valid_user_group_name(NULL));
	105	assert_se(!valid_user_group_name(""));
	106	assert_se(!valid_user_group_name("1"));
	107	assert_se(!valid_user_group_name("65535"));
	108	assert_se(!valid_user_group_name("-1"));
	109	assert_se(!valid_user_group_name("-kkk"));
	110	assert_se(!valid_user_group_name("rööt"));
	111	assert_se(!valid_user_group_name("."));
1a29610f	112	assert_se(!valid_user_group_name(".eff"));
e4631b48 LP	113	assert_se(!valid_user_group_name("foo\nbar"));
	114	assert_se(!valid_user_group_name("0123456789012345678901234567890123456789"));
	115	assert_se(!valid_user_group_name_or_id("aaa:bbb"));
1a29610f ZJS	116	assert_se(!valid_user_group_name("."));
	117	assert_se(!valid_user_group_name(".1"));
	118	assert_se(!valid_user_group_name(".65535"));
	119	assert_se(!valid_user_group_name(".-1"));
	120	assert_se(!valid_user_group_name(".-kkk"));
	121	assert_se(!valid_user_group_name(".rööt"));
	122	assert_se(!valid_user_group_name_or_id(".aaa:bbb"));
e4631b48 LP	123
	124	assert_se(valid_user_group_name("root"));
	125	assert_se(valid_user_group_name("lennart"));
	126	assert_se(valid_user_group_name("LENNART"));
	127	assert_se(valid_user_group_name("_kkk"));
	128	assert_se(valid_user_group_name("kkk-"));
	129	assert_se(valid_user_group_name("kk-k"));
1a29610f ZJS	130	assert_se(!valid_user_group_name("eff.eff"));
1a29610f ZJS	131	assert_se(!valid_user_group_name("eff."));
e4631b48 LP	132
	133	assert_se(valid_user_group_name("some5"));
	134	assert_se(!valid_user_group_name("5some"));
	135	assert_se(valid_user_group_name("INNER5NUMBER"));
	136	}
	137
1a29610f ZJS	138	static void test_valid_user_group_name_or_id_compat(void) {
	139	log_info("/* %s */", __func__);
	140
	141	assert_se(!valid_user_group_name_or_id_compat(NULL));
	142	assert_se(!valid_user_group_name_or_id_compat(""));
	143	assert_se(valid_user_group_name_or_id_compat("0"));
	144	assert_se(valid_user_group_name_or_id_compat("1"));
	145	assert_se(valid_user_group_name_or_id_compat("65534"));
	146	assert_se(!valid_user_group_name_or_id_compat("65535"));
	147	assert_se(valid_user_group_name_or_id_compat("65536"));
	148	assert_se(!valid_user_group_name_or_id_compat("-1"));
	149	assert_se(!valid_user_group_name_or_id_compat("-kkk"));
	150	assert_se(!valid_user_group_name_or_id_compat("rööt"));
	151	assert_se(!valid_user_group_name_or_id_compat("."));
	152	assert_se(!valid_user_group_name_or_id_compat(".eff"));
	153	assert_se(valid_user_group_name_or_id_compat("eff.eff"));
	154	assert_se(valid_user_group_name_or_id_compat("eff."));
	155	assert_se(!valid_user_group_name_or_id_compat("foo\nbar"));
	156	assert_se(!valid_user_group_name_or_id_compat("0123456789012345678901234567890123456789"));
	157	assert_se(!valid_user_group_name_or_id_compat("aaa:bbb"));
	158
	159	assert_se(valid_user_group_name_or_id_compat("root"));
	160	assert_se(valid_user_group_name_or_id_compat("lennart"));
	161	assert_se(valid_user_group_name_or_id_compat("LENNART"));
	162	assert_se(valid_user_group_name_or_id_compat("_kkk"));
	163	assert_se(valid_user_group_name_or_id_compat("kkk-"));
	164	assert_se(valid_user_group_name_or_id_compat("kk-k"));
	165
	166	assert_se(valid_user_group_name_or_id_compat("some5"));
	167	assert_se(!valid_user_group_name_or_id_compat("5some"));
	168	assert_se(valid_user_group_name_or_id_compat("INNER5NUMBER"));
	169	}
	170
e4631b48	171	static void test_valid_user_group_name_or_id(void) {
52c6e6a8 ZJS	172	log_info("/* %s */", __func__);
52c6e6a8 ZJS	173
e4631b48 LP	174	assert_se(!valid_user_group_name_or_id(NULL));
	175	assert_se(!valid_user_group_name_or_id(""));
	176	assert_se(valid_user_group_name_or_id("0"));
	177	assert_se(valid_user_group_name_or_id("1"));
	178	assert_se(valid_user_group_name_or_id("65534"));
	179	assert_se(!valid_user_group_name_or_id("65535"));
	180	assert_se(valid_user_group_name_or_id("65536"));
	181	assert_se(!valid_user_group_name_or_id("-1"));
	182	assert_se(!valid_user_group_name_or_id("-kkk"));
	183	assert_se(!valid_user_group_name_or_id("rööt"));
	184	assert_se(!valid_user_group_name_or_id("."));
1a29610f	185	assert_se(!valid_user_group_name_or_id(".eff"));
e4631b48	186	assert_se(!valid_user_group_name_or_id("eff.eff"));
1a29610f	187	assert_se(!valid_user_group_name_or_id("eff."));
e4631b48 LP	188	assert_se(!valid_user_group_name_or_id("foo\nbar"));
	189	assert_se(!valid_user_group_name_or_id("0123456789012345678901234567890123456789"));
	190	assert_se(!valid_user_group_name_or_id("aaa:bbb"));
	191
	192	assert_se(valid_user_group_name_or_id("root"));
	193	assert_se(valid_user_group_name_or_id("lennart"));
	194	assert_se(valid_user_group_name_or_id("LENNART"));
	195	assert_se(valid_user_group_name_or_id("_kkk"));
	196	assert_se(valid_user_group_name_or_id("kkk-"));
	197	assert_se(valid_user_group_name_or_id("kk-k"));
	198
	199	assert_se(valid_user_group_name_or_id("some5"));
	200	assert_se(!valid_user_group_name_or_id("5some"));
	201	assert_se(valid_user_group_name_or_id("INNER5NUMBER"));
	202	}
	203
	204	static void test_valid_gecos(void) {
52c6e6a8	205	log_info("/* %s */", __func__);
e4631b48 LP	206
	207	assert_se(!valid_gecos(NULL));
	208	assert_se(valid_gecos(""));
	209	assert_se(valid_gecos("test"));
	210	assert_se(valid_gecos("Ümläüt"));
	211	assert_se(!valid_gecos("In\nvalid"));
	212	assert_se(!valid_gecos("In:valid"));
	213	}
	214
	215	static void test_valid_home(void) {
52c6e6a8	216	log_info("/* %s */", __func__);
e4631b48 LP	217
	218	assert_se(!valid_home(NULL));
	219	assert_se(!valid_home(""));
	220	assert_se(!valid_home("."));
	221	assert_se(!valid_home("/home/.."));
	222	assert_se(!valid_home("/home/../"));
	223	assert_se(!valid_home("/home\n/foo"));
	224	assert_se(!valid_home("./piep"));
	225	assert_se(!valid_home("piep"));
	226	assert_se(!valid_home("/home/user:lennart"));
	227
	228	assert_se(valid_home("/"));
	229	assert_se(valid_home("/home"));
	230	assert_se(valid_home("/home/foo"));
	231	}
	232
7e61fd02	233	static void test_get_user_creds_one(const char id, const char name, uid_t uid, gid_t gid, const char home, const char shell) {
7559b2da ZJS	234	const char *rhome = NULL;
	235	const char *rshell = NULL;
	236	uid_t ruid = UID_INVALID;
	237	gid_t rgid = GID_INVALID;
	238	int r;
7e61fd02	239
52c6e6a8 ZJS	240	log_info("/* %s(\"%s\", \"%s\", "UID_FMT", "GID_FMT", \"%s\", \"%s\") */",
	241	__func__, id, name, uid, gid, home, shell);
	242
fafff8f1	243	r = get_user_creds(&id, &ruid, &rgid, &rhome, &rshell, 0);
7559b2da ZJS	244	log_info_errno(r, "got \"%s\", "UID_FMT", "GID_FMT", \"%s\", \"%s\": %m",
	245	id, ruid, rgid, strnull(rhome), strnull(rshell));
	246	if (!synthesize_nobody() && streq(name, NOBODY_USER_NAME)) {
	247	log_info("(skipping detailed tests because nobody is not synthesized)");
	248	return;
	249	}
	250	assert_se(r == 0);
7e61fd02 LP	251	assert_se(streq_ptr(id, name));
	252	assert_se(ruid == uid);
	253	assert_se(rgid == gid);
	254	assert_se(path_equal(rhome, home));
	255	assert_se(path_equal(rshell, shell));
	256	}
	257
	258	static void test_get_group_creds_one(const char id, const char name, gid_t gid) {
7559b2da ZJS	259	gid_t rgid = GID_INVALID;
7559b2da ZJS	260	int r;
7e61fd02	261
52c6e6a8 ZJS	262	log_info("/* %s(\"%s\", \"%s\", "GID_FMT") */", __func__, id, name, gid);
52c6e6a8 ZJS	263
fafff8f1	264	r = get_group_creds(&id, &rgid, 0);
7559b2da ZJS	265	log_info_errno(r, "got \"%s\", "GID_FMT": %m", id, rgid);
	266	if (!synthesize_nobody() && streq(name, NOBODY_GROUP_NAME)) {
	267	log_info("(skipping detailed tests because nobody is not synthesized)");
	268	return;
	269	}
	270	assert_se(r == 0);
7e61fd02 LP	271	assert_se(streq_ptr(id, name));
	272	assert_se(rgid == gid);
	273	}
	274
521ff2fc ZJS	275	static void test_make_salt(void) {
	276	log_info("/* %s */", __func__);
	277
	278	_cleanup_free_ char s, t;
	279
	280	assert_se(make_salt(&s) == 0);
	281	log_info("got %s", s);
	282
	283	assert_se(make_salt(&t) == 0);
	284	log_info("got %s", t);
	285
	286	assert(!streq(s, t));
	287	}
	288
eb2cfa81 LP	289	static void test_in_gid(void) {
	290
	291	assert(in_gid(getgid()) >= 0);
	292	assert(in_gid(getegid()) >= 0);
	293
	294	assert(in_gid(GID_INVALID) < 0);
	295	assert(in_gid(TTY_GID) == 0); /* The TTY gid is for owning ttys, it would be really really weird if we were in it. */
	296	}
	297
f2a3de01	298	int main(int argc, char *argv[]) {
d0260817	299	test_uid_to_name_one(0, "root");
7e61fd02	300	test_uid_to_name_one(UID_NOBODY, NOBODY_USER_NAME);
d0260817 LP	301	test_uid_to_name_one(0xFFFF, "65535");
	302	test_uid_to_name_one(0xFFFFFFFF, "4294967295");
	303
	304	test_gid_to_name_one(0, "root");
7e61fd02	305	test_gid_to_name_one(GID_NOBODY, NOBODY_GROUP_NAME);
d0260817 LP	306	test_gid_to_name_one(TTY_GID, "tty");
	307	test_gid_to_name_one(0xFFFF, "65535");
	308	test_gid_to_name_one(0xFFFFFFFF, "4294967295");
	309
7e61fd02 LP	310	test_get_user_creds_one("root", "root", 0, 0, "/root", "/bin/sh");
7e61fd02 LP	311	test_get_user_creds_one("0", "root", 0, 0, "/root", "/bin/sh");
6db90462 MB	312	test_get_user_creds_one(NOBODY_USER_NAME, NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
6db90462 MB	313	test_get_user_creds_one("65534", NOBODY_USER_NAME, UID_NOBODY, GID_NOBODY, "/", NOLOGIN);
7e61fd02 LP	314
	315	test_get_group_creds_one("root", "root", 0);
	316	test_get_group_creds_one("0", "root", 0);
	317	test_get_group_creds_one(NOBODY_GROUP_NAME, NOBODY_GROUP_NAME, GID_NOBODY);
	318	test_get_group_creds_one("65534", NOBODY_GROUP_NAME, GID_NOBODY);
	319
d5b29bb5 RC	320	test_parse_uid();
	321	test_uid_ptr();
	322
1a29610f	323	test_valid_user_group_name_compat();
e4631b48	324	test_valid_user_group_name();
1a29610f	325	test_valid_user_group_name_or_id_compat();
e4631b48 LP	326	test_valid_user_group_name_or_id();
	327	test_valid_gecos();
	328	test_valid_home();
	329
521ff2fc ZJS	330	test_make_salt();
521ff2fc ZJS	331
eb2cfa81 LP	332	test_in_gid();
eb2cfa81 LP	333
d0260817 LP	334	return 0;
d0260817 LP	335	}