[thirdparty/systemd.git] / src / test / test-serialize.c

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

#include "escape.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "log.h"
#include "serialize.h"
#include "strv.h"
#include "tests.h"
#include "tmpfile-util.h"

char long_string[LONG_LINE_MAX+1];

static void test_serialize_item(void) {
        _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
        _cleanup_fclose_ FILE *f = NULL;

        assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
        log_info("/* %s (%s) */", __func__, fn);

        assert_se(serialize_item(f, "a", NULL) == 0);
        assert_se(serialize_item(f, "a", "bbb") == 1);
        assert_se(serialize_item(f, "a", "bbb") == 1);
        assert_se(serialize_item(f, "a", long_string) == -EINVAL);
        assert_se(serialize_item(f, long_string, "a") == -EINVAL);
        assert_se(serialize_item(f, long_string, long_string) == -EINVAL);

        rewind(f);

        _cleanup_free_ char *line1 = NULL, *line2 = NULL, *line3 = NULL;
        assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
        assert_se(streq(line1, "a=bbb"));
        assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
        assert_se(streq(line2, "a=bbb"));
        assert_se(read_line(f, LONG_LINE_MAX, &line3) == 0);
        assert_se(streq(line3, ""));
}

static void test_serialize_item_escaped(void) {
        _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
        _cleanup_fclose_ FILE *f = NULL;

        assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
        log_info("/* %s (%s) */", __func__, fn);

        assert_se(serialize_item_escaped(f, "a", NULL) == 0);
        assert_se(serialize_item_escaped(f, "a", "bbb") == 1);
        assert_se(serialize_item_escaped(f, "a", "bbb") == 1);
        assert_se(serialize_item_escaped(f, "a", long_string) == -EINVAL);
        assert_se(serialize_item_escaped(f, long_string, "a") == -EINVAL);
        assert_se(serialize_item_escaped(f, long_string, long_string) == -EINVAL);

        rewind(f);

        _cleanup_free_ char *line1 = NULL, *line2 = NULL, *line3 = NULL;
        assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
        assert_se(streq(line1, "a=bbb"));
        assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
        assert_se(streq(line2, "a=bbb"));
        assert_se(read_line(f, LONG_LINE_MAX, &line3) == 0);
        assert_se(streq(line3, ""));
}

static void test_serialize_usec(void) {
        _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
        _cleanup_fclose_ FILE *f = NULL;

        assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
        log_info("/* %s (%s) */", __func__, fn);

        assert_se(serialize_usec(f, "usec1", USEC_INFINITY) == 0);
        assert_se(serialize_usec(f, "usec2", 0) == 1);
        assert_se(serialize_usec(f, "usec3", USEC_INFINITY-1) == 1);

        rewind(f);

        _cleanup_free_ char *line1 = NULL, *line2 = NULL;
        usec_t x;

        assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
        assert_se(streq(line1, "usec2=0"));
        assert_se(deserialize_usec(line1 + 6, &x) == 0);
        assert_se(x == 0);

        assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
        assert_se(startswith(line2, "usec3="));
        assert_se(deserialize_usec(line2 + 6, &x) == 0);
        assert_se(x == USEC_INFINITY-1);
}

static void test_serialize_strv(void) {
        _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
        _cleanup_fclose_ FILE *f = NULL;

        char **strv = STRV_MAKE("a", "b", "foo foo",
                                "nasty1 \"",
                                "\"nasty2 ",
                                "nasty3 '",
                                "\"nasty4 \"",
                                "nasty5\n",
                                "\nnasty5\nfoo=bar",
                                "\nnasty5\nfoo=bar");

        assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
        log_info("/* %s (%s) */", __func__, fn);

        assert_se(serialize_strv(f, "strv1", NULL) == 0);
        assert_se(serialize_strv(f, "strv2", STRV_MAKE_EMPTY) == 0);
        assert_se(serialize_strv(f, "strv3", strv) == 1);
        assert_se(serialize_strv(f, "strv4", STRV_MAKE(long_string)) == -EINVAL);

        rewind(f);

        _cleanup_strv_free_ char **strv2 = NULL;
        for (;;) {
                _cleanup_free_ char *line = NULL;
                int r;

                r = read_line(f, LONG_LINE_MAX, &line);
                if (r == 0)
                        break;
                assert_se(r > 0);

                const char *t = startswith(line, "strv3=");
                assert_se(t);

                char *un;
                assert_se(cunescape(t, 0, &un) >= 0);
                assert_se(strv_consume(&strv2, un) >= 0);
        }

        assert_se(strv_equal(strv, strv2));
}

static void test_deserialize_environment(void) {
        _cleanup_strv_free_ char **env;

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

        assert_se(env = strv_new("A=1"));

        assert_se(deserialize_environment("B=2", &env) >= 0);
        assert_se(deserialize_environment("FOO%%=a\\177b\\nc\\td e", &env) >= 0);

        assert_se(strv_equal(env, STRV_MAKE("A=1", "B=2", "FOO%%=a\177b\nc\td e")));

        assert_se(deserialize_environment("foo\\", &env) < 0);
        assert_se(deserialize_environment("bar\\_baz", &env) < 0);
}

static void test_serialize_environment(void) {
        _cleanup_strv_free_ char **env = NULL, **env2 = NULL;
        _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-env-util.XXXXXXX";
        _cleanup_fclose_ FILE *f = NULL;
        int r;

        assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
        log_info("/* %s (%s) */", __func__, fn);

        assert_se(env = strv_new("A=1",
                                 "B=2",
                                 "C=ąęółń",
                                 "D=D=a\\x0Ab",
                                 "FOO%%=a\177b\nc\td e"));

        assert_se(serialize_strv(f, "env", env) == 1);
        assert_se(fflush_and_check(f) == 0);

        rewind(f);

        for (;;) {
                _cleanup_free_ char *line = NULL;
                const char *l;

                r = read_line(f, LONG_LINE_MAX, &line);
                assert_se(r >= 0);

                if (r == 0)
                        break;

                l = strstrip(line);

                assert_se(startswith(l, "env="));

                r = deserialize_environment(l+4, &env2);
                assert_se(r >= 0);
        }
        assert_se(feof(f));

        assert_se(strv_equal(env, env2));
}

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

        memset(long_string, 'x', sizeof(long_string)-1);
        char_array_0(long_string);

        test_serialize_item();
        test_serialize_item_escaped();
        test_serialize_usec();
        test_serialize_strv();
        test_deserialize_environment();
        test_serialize_environment();

        return EXIT_SUCCESS;
}
Commit	Line	Data
40a4c4b3 ZJS	1	/* SPDX-License-Identifier: LGPL-2.1+ */
40a4c4b3 ZJS	2
40a4c4b3 ZJS	3	#include "escape.h"
	4	#include "fd-util.h"
	5	#include "fileio.h"
	6	#include "fs-util.h"
	7	#include "log.h"
	8	#include "serialize.h"
	9	#include "strv.h"
	10	#include "tests.h"
e4de7287	11	#include "tmpfile-util.h"
40a4c4b3	12
fa2951de	13	char long_string[LONG_LINE_MAX+1];
40a4c4b3 ZJS	14
	15	static void test_serialize_item(void) {
	16	_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
	17	_cleanup_fclose_ FILE *f = NULL;
	18
	19	assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
	20	log_info("/* %s (%s) */", __func__, fn);
	21
	22	assert_se(serialize_item(f, "a", NULL) == 0);
	23	assert_se(serialize_item(f, "a", "bbb") == 1);
	24	assert_se(serialize_item(f, "a", "bbb") == 1);
	25	assert_se(serialize_item(f, "a", long_string) == -EINVAL);
	26	assert_se(serialize_item(f, long_string, "a") == -EINVAL);
	27	assert_se(serialize_item(f, long_string, long_string) == -EINVAL);
	28
	29	rewind(f);
	30
	31	_cleanup_free_ char line1 = NULL, line2 = NULL, *line3 = NULL;
	32	assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
	33	assert_se(streq(line1, "a=bbb"));
	34	assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
	35	assert_se(streq(line2, "a=bbb"));
	36	assert_se(read_line(f, LONG_LINE_MAX, &line3) == 0);
	37	assert_se(streq(line3, ""));
	38	}
	39
	40	static void test_serialize_item_escaped(void) {
	41	_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
	42	_cleanup_fclose_ FILE *f = NULL;
	43
	44	assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
	45	log_info("/* %s (%s) */", __func__, fn);
	46
	47	assert_se(serialize_item_escaped(f, "a", NULL) == 0);
	48	assert_se(serialize_item_escaped(f, "a", "bbb") == 1);
	49	assert_se(serialize_item_escaped(f, "a", "bbb") == 1);
	50	assert_se(serialize_item_escaped(f, "a", long_string) == -EINVAL);
	51	assert_se(serialize_item_escaped(f, long_string, "a") == -EINVAL);
	52	assert_se(serialize_item_escaped(f, long_string, long_string) == -EINVAL);
	53
	54	rewind(f);
	55
	56	_cleanup_free_ char line1 = NULL, line2 = NULL, *line3 = NULL;
	57	assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
	58	assert_se(streq(line1, "a=bbb"));
	59	assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
	60	assert_se(streq(line2, "a=bbb"));
	61	assert_se(read_line(f, LONG_LINE_MAX, &line3) == 0);
	62	assert_se(streq(line3, ""));
	63	}
	64
	65	static void test_serialize_usec(void) {
	66	_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
	67	_cleanup_fclose_ FILE *f = NULL;
	68
	69	assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
	70	log_info("/* %s (%s) */", __func__, fn);
	71
	72	assert_se(serialize_usec(f, "usec1", USEC_INFINITY) == 0);
	73	assert_se(serialize_usec(f, "usec2", 0) == 1);
	74	assert_se(serialize_usec(f, "usec3", USEC_INFINITY-1) == 1);
	75
	76	rewind(f);
	77
78	_cleanup_free_ char line1 = NULL, line2 = NULL;
79	usec_t x;
80
81	assert_se(read_line(f, LONG_LINE_MAX, &line1) > 0);
82	assert_se(streq(line1, "usec2=0"));
83	assert_se(deserialize_usec(line1 + 6, &x) == 0);
84	assert_se(x == 0);
85
86	assert_se(read_line(f, LONG_LINE_MAX, &line2) > 0);
87	assert_se(startswith(line2, "usec3="));
88	assert_se(deserialize_usec(line2 + 6, &x) == 0);
89	assert_se(x == USEC_INFINITY-1);
90	}
91
92	static void test_serialize_strv(void) {
93	_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-serialize.XXXXXX";
94	_cleanup_fclose_ FILE *f = NULL;
95
96	char **strv = STRV_MAKE("a", "b", "foo foo",
97	"nasty1 \"",
98	"\"nasty2 ",
99	"nasty3 '",
100	"\"nasty4 \"",
101	"nasty5\n",
102	"\nnasty5\nfoo=bar",
103	"\nnasty5\nfoo=bar");
104
105	assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
106	log_info("/* %s (%s) */", __func__, fn);
107
108	assert_se(serialize_strv(f, "strv1", NULL) == 0);
109	assert_se(serialize_strv(f, "strv2", STRV_MAKE_EMPTY) == 0);
110	assert_se(serialize_strv(f, "strv3", strv) == 1);
111	assert_se(serialize_strv(f, "strv4", STRV_MAKE(long_string)) == -EINVAL);
112
113	rewind(f);
114
115	_cleanup_strv_free_ char **strv2 = NULL;
116	for (;;) {
117	_cleanup_free_ char *line = NULL;
118	int r;
119
120	r = read_line(f, LONG_LINE_MAX, &line);
121	if (r == 0)
122	break;
123	assert_se(r > 0);
124
125	const char *t = startswith(line, "strv3=");
126	assert_se(t);
127
128	char *un;
129	assert_se(cunescape(t, 0, &un) >= 0);
130	assert_se(strv_consume(&strv2, un) >= 0);
131	}
132
133	assert_se(strv_equal(strv, strv2));
134	}
135
1c1d719a ZJS	136	static void test_deserialize_environment(void) {
	137	_cleanup_strv_free_ char **env;
	138
	139	log_info("/* %s */", __func__);
	140
bea1a013	141	assert_se(env = strv_new("A=1"));
1c1d719a ZJS	142
	143	assert_se(deserialize_environment("B=2", &env) >= 0);
	144	assert_se(deserialize_environment("FOO%%=a\\177b\\nc\\td e", &env) >= 0);
	145
	146	assert_se(strv_equal(env, STRV_MAKE("A=1", "B=2", "FOO%%=a\177b\nc\td e")));
	147
	148	assert_se(deserialize_environment("foo\\", &env) < 0);
	149	assert_se(deserialize_environment("bar\\_baz", &env) < 0);
	150	}
	151
	152	static void test_serialize_environment(void) {
	153	_cleanup_strv_free_ char env = NULL, env2 = NULL;
	154	_cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-env-util.XXXXXXX";
	155	_cleanup_fclose_ FILE *f = NULL;
	156	int r;
	157
	158	assert_se(fmkostemp_safe(fn, "r+", &f) == 0);
	159	log_info("/* %s (%s) */", __func__, fn);
	160
	161	assert_se(env = strv_new("A=1",
	162	"B=2",
	163	"C=ąęółń",
	164	"D=D=a\\x0Ab",
bea1a013	165	"FOO%%=a\177b\nc\td e"));
1c1d719a ZJS	166
	167	assert_se(serialize_strv(f, "env", env) == 1);
	168	assert_se(fflush_and_check(f) == 0);
	169
	170	rewind(f);
	171
	172	for (;;) {
	173	_cleanup_free_ char *line = NULL;
	174	const char *l;
	175
	176	r = read_line(f, LONG_LINE_MAX, &line);
	177	assert_se(r >= 0);
	178
	179	if (r == 0)
	180	break;
	181
	182	l = strstrip(line);
	183
	184	assert_se(startswith(l, "env="));
	185
	186	r = deserialize_environment(l+4, &env2);
	187	assert_se(r >= 0);
	188	}
	189	assert_se(feof(f));
	190
	191	assert_se(strv_equal(env, env2));
	192	}
	193
40a4c4b3 ZJS	194	int main(int argc, char *argv[]) {
	195	test_setup_logging(LOG_INFO);
	196
fa2951de ZJS	197	memset(long_string, 'x', sizeof(long_string)-1);
	198	char_array_0(long_string);
	199
40a4c4b3 ZJS	200	test_serialize_item();
	201	test_serialize_item_escaped();
	202	test_serialize_usec();
	203	test_serialize_strv();
1c1d719a ZJS	204	test_deserialize_environment();
1c1d719a ZJS	205	test_serialize_environment();
40a4c4b3 ZJS	206
	207	return EXIT_SUCCESS;
	208	}