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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "parse-util.h"
#include "process-util.h"
#include "serialize.h"
#include "string-util.h"
#include "strv.h"
#include "tests.h"

TEST(strv_env_delete) {
        _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;

        a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
        assert_se(a);

        b = strv_new("PIEP", "FOO");
        assert_se(b);

        c = strv_new("SCHLUMPF");
        assert_se(c);

        d = strv_env_delete(a, 2, b, c);
        assert_se(d);

        assert_se(streq(d[0], "WALDO=WALDO"));
        assert_se(streq(d[1], "WALDO="));
        assert_se(strv_length(d) == 2);
}

TEST(strv_env_get) {
        char **l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");

        assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2"));
        assert_se(streq(strv_env_get(l, "THREE"), "3"));
        assert_se(streq(strv_env_get(l, "FOUR"), "4"));
}

TEST(strv_env_pairs_get) {
        char **l = STRV_MAKE("ONE_OR_TWO", "1", "THREE", "3", "ONE_OR_TWO", "2", "FOUR", "4", "FIVE", "5", "SIX", "FIVE", "SEVEN", "7");

        assert_se(streq(strv_env_pairs_get(l, "ONE_OR_TWO"), "2"));
        assert_se(streq(strv_env_pairs_get(l, "THREE"), "3"));
        assert_se(streq(strv_env_pairs_get(l, "FOUR"), "4"));
        assert_se(streq(strv_env_pairs_get(l, "FIVE"), "5"));
}

TEST(strv_env_unset) {
        _cleanup_strv_free_ char **l = NULL;

        l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
        assert_se(l);

        assert_se(strv_env_unset(l, "SCHLUMPF") == l);

        assert_se(streq(l[0], "PIEP"));
        assert_se(streq(l[1], "NANANANA=YES"));
        assert_se(strv_length(l) == 2);
}

TEST(strv_env_merge) {
        char **a = STRV_MAKE("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", "EQ===");
        char **b = STRV_MAKE("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");

        _cleanup_strv_free_ char **r = strv_env_merge(NULL, a, NULL, b, NULL, a, b, b, NULL);
        assert_se(r);
        assert_se(streq(r[0], "FOO="));
        assert_se(streq(r[1], "WALDO="));
        assert_se(streq(r[2], "PIEP"));
        assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
        assert_se(streq(r[4], "EQ==="));
        assert_se(streq(r[5], "PIEP="));
        assert_se(streq(r[6], "NANANANA=YES"));
        assert_se(strv_length(r) == 7);

        assert_se(strv_env_clean(r) == r);
        assert_se(streq(r[0], "FOO="));
        assert_se(streq(r[1], "WALDO="));
        assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
        assert_se(streq(r[3], "EQ==="));
        assert_se(streq(r[4], "PIEP="));
        assert_se(streq(r[5], "NANANANA=YES"));
        assert_se(strv_length(r) == 6);
}

TEST(strv_env_replace_strdup) {
        _cleanup_strv_free_ char **a = NULL;

        assert_se(strv_env_replace_strdup(&a, "a=a") == 1);
        assert_se(strv_env_replace_strdup(&a, "b=b") == 1);
        assert_se(strv_env_replace_strdup(&a, "a=A") == 0);
        assert_se(strv_env_replace_strdup(&a, "c") == -EINVAL);

        assert_se(strv_length(a) == 2);
        strv_sort(a);
        assert_se(streq(a[0], "a=A"));
        assert_se(streq(a[1], "b=b"));
}

TEST(strv_env_replace_strdup_passthrough) {
        _cleanup_strv_free_ char **a = NULL;

        assert_se(putenv((char*) "a=a") == 0);
        assert_se(putenv((char*) "b=") == 0);
        assert_se(unsetenv("c") == 0);

        assert_se(strv_env_replace_strdup_passthrough(&a, "a") == 1);
        assert_se(strv_env_replace_strdup_passthrough(&a, "b") == 1);
        assert_se(strv_env_replace_strdup_passthrough(&a, "c") == 1);
        assert_se(strv_env_replace_strdup_passthrough(&a, "a") == 0);
        assert_se(strv_env_replace_strdup_passthrough(&a, "$a") == -EINVAL);

        assert_se(strv_length(a) == 3);
        assert_se(streq(a[0], "a=a"));
        assert_se(streq(a[1], "b="));
        assert_se(streq(a[2], "c="));
}

TEST(strv_env_assign) {
        _cleanup_strv_free_ char **a = NULL;

        assert_se(strv_env_assign(&a, "a", "a") == 1);
        assert_se(strv_env_assign(&a, "b", "b") == 1);
        assert_se(strv_env_assign(&a, "a", "A") == 0);
        assert_se(strv_env_assign(&a, "b", NULL) == 0);

        assert_se(strv_env_assign(&a, "a=", "B") == -EINVAL);

        assert_se(strv_length(a) == 1);
        assert_se(streq(a[0], "a=A"));
}

TEST(strv_env_assign_many) {
        _cleanup_strv_free_ char **a = NULL;

        assert_se(strv_env_assign_many(&a, "a", "a", "b", "b") >= 0);

        assert_se(strv_length(a) == 2);
        assert_se(strv_contains(a, "a=a"));
        assert_se(strv_contains(a, "b=b"));

        assert_se(strv_env_assign_many(&a, "a", "A", "b", "b", "c", "c") >= 0);
        assert_se(strv_length(a) == 3);
        assert_se(strv_contains(a, "a=A"));
        assert_se(strv_contains(a, "b=b"));
        assert_se(strv_contains(a, "c=c"));

        assert_se(strv_env_assign_many(&a, "b", NULL, "c", "C") >= 0);
        assert_se(strv_length(a) == 2);
        assert_se(strv_contains(a, "a=A"));
        assert_se(strv_contains(a, "c=C"));

        assert_se(strv_env_assign_many(&a, "a=", "B") == -EINVAL);
        assert_se(strv_length(a) == 2);
        assert_se(strv_contains(a, "a=A"));
        assert_se(strv_contains(a, "c=C"));
}

TEST(env_strv_get_n) {
        const char *_env[] = {
                "FOO=NO NO NO",
                "FOO=BAR BAR",
                "BAR=waldo",
                "PATH=unset",
                NULL
        };
        char **env = (char**) _env;

        assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
        assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
        assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
        assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));

        assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
        assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
        assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
        assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));

        env[3] = NULL; /* kill our $PATH */

        assert_se(!strv_env_get_n(env, "PATH__", 4, 0));
        assert_se(!strv_env_get_n(env, "PATH", 4, 0));
        assert_se(streq_ptr(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
                            getenv("PATH")));
        assert_se(streq_ptr(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
                            getenv("PATH")));
}

static void test_replace_env1(bool braceless) {
        log_info("/* %s(braceless=%s) */", __func__, yes_no(braceless));

        const char *env[] = {
                "FOO=BAR BAR",
                "BAR=waldo",
                NULL
        };
        _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL;
        unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;

        t = replace_env("FOO=$FOO=${FOO}", (char**) env, flags);
        assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));

        s = replace_env("BAR=$BAR=${BAR}", (char**) env, flags);
        assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));

        q = replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags);
        assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));

        r = replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags);
        assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));

        p = replace_env("${BAR}$BAR$BAR", (char**) env, flags);
        assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
}

static void test_replace_env2(bool extended) {
        log_info("/* %s(extended=%s) */", __func__, yes_no(extended));

        const char *env[] = {
                "FOO=foo",
                "BAR=bar",
                NULL
        };
        _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL, *x = NULL, *y = NULL;
        unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;

        t = replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags);
        assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));

        s = replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags);
        assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));

        q = replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags);
        assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));

        r = replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags);
        assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));

        p = replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags);
        assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));

        x = replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags);
        assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));

        y = replace_env("FOO=${FOO}between${BAR:-baz}", (char**) env, flags);
        assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"));
}

TEST(replace_env) {
        test_replace_env1(false);
        test_replace_env1(true);
        test_replace_env2(false);
        test_replace_env2(true);
}

TEST(replace_env_argv) {
        const char *env[] = {
                "FOO=BAR BAR",
                "BAR=waldo",
                NULL
        };
        const char *line[] = {
                "FOO$FOO",
                "FOO$FOOFOO",
                "FOO${FOO}$FOO",
                "FOO${FOO}",
                "${FOO}",
                "$FOO",
                "$FOO$FOO",
                "${FOO}${BAR}",
                "${FOO",
                "FOO$$${FOO}",
                "$$FOO${FOO}",
                "${FOO:-${BAR}}",
                "${QUUX:-${FOO}}",
                "${FOO:+${BAR}}",
                "${QUUX:+${BAR}}",
                "${FOO:+|${BAR}|}}",
                "${FOO:+|${BAR}{|}",
                NULL
        };
        _cleanup_strv_free_ char **r = NULL;

        r = replace_env_argv((char**) line, (char**) env);
        assert_se(r);
        assert_se(streq(r[0], "FOO$FOO"));
        assert_se(streq(r[1], "FOO$FOOFOO"));
        assert_se(streq(r[2], "FOOBAR BAR$FOO"));
        assert_se(streq(r[3], "FOOBAR BAR"));
        assert_se(streq(r[4], "BAR BAR"));
        assert_se(streq(r[5], "BAR"));
        assert_se(streq(r[6], "BAR"));
        assert_se(streq(r[7], "BAR BARwaldo"));
        assert_se(streq(r[8], "${FOO"));
        assert_se(streq(r[9], "FOO$BAR BAR"));
        assert_se(streq(r[10], "$FOOBAR BAR"));
        assert_se(streq(r[11], "${FOO:-waldo}"));
        assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
        assert_se(streq(r[13], "${FOO:+waldo}"));
        assert_se(streq(r[14], "${QUUX:+waldo}"));
        assert_se(streq(r[15], "${FOO:+|waldo|}}"));
        assert_se(streq(r[16], "${FOO:+|waldo{|}"));
        assert_se(strv_length(r) == 17);
}

TEST(env_clean) {
        _cleanup_strv_free_ char **e = strv_new("FOOBAR=WALDO",
                                                "FOOBAR=WALDO",
                                                "FOOBAR",
                                                "F",
                                                "X=",
                                                "F=F",
                                                "=",
                                                "=F",
                                                "",
                                                "0000=000",
                                                "äöüß=abcd",
                                                "abcd=äöüß",
                                                "xyz\n=xyz",
                                                "xyz=xyz\n",
                                                "another=one",
                                                "another=final one",
                                                "CRLF=\r\n",
                                                "LESS_TERMCAP_mb=\x1b[01;31m",
                                                "BASH_FUNC_foo%%=() {  echo foo\n}");
        assert_se(e);
        assert_se(!strv_env_is_valid(e));
        assert_se(strv_env_clean(e) == e);
        assert_se(strv_env_is_valid(e));

        assert_se(streq(e[0], "FOOBAR=WALDO"));
        assert_se(streq(e[1], "X="));
        assert_se(streq(e[2], "F=F"));
        assert_se(streq(e[3], "abcd=äöüß"));
        assert_se(streq(e[4], "xyz=xyz\n"));
        assert_se(streq(e[5], "another=final one"));
        assert_se(streq(e[6], "CRLF=\r\n"));
        assert_se(streq(e[7], "LESS_TERMCAP_mb=\x1b[01;31m"));
        assert_se(e[8] == NULL);
}

TEST(env_name_is_valid) {
        assert_se(env_name_is_valid("test"));

        assert_se(!env_name_is_valid(NULL));
        assert_se(!env_name_is_valid(""));
        assert_se(!env_name_is_valid("xxx\a"));
        assert_se(!env_name_is_valid("xxx\007b"));
        assert_se(!env_name_is_valid("\007\009"));
        assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
        assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
}

TEST(env_value_is_valid) {
        assert_se(env_value_is_valid(""));
        assert_se(env_value_is_valid("głąb kapuściany"));
        assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
        assert_se(env_value_is_valid("tab\tcharacter"));
        assert_se(env_value_is_valid("new\nline"));
        assert_se(env_value_is_valid("Show this?\rNope. Show that!"));
        assert_se(env_value_is_valid("new DOS\r\nline"));

        assert_se(!env_value_is_valid("\xc5")); /* A truncated utf-8-encoded "ł".
                                                 * We currently disallow that. */
}

TEST(env_assignment_is_valid) {
        assert_se(env_assignment_is_valid("a="));
        assert_se(env_assignment_is_valid("b=głąb kapuściany"));
        assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
        assert_se(env_assignment_is_valid("e=printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
        assert_se(env_assignment_is_valid("f=tab\tcharacter"));
        assert_se(env_assignment_is_valid("g=new\nline"));

        assert_se(!env_assignment_is_valid("="));
        assert_se(!env_assignment_is_valid("a b="));
        assert_se(!env_assignment_is_valid("a ="));
        assert_se(!env_assignment_is_valid(" b="));
        /* no dots or dashes: http://tldp.org/LDP/abs/html/gotchas.html */
        assert_se(!env_assignment_is_valid("a.b="));
        assert_se(!env_assignment_is_valid("a-b="));
        assert_se(!env_assignment_is_valid("\007=głąb kapuściany"));
        assert_se(!env_assignment_is_valid("c\009=\007\009\011"));
        assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
}

TEST(putenv_dup) {
        assert_se(putenv_dup("A=a1", true) == 0);
        assert_se(streq_ptr(getenv("A"), "a1"));
        assert_se(putenv_dup("A=a1", true) == 0);
        assert_se(streq_ptr(getenv("A"), "a1"));
        assert_se(putenv_dup("A=a2", false) == 0);
        assert_se(streq_ptr(getenv("A"), "a1"));
        assert_se(putenv_dup("A=a2", true) == 0);
        assert_se(streq_ptr(getenv("A"), "a2"));
}

TEST(setenv_systemd_exec_pid) {
        _cleanup_free_ char *saved = NULL;
        const char *e;
        pid_t p;

        e = getenv("SYSTEMD_EXEC_PID");
        if (e)
                assert_se(saved = strdup(e));

        assert_se(unsetenv("SYSTEMD_EXEC_PID") >= 0);
        assert_se(setenv_systemd_exec_pid(true) == 0);
        assert_se(!getenv("SYSTEMD_EXEC_PID"));

        assert_se(setenv("SYSTEMD_EXEC_PID", "*", 1) >= 0);
        assert_se(setenv_systemd_exec_pid(true) == 0);
        assert_se(e = getenv("SYSTEMD_EXEC_PID"));
        assert_se(streq(e, "*"));

        assert_se(setenv("SYSTEMD_EXEC_PID", "123abc", 1) >= 0);
        assert_se(setenv_systemd_exec_pid(true) == 1);
        assert_se(e = getenv("SYSTEMD_EXEC_PID"));
        assert_se(parse_pid(e, &p) >= 0);
        assert_se(p == getpid_cached());

        assert_se(unsetenv("SYSTEMD_EXEC_PID") >= 0);
        assert_se(setenv_systemd_exec_pid(false) == 1);
        assert_se(e = getenv("SYSTEMD_EXEC_PID"));
        assert_se(parse_pid(e, &p) >= 0);
        assert_se(p == getpid_cached());

        assert_se(set_unset_env("SYSTEMD_EXEC_PID", saved, 1) >= 0);
}

TEST(getenv_steal_erase) {
        int r;

        r = safe_fork("(sd-getenvstealerase)", FORK_DEATHSIG|FORK_LOG|FORK_WAIT, NULL);
        if (r == 0) {
                _cleanup_strv_free_ char **l = NULL;

                /* child */

                assert_se(getenv_steal_erase("thisenvvardefinitelywontexist", NULL) == 0);

                l = strv_new("FOO=BAR", "QUUX=PIFF", "ONE=TWO", "A=B");
                assert_se(strv_length(l) == 4);

                environ = l;

                STRV_FOREACH(e, environ) {
                        _cleanup_free_ char *n = NULL, *copy1 = NULL, *copy2 = NULL;
                        char *eq;

                        eq = strchr(*e, '=');
                        if (!eq)
                                continue;

                        n = strndup(*e, eq - *e);
                        assert_se(n);

                        copy1 = strdup(eq + 1);
                        assert_se(copy1);

                        assert_se(streq_ptr(getenv(n), copy1));
                        assert_se(getenv(n) == eq + 1);
                        assert_se(getenv_steal_erase(n, &copy2) > 0);
                        assert_se(streq_ptr(copy1, copy2));
                        assert_se(isempty(eq + 1));
                        assert_se(!getenv(n));
                }

                environ = NULL;
                l = strv_free(l);

                _exit(EXIT_SUCCESS);
        }

        assert_se(r > 0);
}

TEST(strv_env_name_is_valid) {
        assert_se(strv_env_name_is_valid(STRV_MAKE("HOME", "USER", "SHELL", "PATH")));
        assert_se(!strv_env_name_is_valid(STRV_MAKE("", "PATH", "home", "user", "SHELL")));
        assert_se(!strv_env_name_is_valid(STRV_MAKE("HOME", "USER", "SHELL", "USER")));
}

DEFINE_TEST_MAIN(LOG_DEBUG);
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
c24eb49e	2
4d1a6904	3	#include "env-util.h"
a096d8c8 ZJS	4	#include "fd-util.h"
a096d8c8 ZJS	5	#include "fileio.h"
75e7d50e	6	#include "fs-util.h"
cfd1c6e2 YW	7	#include "parse-util.h"
cfd1c6e2 YW	8	#include "process-util.h"
d68c645b	9	#include "serialize.h"
07630cea LP	10	#include "string-util.h"
07630cea LP	11	#include "strv.h"
2824374f	12	#include "tests.h"
c24eb49e	13
4f7452a8	14	TEST(strv_env_delete) {
940bd473 TA	15	_cleanup_strv_free_ char a = NULL, b = NULL, c = NULL, d = NULL;
940bd473 TA	16
bea1a013	17	a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
9b5d6bd9 LP	18	assert_se(a);
9b5d6bd9 LP	19
bea1a013	20	b = strv_new("PIEP", "FOO");
9b5d6bd9 LP	21	assert_se(b);
9b5d6bd9 LP	22
bea1a013	23	c = strv_new("SCHLUMPF");
9b5d6bd9	24	assert_se(c);
940bd473 TA	25
940bd473 TA	26	d = strv_env_delete(a, 2, b, c);
9b5d6bd9	27	assert_se(d);
940bd473	28
9b5d6bd9 LP	29	assert_se(streq(d[0], "WALDO=WALDO"));
	30	assert_se(streq(d[1], "WALDO="));
	31	assert_se(strv_length(d) == 2);
940bd473 TA	32	}
940bd473 TA	33
4f7452a8	34	TEST(strv_env_get) {
0b345642	35	char **l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");
6162512c RS	36
	37	assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2"));
	38	assert_se(streq(strv_env_get(l, "THREE"), "3"));
	39	assert_se(streq(strv_env_get(l, "FOUR"), "4"));
	40	}
	41
4f7452a8	42	TEST(strv_env_pairs_get) {
42e6a77b LB	43	char **l = STRV_MAKE("ONE_OR_TWO", "1", "THREE", "3", "ONE_OR_TWO", "2", "FOUR", "4", "FIVE", "5", "SIX", "FIVE", "SEVEN", "7");
	44
	45	assert_se(streq(strv_env_pairs_get(l, "ONE_OR_TWO"), "2"));
	46	assert_se(streq(strv_env_pairs_get(l, "THREE"), "3"));
	47	assert_se(streq(strv_env_pairs_get(l, "FOUR"), "4"));
	48	assert_se(streq(strv_env_pairs_get(l, "FIVE"), "5"));
	49	}
	50
4f7452a8	51	TEST(strv_env_unset) {
940bd473 TA	52	_cleanup_strv_free_ char **l = NULL;
940bd473 TA	53
bea1a013	54	l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
9b5d6bd9	55	assert_se(l);
940bd473	56
9b5d6bd9	57	assert_se(strv_env_unset(l, "SCHLUMPF") == l);
940bd473	58
9b5d6bd9 LP	59	assert_se(streq(l[0], "PIEP"));
	60	assert_se(streq(l[1], "NANANANA=YES"));
	61	assert_se(strv_length(l) == 2);
940bd473 TA	62	}
940bd473 TA	63
4f7452a8	64	TEST(strv_env_merge) {
43cadb64 ZJS	65	char **a = STRV_MAKE("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", "EQ===");
43cadb64 ZJS	66	char **b = STRV_MAKE("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");
1f28b2de	67
43cadb64	68	_cleanup_strv_free_ char **r = strv_env_merge(NULL, a, NULL, b, NULL, a, b, b, NULL);
9b5d6bd9 LP	69	assert_se(r);
	70	assert_se(streq(r[0], "FOO="));
	71	assert_se(streq(r[1], "WALDO="));
	72	assert_se(streq(r[2], "PIEP"));
	73	assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
43cadb64 ZJS	74	assert_se(streq(r[4], "EQ==="));
	75	assert_se(streq(r[5], "PIEP="));
	76	assert_se(streq(r[6], "NANANANA=YES"));
	77	assert_se(strv_length(r) == 7);
9b5d6bd9 LP	78
	79	assert_se(strv_env_clean(r) == r);
	80	assert_se(streq(r[0], "FOO="));
	81	assert_se(streq(r[1], "WALDO="));
	82	assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
43cadb64 ZJS	83	assert_se(streq(r[3], "EQ==="));
	84	assert_se(streq(r[4], "PIEP="));
	85	assert_se(streq(r[5], "NANANANA=YES"));
	86	assert_se(strv_length(r) == 6);
1f28b2de TA	87	}
1f28b2de TA	88
4f7452a8	89	TEST(strv_env_replace_strdup) {
73c8cc71 ZJS	90	_cleanup_strv_free_ char **a = NULL;
	91
	92	assert_se(strv_env_replace_strdup(&a, "a=a") == 1);
	93	assert_se(strv_env_replace_strdup(&a, "b=b") == 1);
	94	assert_se(strv_env_replace_strdup(&a, "a=A") == 0);
a14af47e	95	assert_se(strv_env_replace_strdup(&a, "c") == -EINVAL);
73c8cc71 ZJS	96
	97	assert_se(strv_length(a) == 2);
	98	strv_sort(a);
	99	assert_se(streq(a[0], "a=A"));
	100	assert_se(streq(a[1], "b=b"));
	101	}
	102
4f7452a8	103	TEST(strv_env_replace_strdup_passthrough) {
a14af47e ZJS	104	_cleanup_strv_free_ char **a = NULL;
	105
	106	assert_se(putenv((char*) "a=a") == 0);
	107	assert_se(putenv((char*) "b=") == 0);
	108	assert_se(unsetenv("c") == 0);
	109
	110	assert_se(strv_env_replace_strdup_passthrough(&a, "a") == 1);
	111	assert_se(strv_env_replace_strdup_passthrough(&a, "b") == 1);
	112	assert_se(strv_env_replace_strdup_passthrough(&a, "c") == 1);
	113	assert_se(strv_env_replace_strdup_passthrough(&a, "a") == 0);
	114	assert_se(strv_env_replace_strdup_passthrough(&a, "$a") == -EINVAL);
	115
	116	assert_se(strv_length(a) == 3);
	117	assert_se(streq(a[0], "a=a"));
	118	assert_se(streq(a[1], "b="));
	119	assert_se(streq(a[2], "c="));
	120	}
	121
4f7452a8	122	TEST(strv_env_assign) {
73c8cc71 ZJS	123	_cleanup_strv_free_ char **a = NULL;
	124
	125	assert_se(strv_env_assign(&a, "a", "a") == 1);
	126	assert_se(strv_env_assign(&a, "b", "b") == 1);
	127	assert_se(strv_env_assign(&a, "a", "A") == 0);
	128	assert_se(strv_env_assign(&a, "b", NULL) == 0);
	129
	130	assert_se(strv_env_assign(&a, "a=", "B") == -EINVAL);
	131
	132	assert_se(strv_length(a) == 1);
	133	assert_se(streq(a[0], "a=A"));
	134	}
	135
40975963 YW	136	TEST(strv_env_assign_many) {
	137	_cleanup_strv_free_ char **a = NULL;
	138
	139	assert_se(strv_env_assign_many(&a, "a", "a", "b", "b") >= 0);
	140
	141	assert_se(strv_length(a) == 2);
	142	assert_se(strv_contains(a, "a=a"));
	143	assert_se(strv_contains(a, "b=b"));
	144
	145	assert_se(strv_env_assign_many(&a, "a", "A", "b", "b", "c", "c") >= 0);
	146	assert_se(strv_length(a) == 3);
	147	assert_se(strv_contains(a, "a=A"));
	148	assert_se(strv_contains(a, "b=b"));
	149	assert_se(strv_contains(a, "c=c"));
	150
	151	assert_se(strv_env_assign_many(&a, "b", NULL, "c", "C") >= 0);
	152	assert_se(strv_length(a) == 2);
	153	assert_se(strv_contains(a, "a=A"));
	154	assert_se(strv_contains(a, "c=C"));
	155
	156	assert_se(strv_env_assign_many(&a, "a=", "B") == -EINVAL);
	157	assert_se(strv_length(a) == 2);
	158	assert_se(strv_contains(a, "a=A"));
	159	assert_se(strv_contains(a, "c=C"));
	160	}
	161
4f7452a8	162	TEST(env_strv_get_n) {
37f3ffca RS	163	const char *_env[] = {
	164	"FOO=NO NO NO",
	165	"FOO=BAR BAR",
	166	"BAR=waldo",
	167	"PATH=unset",
	168	NULL
	169	};
	170	char env = (char) _env;
	171
	172	assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
	173	assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
	174	assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
	175	assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
	176
	177	assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
	178	assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
	179	assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
	180	assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
	181
	182	env[3] = NULL; /* kill our $PATH */
	183
	184	assert_se(!strv_env_get_n(env, "PATH__", 4, 0));
	185	assert_se(!strv_env_get_n(env, "PATH", 4, 0));
1890c538 ZJS	186	assert_se(streq_ptr(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
	187	getenv("PATH")));
	188	assert_se(streq_ptr(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
	189	getenv("PATH")));
37f3ffca RS	190	}
37f3ffca RS	191
4f7452a8	192	static void test_replace_env1(bool braceless) {
0b345642 ZJS	193	log_info("/* %s(braceless=%s) */", __func__, yes_no(braceless));
0b345642 ZJS	194
ccad1fd0 ZJS	195	const char *env[] = {
	196	"FOO=BAR BAR",
	197	"BAR=waldo",
	198	NULL
	199	};
	200	_cleanup_free_ char t = NULL, s = NULL, q = NULL, r = NULL, *p = NULL;
	201	unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;
	202
	203	t = replace_env("FOO=$FOO=${FOO}", (char**) env, flags);
	204	assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));
	205
	206	s = replace_env("BAR=$BAR=${BAR}", (char**) env, flags);
	207	assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));
	208
	209	q = replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags);
	210	assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));
	211
a93236aa ZJS	212	r = replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags);
a93236aa ZJS	213	assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));
ccad1fd0 ZJS	214
	215	p = replace_env("${BAR}$BAR$BAR", (char**) env, flags);
	216	assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
	217	}
	218
f50ce8fc	219	static void test_replace_env2(bool extended) {
0b345642 ZJS	220	log_info("/* %s(extended=%s) */", __func__, yes_no(extended));
0b345642 ZJS	221
f50ce8fc ZJS	222	const char *env[] = {
	223	"FOO=foo",
	224	"BAR=bar",
	225	NULL
	226	};
5ef97a71	227	_cleanup_free_ char t = NULL, s = NULL, q = NULL, r = NULL, p = NULL, x = NULL, *y = NULL;
f50ce8fc ZJS	228	unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;
	229
	230	t = replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags);
	231	assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));
	232
	233	s = replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags);
	234	assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));
	235
	236	q = replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags);
	237	assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));
	238
	239	r = replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags);
	240	assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));
	241
	242	p = replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags);
	243	assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));
	244
	245	x = replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags);
	246	assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
5ef97a71 AS	247
	248	y = replace_env("FOO=${FOO}between${BAR:-baz}", (char**) env, flags);
	249	assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"));
f50ce8fc ZJS	250	}
f50ce8fc ZJS	251
4f7452a8 JJ	252	TEST(replace_env) {
	253	test_replace_env1(false);
	254	test_replace_env1(true);
	255	test_replace_env2(false);
	256	test_replace_env2(true);
	257	}
0b345642	258
4f7452a8	259	TEST(replace_env_argv) {
c24eb49e LP	260	const char *env[] = {
	261	"FOO=BAR BAR",
	262	"BAR=waldo",
	263	NULL
	264	};
c24eb49e LP	265	const char *line[] = {
	266	"FOO$FOO",
	267	"FOO$FOOFOO",
	268	"FOO${FOO}$FOO",
	269	"FOO${FOO}",
	270	"${FOO}",
	271	"$FOO",
	272	"$FOO$FOO",
	273	"${FOO}${BAR}",
	274	"${FOO",
df553b58 MS	275	"FOO$$${FOO}",
df553b58 MS	276	"$$FOO${FOO}",
b82f58bf RS	277	"${FOO:-${BAR}}",
	278	"${QUUX:-${FOO}}",
	279	"${FOO:+${BAR}}",
	280	"${QUUX:+${BAR}}",
	281	"${FOO:+\|${BAR}\|}}",
	282	"${FOO:+\|${BAR}{\|}",
c24eb49e LP	283	NULL
c24eb49e LP	284	};
1f28b2de	285	_cleanup_strv_free_ char **r = NULL;
c24eb49e LP	286
c24eb49e LP	287	r = replace_env_argv((char) line, (char) env);
9b5d6bd9 LP	288	assert_se(r);
	289	assert_se(streq(r[0], "FOO$FOO"));
	290	assert_se(streq(r[1], "FOO$FOOFOO"));
	291	assert_se(streq(r[2], "FOOBAR BAR$FOO"));
	292	assert_se(streq(r[3], "FOOBAR BAR"));
	293	assert_se(streq(r[4], "BAR BAR"));
	294	assert_se(streq(r[5], "BAR"));
	295	assert_se(streq(r[6], "BAR"));
	296	assert_se(streq(r[7], "BAR BARwaldo"));
	297	assert_se(streq(r[8], "${FOO"));
df553b58 MS	298	assert_se(streq(r[9], "FOO$BAR BAR"));
df553b58 MS	299	assert_se(streq(r[10], "$FOOBAR BAR"));
b82f58bf RS	300	assert_se(streq(r[11], "${FOO:-waldo}"));
	301	assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
	302	assert_se(streq(r[13], "${FOO:+waldo}"));
	303	assert_se(streq(r[14], "${QUUX:+waldo}"));
	304	assert_se(streq(r[15], "${FOO:+\|waldo\|}}"));
	305	assert_se(streq(r[16], "${FOO:+\|waldo{\|}"));
	306	assert_se(strv_length(r) == 17);
1f28b2de	307	}
a6ff950e	308
4f7452a8	309	TEST(env_clean) {
0b345642 ZJS	310	_cleanup_strv_free_ char **e = strv_new("FOOBAR=WALDO",
	311	"FOOBAR=WALDO",
	312	"FOOBAR",
	313	"F",
	314	"X=",
	315	"F=F",
	316	"=",
	317	"=F",
	318	"",
	319	"0000=000",
	320	"äöüß=abcd",
	321	"abcd=äöüß",
	322	"xyz\n=xyz",
	323	"xyz=xyz\n",
	324	"another=one",
b45c068d	325	"another=final one",
e1e8c60a	326	"CRLF=\r\n",
30927a24	327	"LESS_TERMCAP_mb=\x1b[01;31m",
b45c068d	328	"BASH_FUNC_foo%%=() { echo foo\n}");
9b5d6bd9 LP	329	assert_se(e);
	330	assert_se(!strv_env_is_valid(e));
	331	assert_se(strv_env_clean(e) == e);
	332	assert_se(strv_env_is_valid(e));
4d1a6904 LP	333
	334	assert_se(streq(e[0], "FOOBAR=WALDO"));
	335	assert_se(streq(e[1], "X="));
	336	assert_se(streq(e[2], "F=F"));
ff461576 ZJS	337	assert_se(streq(e[3], "abcd=äöüß"));
	338	assert_se(streq(e[4], "xyz=xyz\n"));
	339	assert_se(streq(e[5], "another=final one"));
30927a24 ZJS	340	assert_se(streq(e[6], "CRLF=\r\n"));
	341	assert_se(streq(e[7], "LESS_TERMCAP_mb=\x1b[01;31m"));
	342	assert_se(e[8] == NULL);
4d1a6904 LP	343	}
4d1a6904 LP	344
4f7452a8	345	TEST(env_name_is_valid) {
8354c34e TA	346	assert_se(env_name_is_valid("test"));
	347
	348	assert_se(!env_name_is_valid(NULL));
	349	assert_se(!env_name_is_valid(""));
b8c83cfc ZJS	350	assert_se(!env_name_is_valid("xxx\a"));
	351	assert_se(!env_name_is_valid("xxx\007b"));
	352	assert_se(!env_name_is_valid("\007\009"));
ff461576	353	assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
8354c34e TA	354	assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
	355	}
	356
4f7452a8	357	TEST(env_value_is_valid) {
b8c83cfc ZJS	358	assert_se(env_value_is_valid(""));
	359	assert_se(env_value_is_valid("głąb kapuściany"));
	360	assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
b4346b9a FB	361	assert_se(env_value_is_valid("tab\tcharacter"));
b4346b9a FB	362	assert_se(env_value_is_valid("new\nline"));
30927a24 ZJS	363	assert_se(env_value_is_valid("Show this?\rNope. Show that!"));
	364	assert_se(env_value_is_valid("new DOS\r\nline"));
	365
	366	assert_se(!env_value_is_valid("\xc5")); /* A truncated utf-8-encoded "ł".
	367	* We currently disallow that. */
b8c83cfc ZJS	368	}
b8c83cfc ZJS	369
4f7452a8	370	TEST(env_assignment_is_valid) {
b8c83cfc ZJS	371	assert_se(env_assignment_is_valid("a="));
	372	assert_se(env_assignment_is_valid("b=głąb kapuściany"));
	373	assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
	374	assert_se(env_assignment_is_valid("e=printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
b4346b9a FB	375	assert_se(env_assignment_is_valid("f=tab\tcharacter"));
b4346b9a FB	376	assert_se(env_assignment_is_valid("g=new\nline"));
b8c83cfc ZJS	377
	378	assert_se(!env_assignment_is_valid("="));
	379	assert_se(!env_assignment_is_valid("a b="));
	380	assert_se(!env_assignment_is_valid("a ="));
	381	assert_se(!env_assignment_is_valid(" b="));
ff461576 ZJS	382	/* no dots or dashes: http://tldp.org/LDP/abs/html/gotchas.html */
	383	assert_se(!env_assignment_is_valid("a.b="));
	384	assert_se(!env_assignment_is_valid("a-b="));
b8c83cfc ZJS	385	assert_se(!env_assignment_is_valid("\007=głąb kapuściany"));
	386	assert_se(!env_assignment_is_valid("c\009=\007\009\011"));
	387	assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
	388	}
	389
4f7452a8	390	TEST(putenv_dup) {
fa256f43	391	assert_se(putenv_dup("A=a1", true) == 0);
05576809	392	assert_se(streq_ptr(getenv("A"), "a1"));
fa256f43	393	assert_se(putenv_dup("A=a1", true) == 0);
05576809	394	assert_se(streq_ptr(getenv("A"), "a1"));
fa256f43	395	assert_se(putenv_dup("A=a2", false) == 0);
05576809	396	assert_se(streq_ptr(getenv("A"), "a1"));
fa256f43	397	assert_se(putenv_dup("A=a2", true) == 0);
05576809	398	assert_se(streq_ptr(getenv("A"), "a2"));
fa256f43 ZJS	399	}
fa256f43 ZJS	400
4f7452a8	401	TEST(setenv_systemd_exec_pid) {
cfd1c6e2 YW	402	_cleanup_free_ char *saved = NULL;
	403	const char *e;
	404	pid_t p;
	405
cfd1c6e2 YW	406	e = getenv("SYSTEMD_EXEC_PID");
	407	if (e)
	408	assert_se(saved = strdup(e));
	409
	410	assert_se(unsetenv("SYSTEMD_EXEC_PID") >= 0);
	411	assert_se(setenv_systemd_exec_pid(true) == 0);
	412	assert_se(!getenv("SYSTEMD_EXEC_PID"));
	413
	414	assert_se(setenv("SYSTEMD_EXEC_PID", "*", 1) >= 0);
	415	assert_se(setenv_systemd_exec_pid(true) == 0);
	416	assert_se(e = getenv("SYSTEMD_EXEC_PID"));
	417	assert_se(streq(e, "*"));
	418
	419	assert_se(setenv("SYSTEMD_EXEC_PID", "123abc", 1) >= 0);
	420	assert_se(setenv_systemd_exec_pid(true) == 1);
	421	assert_se(e = getenv("SYSTEMD_EXEC_PID"));
	422	assert_se(parse_pid(e, &p) >= 0);
	423	assert_se(p == getpid_cached());
	424
	425	assert_se(unsetenv("SYSTEMD_EXEC_PID") >= 0);
	426	assert_se(setenv_systemd_exec_pid(false) == 1);
	427	assert_se(e = getenv("SYSTEMD_EXEC_PID"));
	428	assert_se(parse_pid(e, &p) >= 0);
	429	assert_se(p == getpid_cached());
	430
	431	assert_se(set_unset_env("SYSTEMD_EXEC_PID", saved, 1) >= 0);
	432	}
	433
e99ca147	434	TEST(getenv_steal_erase) {
7a6abbe9 LP	435	int r;
7a6abbe9 LP	436
e99ca147	437	r = safe_fork("(sd-getenvstealerase)", FORK_DEATHSIG\|FORK_LOG\|FORK_WAIT, NULL);
7a6abbe9 LP	438	if (r == 0) {
7a6abbe9 LP	439	_cleanup_strv_free_ char **l = NULL;
7a6abbe9 LP	440
	441	/* child */
	442
e99ca147	443	assert_se(getenv_steal_erase("thisenvvardefinitelywontexist", NULL) == 0);
7a6abbe9 LP	444
	445	l = strv_new("FOO=BAR", "QUUX=PIFF", "ONE=TWO", "A=B");
	446	assert_se(strv_length(l) == 4);
	447
	448	environ = l;
	449
	450	STRV_FOREACH(e, environ) {
e99ca147	451	_cleanup_free_ char n = NULL, copy1 = NULL, *copy2 = NULL;
7a6abbe9 LP	452	char *eq;
	453
	454	eq = strchr(*e, '=');
	455	if (!eq)
	456	continue;
	457
	458	n = strndup(e, eq - e);
	459	assert_se(n);
	460
e99ca147 LP	461	copy1 = strdup(eq + 1);
	462	assert_se(copy1);
	463
	464	assert_se(streq_ptr(getenv(n), copy1));
7a6abbe9	465	assert_se(getenv(n) == eq + 1);
e99ca147 LP	466	assert_se(getenv_steal_erase(n, &copy2) > 0);
e99ca147 LP	467	assert_se(streq_ptr(copy1, copy2));
7a6abbe9 LP	468	assert_se(isempty(eq + 1));
	469	assert_se(!getenv(n));
	470	}
	471
	472	environ = NULL;
	473	l = strv_free(l);
	474
	475	_exit(EXIT_SUCCESS);
	476	}
	477
	478	assert_se(r > 0);
	479	}
	480
6cc19afa	481	TEST(strv_env_name_is_valid) {
fd762319 T	482	assert_se(strv_env_name_is_valid(STRV_MAKE("HOME", "USER", "SHELL", "PATH")));
	483	assert_se(!strv_env_name_is_valid(STRV_MAKE("", "PATH", "home", "user", "SHELL")));
	484	assert_se(!strv_env_name_is_valid(STRV_MAKE("HOME", "USER", "SHELL", "USER")));
6cc19afa	485	}
6cc19afa	486
4f7452a8	487	DEFINE_TEST_MAIN(LOG_DEBUG);