[thirdparty/systemd.git] / src / test / test-unit-file.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2012 Lennart Poettering
  Copyright 2013 Zbigniew Jędrzejewski-Szmek

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <assert.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include <unistd.h>

#include "install.h"
#include "install-printf.h"
#include "specifier.h"
#include "util.h"
#include "macro.h"
#include "hashmap.h"
#include "load-fragment.h"
#include "strv.h"
#include "fileio.h"

static void test_unit_file_get_set(void) {
        int r;
        Hashmap *h;
        Iterator i;
        UnitFileList *p;

        h = hashmap_new(string_hash_func, string_compare_func);
        assert(h);

        r = unit_file_get_list(UNIT_FILE_SYSTEM, NULL, h);
        log_info("unit_file_get_list: %s", strerror(-r));
        assert(r >= 0);

        HASHMAP_FOREACH(p, h, i)
                printf("%s = %s\n", p->path, unit_file_state_to_string(p->state));

        unit_file_list_free(h);
}

static void check_execcommand(ExecCommand *c,
                              const char* path,
                              const char* argv0,
                              const char* argv1,
                              bool ignore) {
        assert_se(c);
        log_info("%s %s %s %s",
                 c->path, c->argv[0], c->argv[1], c->argv[2]);
        assert_se(streq(c->path, path));
        assert_se(streq(c->argv[0], argv0));
        assert_se(streq(c->argv[1], argv1));
        assert_se(c->argv[2] == NULL);
        assert_se(c->ignore == ignore);
}

static void test_config_parse_exec(void) {
        /* int config_parse_exec( */
        /*         const char *filename, */
        /*         unsigned line, */
        /*         const char *section, */
        /*         const char *lvalue, */
        /*         int ltype, */
        /*         const char *rvalue, */
        /*         void *data, */
        /*         void *userdata) */
        int r;

        ExecCommand *c = NULL, *c1;

        /* basic test */
        r = config_parse_exec("fake", 1, "section",
                              "LValue", 0, "/RValue r1",
                              &c, NULL);
        assert_se(r >= 0);
        check_execcommand(c, "/RValue", "/RValue", "r1", false);

        r = config_parse_exec("fake", 2, "section",
                              "LValue", 0, "/RValue///slashes/// r1",
                              &c, NULL);
       /* test slashes */
        assert_se(r >= 0);
        c1 = c->command_next;
        check_execcommand(c1, "/RValue/slashes", "/RValue///slashes///",
                          "r1", false);

        /* honour_argv0 */
        r = config_parse_exec("fake", 3, "section",
                              "LValue", 0, "@/RValue///slashes2/// argv0 r1",
                              &c, NULL);
        assert_se(r >= 0);
        c1 = c1->command_next;
        check_execcommand(c1, "/RValue/slashes2", "argv0", "r1", false);

        /* ignore && honour_argv0 */
        r = config_parse_exec("fake", 4, "section",
                              "LValue", 0, "-@/RValue///slashes3/// argv0a r1",
                              &c, NULL);
        assert_se(r >= 0);
        c1 = c1->command_next;
        check_execcommand(c1,
                          "/RValue/slashes3", "argv0a", "r1", true);

        /* ignore && honour_argv0 */
        r = config_parse_exec("fake", 4, "section",
                              "LValue", 0, "@-/RValue///slashes4/// argv0b r1",
                              &c, NULL);
        assert_se(r >= 0);
        c1 = c1->command_next;
        check_execcommand(c1,
                          "/RValue/slashes4", "argv0b", "r1", true);

        /* ignore && ignore */
        r = config_parse_exec("fake", 4, "section",
                              "LValue", 0, "--/RValue argv0 r1",
                              &c, NULL);
        assert_se(r == 0);
        assert_se(c1->command_next == NULL);

        /* ignore && ignore */
        r = config_parse_exec("fake", 4, "section",
                              "LValue", 0, "-@-/RValue argv0 r1",
                              &c, NULL);
        assert_se(r == 0);
        assert_se(c1->command_next == NULL);

        /* semicolon */
        r = config_parse_exec("fake", 5, "section",
                              "LValue", 0,
                              "-@/RValue argv0 r1 ; "
                              "/goo/goo boo",
                              &c, NULL);
        assert_se(r >= 0);
        c1 = c1->command_next;
        check_execcommand(c1,
                          "/RValue", "argv0", "r1", true);

        c1 = c1->command_next;
        check_execcommand(c1,
                          "/goo/goo", "/goo/goo", "boo", false);

        /* trailing semicolon */
        r = config_parse_exec("fake", 5, "section",
                              "LValue", 0,
                              "-@/RValue argv0 r1 ; ",
                              &c, NULL);
        assert_se(r >= 0);
        c1 = c1->command_next;
        check_execcommand(c1,
                          "/RValue", "argv0", "r1", true);

        assert_se(c1->command_next == NULL);

        /* escaped semicolon */
        r = config_parse_exec("fake", 5, "section",
                              "LValue", 0,
                              "/usr/bin/find \\;",
                              &c, NULL);
        assert_se(r >= 0);
        c1 = c1->command_next;
        check_execcommand(c1,
                          "/usr/bin/find", "/usr/bin/find", ";", false);

        exec_command_free_list(c);
}

#define env_file_1                              \
        "a=a\n"                                 \
        "b=b\\\n"                               \
        "c\n"                                   \
        "d=d\\\n"                               \
        "e\\\n"                                 \
        "f\n"                                   \
        "g=g\\ \n"                              \
        "h=h\n"                                 \
        "i=i\\"

#define env_file_2                              \
        "a=a\\\n"

#define env_file_3 \
        "#SPAMD_ARGS=\"-d --socketpath=/var/lib/bulwark/spamd \\\n" \
        "#--nouser-config                                     \\\n" \
        "normal=line"

static void test_load_env_file_1(void) {
        char _cleanup_strv_free_ **data = NULL;
        int r;

        char name[] = "/tmp/test-load-env-file.XXXXXX";
        int _cleanup_close_ fd = mkstemp(name);
        assert(fd >= 0);
        assert_se(write(fd, env_file_1, sizeof(env_file_1)) == sizeof(env_file_1));

        r = load_env_file(name, NULL, &data);
        assert(r == 0);
        assert(streq(data[0], "a=a"));
        assert(streq(data[1], "b=bc"));
        assert(streq(data[2], "d=def"));
        assert(streq(data[3], "g=g "));
        assert(streq(data[4], "h=h"));
        assert(streq(data[5], "i=i"));
        assert(data[6] == NULL);
        unlink(name);
}

static void test_load_env_file_2(void) {
        char _cleanup_strv_free_ **data = NULL;
        int r;

        char name[] = "/tmp/test-load-env-file.XXXXXX";
        int _cleanup_close_ fd = mkstemp(name);
        assert(fd >= 0);
        assert_se(write(fd, env_file_2, sizeof(env_file_2)) == sizeof(env_file_2));

        r = load_env_file(name, NULL, &data);
        assert(r == 0);
        assert(streq(data[0], "a=a"));
        assert(data[1] == NULL);
        unlink(name);
}

static void test_load_env_file_3(void) {
        char _cleanup_strv_free_ **data = NULL;
        int r;

        char name[] = "/tmp/test-load-env-file.XXXXXX";
        int _cleanup_close_ fd = mkstemp(name);
        assert(fd >= 0);
        assert_se(write(fd, env_file_3, sizeof(env_file_3)) == sizeof(env_file_3));

        r = load_env_file(name, NULL, &data);
        assert(r == 0);
        assert(data == NULL);
        unlink(name);
}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnonnull"

static void test_install_printf(void) {
        char    name[] = "name.service",
                path[] = "/run/systemd/system/name.service",
                user[] = "xxxx-no-such-user";
        InstallInfo i = {name, path, user};
        InstallInfo i2 = {name, path, NULL};
        char    name3[] = "name@inst.service",
                path3[] = "/run/systemd/system/name.service";
        InstallInfo i3 = {name3, path3, user};
        InstallInfo i4 = {name3, path3, NULL};

        char _cleanup_free_ *mid, *bid, *host;

        assert_se((mid = specifier_machine_id('m', NULL, NULL)));
        assert_se((bid = specifier_boot_id('b', NULL, NULL)));
        assert_se((host = gethostname_malloc()));

#define expect(src, pattern, result)                                    \
        do {                                                            \
                char _cleanup_free_ *t = install_full_printf(&src, pattern); \
                char _cleanup_free_                                     \
                        *d1 = strdup(i.name),                           \
                        *d2 = strdup(i.path),                           \
                        *d3 = strdup(i.user);                           \
                memzero(i.name, strlen(i.name));                        \
                memzero(i.path, strlen(i.path));                        \
                memzero(i.user, strlen(i.user));                        \
                assert(d1 && d2 && d3);                                 \
                if (result) {                                           \
                        printf("%s\n", t);                              \
                        assert(streq(t, result));                       \
                } else assert(t == NULL);                               \
                strcpy(i.name, d1);                                     \
                strcpy(i.path, d2);                                     \
                strcpy(i.user, d3);                                     \
        } while(false)

        assert_se(setenv("USER", "root", 1) == 0);

        expect(i, "%n", "name.service");
        expect(i, "%N", "name");
        expect(i, "%p", "name");
        expect(i, "%i", "");
        expect(i, "%u", "xxxx-no-such-user");
        expect(i, "%U", NULL);
        expect(i, "%m", mid);
        expect(i, "%b", bid);
        expect(i, "%H", host);

        expect(i2, "%u", "root");
        expect(i2, "%U", "0");

        expect(i3, "%n", "name@inst.service");
        expect(i3, "%N", "name@inst");
        expect(i3, "%p", "name");
        expect(i3, "%u", "xxxx-no-such-user");
        expect(i3, "%U", NULL);
        expect(i3, "%m", mid);
        expect(i3, "%b", bid);
        expect(i3, "%H", host);

        expect(i4, "%u", "root");
        expect(i4, "%U", "0");
}
#pragma GCC diagnostic pop

int main(int argc, char *argv[]) {

        test_unit_file_get_set();
        test_config_parse_exec();
        test_load_env_file_1();
        test_load_env_file_2();
        test_load_env_file_3();
        test_install_printf();

        return 0;
}
Commit	Line	Data
b5b46d59 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2012 Lennart Poettering
b9893505	7	Copyright 2013 Zbigniew Jędrzejewski-Szmek
b5b46d59 LP	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
	23	#include <assert.h>
	24	#include <stdio.h>
	25	#include <stddef.h>
	26	#include <string.h>
b9893505	27	#include <unistd.h>
b5b46d59 LP	28
b5b46d59 LP	29	#include "install.h"
7742f7e9 ZJS	30	#include "install-printf.h"
7742f7e9 ZJS	31	#include "specifier.h"
b5b46d59 LP	32	#include "util.h"
	33	#include "macro.h"
	34	#include "hashmap.h"
2c5417ad	35	#include "load-fragment.h"
b9893505	36	#include "strv.h"
a5c32cff	37	#include "fileio.h"
b5b46d59	38
2c5417ad	39	static void test_unit_file_get_set(void) {
b5b46d59 LP	40	int r;
	41	Hashmap *h;
	42	Iterator i;
	43	UnitFileList *p;
	44
	45	h = hashmap_new(string_hash_func, string_compare_func);
	46	assert(h);
	47
	48	r = unit_file_get_list(UNIT_FILE_SYSTEM, NULL, h);
d5891fda	49	log_info("unit_file_get_list: %s", strerror(-r));
b5b46d59 LP	50	assert(r >= 0);
	51
	52	HASHMAP_FOREACH(p, h, i)
	53	printf("%s = %s\n", p->path, unit_file_state_to_string(p->state));
	54
	55	unit_file_list_free(h);
2c5417ad ZJS	56	}
	57
	58	static void check_execcommand(ExecCommand *c,
	59	const char* path,
	60	const char* argv0,
	61	const char* argv1,
	62	bool ignore) {
	63	assert_se(c);
	64	log_info("%s %s %s %s",
	65	c->path, c->argv[0], c->argv[1], c->argv[2]);
	66	assert_se(streq(c->path, path));
	67	assert_se(streq(c->argv[0], argv0));
	68	assert_se(streq(c->argv[1], argv1));
	69	assert_se(c->argv[2] == NULL);
	70	assert_se(c->ignore == ignore);
	71	}
	72
	73	static void test_config_parse_exec(void) {
	74	/* int config_parse_exec( */
	75	/* const char filename, /
	76	/* unsigned line, */
	77	/* const char section, /
	78	/* const char lvalue, /
	79	/* int ltype, */
	80	/* const char rvalue, /
	81	/* void data, /
	82	/* void userdata) /
	83	int r;
	84
	85	ExecCommand c = NULL, c1;
	86
	87	/* basic test */
	88	r = config_parse_exec("fake", 1, "section",
	89	"LValue", 0, "/RValue r1",
	90	&c, NULL);
	91	assert_se(r >= 0);
	92	check_execcommand(c, "/RValue", "/RValue", "r1", false);
	93
	94	r = config_parse_exec("fake", 2, "section",
	95	"LValue", 0, "/RValue///slashes/// r1",
	96	&c, NULL);
	97	/* test slashes */
	98	assert_se(r >= 0);
	99	c1 = c->command_next;
	100	check_execcommand(c1, "/RValue/slashes", "/RValue///slashes///",
	101	"r1", false);
	102
	103	/* honour_argv0 */
	104	r = config_parse_exec("fake", 3, "section",
	105	"LValue", 0, "@/RValue///slashes2/// argv0 r1",
	106	&c, NULL);
	107	assert_se(r >= 0);
	108	c1 = c1->command_next;
	109	check_execcommand(c1, "/RValue/slashes2", "argv0", "r1", false);
	110
	111	/* ignore && honour_argv0 */
	112	r = config_parse_exec("fake", 4, "section",
	113	"LValue", 0, "-@/RValue///slashes3/// argv0a r1",
	114	&c, NULL);
	115	assert_se(r >= 0);
	116	c1 = c1->command_next;
	117	check_execcommand(c1,
	118	"/RValue/slashes3", "argv0a", "r1", true);
	119
0f67f1ef ZJS	120	/* ignore && honour_argv0 */
	121	r = config_parse_exec("fake", 4, "section",
	122	"LValue", 0, "@-/RValue///slashes4/// argv0b r1",
	123	&c, NULL);
	124	assert_se(r >= 0);
	125	c1 = c1->command_next;
	126	check_execcommand(c1,
	127	"/RValue/slashes4", "argv0b", "r1", true);
	128
	129	/* ignore && ignore */
	130	r = config_parse_exec("fake", 4, "section",
	131	"LValue", 0, "--/RValue argv0 r1",
	132	&c, NULL);
	133	assert_se(r == 0);
	134	assert_se(c1->command_next == NULL);
	135
	136	/* ignore && ignore */
	137	r = config_parse_exec("fake", 4, "section",
	138	"LValue", 0, "-@-/RValue argv0 r1",
	139	&c, NULL);
	140	assert_se(r == 0);
	141	assert_se(c1->command_next == NULL);
	142
2c5417ad ZJS	143	/* semicolon */
	144	r = config_parse_exec("fake", 5, "section",
	145	"LValue", 0,
	146	"-@/RValue argv0 r1 ; "
	147	"/goo/goo boo",
	148	&c, NULL);
	149	assert_se(r >= 0);
	150	c1 = c1->command_next;
	151	check_execcommand(c1,
	152	"/RValue", "argv0", "r1", true);
	153
	154	c1 = c1->command_next;
	155	check_execcommand(c1,
	156	"/goo/goo", "/goo/goo", "boo", false);
	157
	158	/* trailing semicolon */
	159	r = config_parse_exec("fake", 5, "section",
	160	"LValue", 0,
	161	"-@/RValue argv0 r1 ; ",
	162	&c, NULL);
	163	assert_se(r >= 0);
	164	c1 = c1->command_next;
	165	check_execcommand(c1,
	166	"/RValue", "argv0", "r1", true);
	167
	168	assert_se(c1->command_next == NULL);
	169
7e1a84f5 OS	170	/* escaped semicolon */
	171	r = config_parse_exec("fake", 5, "section",
	172	"LValue", 0,
	173	"/usr/bin/find \\;",
	174	&c, NULL);
	175	assert_se(r >= 0);
	176	c1 = c1->command_next;
	177	check_execcommand(c1,
	178	"/usr/bin/find", "/usr/bin/find", ";", false);
	179
2c5417ad ZJS	180	exec_command_free_list(c);
	181	}
	182
f73141d7 LP	183	#define env_file_1 \
	184	"a=a\n" \
	185	"b=b\\\n" \
	186	"c\n" \
	187	"d=d\\\n" \
	188	"e\\\n" \
	189	"f\n" \
	190	"g=g\\ \n" \
	191	"h=h\n" \
	192	"i=i\\"
	193
	194	#define env_file_2 \
	195	"a=a\\\n"
b9893505	196
a3aa7ee6 ZJS	197	#define env_file_3 \
	198	"#SPAMD_ARGS=\"-d --socketpath=/var/lib/bulwark/spamd \\\n" \
	199	"#--nouser-config \\\n" \
	200	"normal=line"
	201
b9893505 ZJS	202	static void test_load_env_file_1(void) {
	203	char _cleanup_strv_free_ **data = NULL;
	204	int r;
	205
	206	char name[] = "/tmp/test-load-env-file.XXXXXX";
	207	int _cleanup_close_ fd = mkstemp(name);
	208	assert(fd >= 0);
	209	assert_se(write(fd, env_file_1, sizeof(env_file_1)) == sizeof(env_file_1));
	210
f73141d7	211	r = load_env_file(name, NULL, &data);
b9893505	212	assert(r == 0);
f73141d7 LP	213	assert(streq(data[0], "a=a"));
	214	assert(streq(data[1], "b=bc"));
	215	assert(streq(data[2], "d=def"));
	216	assert(streq(data[3], "g=g "));
	217	assert(streq(data[4], "h=h"));
	218	assert(streq(data[5], "i=i"));
b9893505 ZJS	219	assert(data[6] == NULL);
	220	unlink(name);
	221	}
	222
	223	static void test_load_env_file_2(void) {
	224	char _cleanup_strv_free_ **data = NULL;
	225	int r;
	226
	227	char name[] = "/tmp/test-load-env-file.XXXXXX";
	228	int _cleanup_close_ fd = mkstemp(name);
	229	assert(fd >= 0);
	230	assert_se(write(fd, env_file_2, sizeof(env_file_2)) == sizeof(env_file_2));
	231
f73141d7	232	r = load_env_file(name, NULL, &data);
b9893505	233	assert(r == 0);
f73141d7	234	assert(streq(data[0], "a=a"));
b9893505 ZJS	235	assert(data[1] == NULL);
	236	unlink(name);
	237	}
	238
a3aa7ee6 ZJS	239	static void test_load_env_file_3(void) {
	240	char _cleanup_strv_free_ **data = NULL;
	241	int r;
	242
	243	char name[] = "/tmp/test-load-env-file.XXXXXX";
	244	int _cleanup_close_ fd = mkstemp(name);
	245	assert(fd >= 0);
	246	assert_se(write(fd, env_file_3, sizeof(env_file_3)) == sizeof(env_file_3));
	247
f73141d7	248	r = load_env_file(name, NULL, &data);
a3aa7ee6 ZJS	249	assert(r == 0);
	250	assert(data == NULL);
	251	unlink(name);
	252	}
	253
7742f7e9 ZJS	254	#pragma GCC diagnostic push
	255	#pragma GCC diagnostic ignored "-Wnonnull"
	256
	257	static void test_install_printf(void) {
	258	char name[] = "name.service",
ad88e758	259	path[] = "/run/systemd/system/name.service",
7742f7e9 ZJS	260	user[] = "xxxx-no-such-user";
	261	InstallInfo i = {name, path, user};
	262	InstallInfo i2 = {name, path, NULL};
	263	char name3[] = "name@inst.service",
ad88e758	264	path3[] = "/run/systemd/system/name.service";
7742f7e9 ZJS	265	InstallInfo i3 = {name3, path3, user};
	266	InstallInfo i4 = {name3, path3, NULL};
	267
	268	char _cleanup_free_ mid, bid, *host;
	269
	270	assert_se((mid = specifier_machine_id('m', NULL, NULL)));
	271	assert_se((bid = specifier_boot_id('b', NULL, NULL)));
	272	assert_se((host = gethostname_malloc()));
	273
	274	#define expect(src, pattern, result) \
f73141d7	275	do { \
7742f7e9 ZJS	276	char _cleanup_free_ *t = install_full_printf(&src, pattern); \
	277	char _cleanup_free_ \
	278	*d1 = strdup(i.name), \
	279	*d2 = strdup(i.path), \
	280	*d3 = strdup(i.user); \
	281	memzero(i.name, strlen(i.name)); \
	282	memzero(i.path, strlen(i.path)); \
	283	memzero(i.user, strlen(i.user)); \
	284	assert(d1 && d2 && d3); \
	285	if (result) { \
	286	printf("%s\n", t); \
	287	assert(streq(t, result)); \
	288	} else assert(t == NULL); \
	289	strcpy(i.name, d1); \
	290	strcpy(i.path, d2); \
	291	strcpy(i.user, d3); \
f73141d7	292	} while(false)
7742f7e9 ZJS	293
	294	assert_se(setenv("USER", "root", 1) == 0);
	295
	296	expect(i, "%n", "name.service");
	297	expect(i, "%N", "name");
	298	expect(i, "%p", "name");
	299	expect(i, "%i", "");
	300	expect(i, "%u", "xxxx-no-such-user");
	301	expect(i, "%U", NULL);
	302	expect(i, "%m", mid);
	303	expect(i, "%b", bid);
	304	expect(i, "%H", host);
	305
	306	expect(i2, "%u", "root");
	307	expect(i2, "%U", "0");
	308
	309	expect(i3, "%n", "name@inst.service");
	310	expect(i3, "%N", "name@inst");
	311	expect(i3, "%p", "name");
	312	expect(i3, "%u", "xxxx-no-such-user");
	313	expect(i3, "%U", NULL);
	314	expect(i3, "%m", mid);
	315	expect(i3, "%b", bid);
	316	expect(i3, "%H", host);
	317
	318	expect(i4, "%u", "root");
	319	expect(i4, "%U", "0");
	320	}
	321	#pragma GCC diagnostic pop
b9893505	322
2c5417ad ZJS	323	int main(int argc, char *argv[]) {
	324
	325	test_unit_file_get_set();
	326	test_config_parse_exec();
b9893505 ZJS	327	test_load_env_file_1();
b9893505 ZJS	328	test_load_env_file_2();
a3aa7ee6	329	test_load_env_file_3();
7742f7e9	330	test_install_printf();
b5b46d59 LP	331
	332	return 0;
	333	}