11a1589223
Files which are installed as-is (any .service and other unit files, .conf files, .policy files, etc), are left as is. My assumption is that SPDX identifiers are not yet that well known, so it's better to retain the extended header to avoid any doubt. I also kept any copyright lines. We can probably remove them, but it'd nice to obtain explicit acks from all involved authors before doing that.
388 lines
13 KiB
C
388 lines
13 KiB
C
/* SPDX-License-Identifier: LGPL-2.1+ */
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2010 Lennart Poettering
|
|
Copyright 2016 Zbigniew Jędrzejewski-Szmek
|
|
***/
|
|
|
|
#include <string.h>
|
|
|
|
#include "env-util.h"
|
|
#include "fd-util.h"
|
|
#include "fileio.h"
|
|
#include "string-util.h"
|
|
#include "strv.h"
|
|
#include "util.h"
|
|
|
|
static void test_strv_env_delete(void) {
|
|
_cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
|
|
|
|
a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", NULL);
|
|
assert_se(a);
|
|
|
|
b = strv_new("PIEP", "FOO", NULL);
|
|
assert_se(b);
|
|
|
|
c = strv_new("SCHLUMPF", NULL);
|
|
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);
|
|
}
|
|
|
|
static void test_strv_env_get(void) {
|
|
char **l;
|
|
|
|
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"));
|
|
}
|
|
|
|
static void test_strv_env_unset(void) {
|
|
_cleanup_strv_free_ char **l = NULL;
|
|
|
|
l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES", NULL);
|
|
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);
|
|
}
|
|
|
|
static void test_strv_env_set(void) {
|
|
_cleanup_strv_free_ char **l = NULL, **r = NULL;
|
|
|
|
l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES", NULL);
|
|
assert_se(l);
|
|
|
|
r = strv_env_set(l, "WALDO=WALDO");
|
|
assert_se(r);
|
|
|
|
assert_se(streq(r[0], "PIEP"));
|
|
assert_se(streq(r[1], "SCHLUMPF=SMURFF"));
|
|
assert_se(streq(r[2], "NANANANA=YES"));
|
|
assert_se(streq(r[3], "WALDO=WALDO"));
|
|
assert_se(strv_length(r) == 4);
|
|
}
|
|
|
|
static void test_strv_env_merge(void) {
|
|
_cleanup_strv_free_ char **a = NULL, **b = NULL, **r = NULL;
|
|
|
|
a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", NULL);
|
|
assert_se(a);
|
|
|
|
b = strv_new("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES", NULL);
|
|
assert_se(b);
|
|
|
|
r = strv_env_merge(2, a, b);
|
|
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], "PIEP="));
|
|
assert_se(streq(r[5], "NANANANA=YES"));
|
|
assert_se(strv_length(r) == 6);
|
|
|
|
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], "PIEP="));
|
|
assert_se(streq(r[4], "NANANANA=YES"));
|
|
assert_se(strv_length(r) == 5);
|
|
}
|
|
|
|
static void test_env_strv_get_n(void) {
|
|
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(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
|
|
getenv("PATH")));
|
|
assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
|
|
getenv("PATH")));
|
|
}
|
|
|
|
static void test_replace_env(bool 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) {
|
|
const char *env[] = {
|
|
"FOO=foo",
|
|
"BAR=bar",
|
|
NULL
|
|
};
|
|
_cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL, *x = 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}"));
|
|
}
|
|
|
|
static void test_replace_env_argv(void) {
|
|
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);
|
|
}
|
|
|
|
static void test_env_clean(void) {
|
|
_cleanup_strv_free_ char **e;
|
|
|
|
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",
|
|
NULL);
|
|
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(e[6] == NULL);
|
|
}
|
|
|
|
static void test_env_name_is_valid(void) {
|
|
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"));
|
|
}
|
|
|
|
static void test_env_value_is_valid(void) {
|
|
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"));
|
|
}
|
|
|
|
static void test_env_assignment_is_valid(void) {
|
|
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>\""));
|
|
}
|
|
|
|
static void test_deserialize_environment(void) {
|
|
_cleanup_strv_free_ char **env = strv_new("A=1", NULL);
|
|
|
|
assert_se(deserialize_environment(&env, "env=B=2") >= 0);
|
|
assert_se(deserialize_environment(&env, "env=FOO%%=a\\177b\\nc\\td e") >= 0);
|
|
|
|
assert_se(strv_equal(env, STRV_MAKE("A=1", "B=2", "FOO%%=a\177b\nc\td e")));
|
|
|
|
assert_se(deserialize_environment(&env, "env=foo\\") < 0);
|
|
assert_se(deserialize_environment(&env, "env=bar\\_baz") < 0);
|
|
}
|
|
|
|
static void test_serialize_environment(void) {
|
|
char fn[] = "/tmp/test-env-util.XXXXXXX";
|
|
int fd, r;
|
|
_cleanup_fclose_ FILE *f = NULL;
|
|
|
|
_cleanup_strv_free_ char **env = strv_new("A=1",
|
|
"B=2",
|
|
"C=ąęółń",
|
|
"D=D=a\\x0Ab",
|
|
"FOO%%=a\177b\nc\td e",
|
|
NULL);
|
|
_cleanup_strv_free_ char **env2 = NULL;
|
|
|
|
fd = mkostemp_safe(fn);
|
|
assert_se(fd >= 0);
|
|
|
|
assert_se(f = fdopen(fd, "r+"));
|
|
|
|
assert_se(serialize_environment(f, env) == 0);
|
|
assert_se(fflush_and_check(f) == 0);
|
|
|
|
rewind(f);
|
|
|
|
for (;;) {
|
|
char line[LINE_MAX];
|
|
const char *l;
|
|
|
|
if (!fgets(line, sizeof line, f))
|
|
break;
|
|
|
|
char_array_0(line);
|
|
l = strstrip(line);
|
|
|
|
r = deserialize_environment(&env2, l);
|
|
assert_se(r == 1);
|
|
}
|
|
assert_se(feof(f));
|
|
|
|
assert_se(strv_equal(env, env2));
|
|
|
|
unlink(fn);
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
test_strv_env_delete();
|
|
test_strv_env_get();
|
|
test_strv_env_unset();
|
|
test_strv_env_set();
|
|
test_strv_env_merge();
|
|
test_env_strv_get_n();
|
|
test_replace_env(false);
|
|
test_replace_env(true);
|
|
test_replace_env2(false);
|
|
test_replace_env2(true);
|
|
test_replace_env_argv();
|
|
test_env_clean();
|
|
test_env_name_is_valid();
|
|
test_env_value_is_valid();
|
|
test_env_assignment_is_valid();
|
|
test_deserialize_environment();
|
|
test_serialize_environment();
|
|
|
|
return 0;
|
|
}
|