src/test/test-env-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "env-util.h"
   4 #include "fd-util.h"
   5 #include "fileio.h"
   6 #include "fs-util.h"
   7 #include "parse-util.h"
   8 #include "process-util.h"
   9 #include "serialize.h"
  10 #include "string-util.h"
  11 #include "strv.h"
  12 #include "tests.h"
  13
  14 TEST(strv_env_delete) {
  15         _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
  16
  17         a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
  18         assert_se(a);
  19
  20         b = strv_new("PIEP", "FOO");
  21         assert_se(b);
  22
  23         c = strv_new("SCHLUMPF");
  24         assert_se(c);
  25
  26         d = strv_env_delete(a, 2, b, c);
  27         assert_se(d);
  28
  29         assert_se(streq(d[0], "WALDO=WALDO"));
  30         assert_se(streq(d[1], "WALDO="));
  31         assert_se(strv_length(d) == 2);
  32 }
  33
  34 TEST(strv_env_get) {
  35         char **l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");
  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
  42 TEST(strv_env_pairs_get) {
  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
  51 TEST(strv_env_unset) {
  52         _cleanup_strv_free_ char **l = NULL;
  53
  54         l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
  55         assert_se(l);
  56
  57         assert_se(strv_env_unset(l, "SCHLUMPF") == l);
  58
  59         assert_se(streq(l[0], "PIEP"));
  60         assert_se(streq(l[1], "NANANANA=YES"));
  61         assert_se(strv_length(l) == 2);
  62 }
  63
  64 TEST(strv_env_merge) {
  65         char **a = STRV_MAKE("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF", "EQ===");
  66         char **b = STRV_MAKE("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");
  67
  68         _cleanup_strv_free_ char **r = strv_env_merge(NULL, a, NULL, b, NULL, a, b, b, NULL);
  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"));
  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);
  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"));
  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);
  87 }
  88
  89 TEST(strv_env_replace_strdup) {
  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);
  95         assert_se(strv_env_replace_strdup(&a, "c") == -EINVAL);
  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
 103 TEST(strv_env_replace_strdup_passthrough) {
 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
 122 TEST(strv_env_assign) {
 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
 136 TEST(strv_env_assignf) {
 137         _cleanup_strv_free_ char **a = NULL;
 138
 139         assert_se(strv_env_assignf(&a, "a", "a") > 0);
 140         assert_se(strv_env_assignf(&a, "a", "%c", 'a') == 0);
 141
 142         assert_se(strv_env_assignf(&a, "c", "xxx%iyyy", 5) > 0);
 143         assert_se(strv_length(a) == 2);
 144         assert_se(strv_equal(a, STRV_MAKE("a=a", "c=xxx5yyy")));
 145         assert_se(strv_env_assignf(&a, "c", NULL) == 0);
 146
 147         assert_se(strv_env_assignf(&a, "b", "b") > 0);
 148         assert_se(strv_env_assignf(&a, "a", "A") == 0);
 149         assert_se(strv_env_assignf(&a, "b", NULL) == 0);
 150
 151         assert_se(strv_env_assignf(&a, "a=", "B") == -EINVAL);
 152
 153         assert_se(strv_length(a) == 1);
 154         assert_se(streq(a[0], "a=A"));
 155 }
 156
 157 TEST(strv_env_assign_many) {
 158         _cleanup_strv_free_ char **a = NULL;
 159
 160         assert_se(strv_env_assign_many(&a, "a", "a", "b", "b") >= 0);
 161
 162         assert_se(strv_length(a) == 2);
 163         assert_se(strv_contains(a, "a=a"));
 164         assert_se(strv_contains(a, "b=b"));
 165
 166         assert_se(strv_env_assign_many(&a, "a", "A", "b", "b", "c", "c") >= 0);
 167         assert_se(strv_length(a) == 3);
 168         assert_se(strv_contains(a, "a=A"));
 169         assert_se(strv_contains(a, "b=b"));
 170         assert_se(strv_contains(a, "c=c"));
 171
 172         assert_se(strv_env_assign_many(&a, "b", NULL, "c", "C") >= 0);
 173         assert_se(strv_length(a) == 2);
 174         assert_se(strv_contains(a, "a=A"));
 175         assert_se(strv_contains(a, "c=C"));
 176
 177         assert_se(strv_env_assign_many(&a, "a=", "B") == -EINVAL);
 178         assert_se(strv_length(a) == 2);
 179         assert_se(strv_contains(a, "a=A"));
 180         assert_se(strv_contains(a, "c=C"));
 181 }
 182
 183 TEST(env_strv_get_n) {
 184         const char *_env[] = {
 185                 "FOO=NO NO NO",
 186                 "FOO=BAR BAR",
 187                 "BAR=waldo",
 188                 "PATH=unset",
 189                 NULL
 190         };
 191         char **env = (char**) _env;
 192
 193         assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
 194         assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
 195         assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
 196         assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
 197
 198         assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
 199         assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
 200         assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
 201         assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
 202
 203         env[3] = NULL; /* kill our $PATH */
 204
 205         assert_se(!strv_env_get_n(env, "PATH__", 4, 0));
 206         assert_se(!strv_env_get_n(env, "PATH", 4, 0));
 207         assert_se(streq_ptr(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
 208                             getenv("PATH")));
 209         assert_se(streq_ptr(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
 210                             getenv("PATH")));
 211 }
 212
 213 static void test_replace_env1(bool braceless) {
 214         log_info("/* %s(braceless=%s) */", __func__, yes_no(braceless));
 215
 216         const char *env[] = {
 217                 "FOO=BAR BAR",
 218                 "BAR=waldo",
 219                 NULL
 220         };
 221         _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL;
 222         unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;
 223
 224         assert_se(replace_env("FOO=$FOO=${FOO}", (char**) env, flags, &t) >= 0);
 225         assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));
 226
 227         assert_se(replace_env("BAR=$BAR=${BAR}", (char**) env, flags, &s) >= 0);
 228         assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));
 229
 230         assert_se(replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags, &q) >= 0);
 231         assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));
 232
 233         assert_se(replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags, &r) >= 0);
 234         assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));
 235
 236         assert_se(replace_env("${BAR}$BAR$BAR", (char**) env, flags, &p) >= 0);
 237         assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
 238 }
 239
 240 static void test_replace_env2(bool extended) {
 241         log_info("/* %s(extended=%s) */", __func__, yes_no(extended));
 242
 243         const char *env[] = {
 244                 "FOO=foo",
 245                 "BAR=bar",
 246                 NULL
 247         };
 248         _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL, *x = NULL, *y = NULL;
 249         unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;
 250
 251         assert_se(replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags, &t) >= 0);
 252         assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));
 253
 254         assert_se(replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags, &s) >= 0);
 255         assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));
 256
 257         assert_se(replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags, &q) >= 0);
 258         assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));
 259
 260         assert_se(replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags, &r) >= 0);
 261         assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));
 262
 263         assert_se(replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags, &p) >= 0);
 264         assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));
 265
 266         assert_se(replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags, &x) >= 0);
 267         assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
 268
 269         assert_se(replace_env("FOO=${FOO}between${BAR:-baz}", (char**) env, flags, &y) >= 0);
 270         assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"));
 271 }
 272
 273 TEST(replace_env) {
 274         test_replace_env1(false);
 275         test_replace_env1(true);
 276         test_replace_env2(false);
 277         test_replace_env2(true);
 278 }
 279
 280 TEST(replace_env_argv) {
 281         const char *env[] = {
 282                 "FOO=BAR BAR",
 283                 "BAR=waldo",
 284                 NULL
 285         };
 286         const char *line[] = {
 287                 "FOO$FOO",
 288                 "FOO$FOOFOO",
 289                 "FOO${FOO}$FOO",
 290                 "FOO${FOO}",
 291                 "${FOO}",
 292                 "$FOO",
 293                 "$FOO$FOO",
 294                 "${FOO}${BAR}",
 295                 "${FOO",
 296                 "FOO$$${FOO}",
 297                 "$$FOO${FOO}",
 298                 "${FOO:-${BAR}}",
 299                 "${QUUX:-${FOO}}",
 300                 "${FOO:+${BAR}}",
 301                 "${QUUX:+${BAR}}",
 302                 "${FOO:+|${BAR}|}}",
 303                 "${FOO:+|${BAR}{|}",
 304                 NULL
 305         };
 306         _cleanup_strv_free_ char **r = NULL;
 307
 308         assert_se(replace_env_argv((char**) line, (char**) env, &r, NULL, NULL) >= 0);
 309         assert_se(r);
 310         assert_se(streq(r[0], "FOO$FOO"));
 311         assert_se(streq(r[1], "FOO$FOOFOO"));
 312         assert_se(streq(r[2], "FOOBAR BAR$FOO"));
 313         assert_se(streq(r[3], "FOOBAR BAR"));
 314         assert_se(streq(r[4], "BAR BAR"));
 315         assert_se(streq(r[5], "BAR"));
 316         assert_se(streq(r[6], "BAR"));
 317         assert_se(streq(r[7], "BAR BARwaldo"));
 318         assert_se(streq(r[8], "${FOO"));
 319         assert_se(streq(r[9], "FOO$BAR BAR"));
 320         assert_se(streq(r[10], "$FOOBAR BAR"));
 321         assert_se(streq(r[11], "${FOO:-waldo}"));
 322         assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
 323         assert_se(streq(r[13], "${FOO:+waldo}"));
 324         assert_se(streq(r[14], "${QUUX:+waldo}"));
 325         assert_se(streq(r[15], "${FOO:+|waldo|}}"));
 326         assert_se(streq(r[16], "${FOO:+|waldo{|}"));
 327         assert_se(strv_length(r) == 17);
 328 }
 329
 330 TEST(replace_env_argv_bad) {
 331
 332         const char *env[] = {
 333                 "FOO=BAR BAR",
 334                 "BAR=waldo",
 335                 NULL
 336         };
 337
 338         const char *line[] = {
 339                 "$FOO",
 340                 "A${FOO}B",
 341                 "a${~}${%}b",
 342                 "x${}y",
 343                 "$UNSET2",
 344                 "z${UNSET3}z${UNSET1}z",
 345                 "piff${UNSET2}piff",
 346                 NULL
 347         };
 348
 349         _cleanup_strv_free_ char **bad = NULL, **unset = NULL, **replaced = NULL;
 350
 351         assert_se(replace_env_argv((char**) line, (char**) env, &replaced, &unset, &bad) >= 0);
 352
 353         assert_se(strv_equal(replaced, STRV_MAKE(
 354                                              "BAR",
 355                                              "BAR",
 356                                              "ABAR BARB",
 357                                              "ab",
 358                                              "xy",
 359                                              "zzz",
 360                                              "piffpiff")));
 361
 362         assert_se(strv_equal(unset, STRV_MAKE(
 363                                              "UNSET1",
 364                                              "UNSET2",
 365                                              "UNSET3")));
 366         assert_se(strv_equal(bad, STRV_MAKE("",
 367                                             "%",
 368                                             "~")));
 369 }
 370
 371 TEST(env_clean) {
 372         _cleanup_strv_free_ char **e = strv_new("FOOBAR=WALDO",
 373                                                 "FOOBAR=WALDO",
 374                                                 "FOOBAR",
 375                                                 "F",
 376                                                 "X=",
 377                                                 "F=F",
 378                                                 "=",
 379                                                 "=F",
 380                                                 "",
 381                                                 "0000=000",
 382                                                 "äöüß=abcd",
 383                                                 "abcd=äöüß",
 384                                                 "xyz\n=xyz",
 385                                                 "xyz=xyz\n",
 386                                                 "another=one",
 387                                                 "another=final one",
 388                                                 "CRLF=\r\n",
 389                                                 "LESS_TERMCAP_mb=\x1b[01;31m",
 390                                                 "BASH_FUNC_foo%%=() {  echo foo\n}");
 391         assert_se(e);
 392         assert_se(!strv_env_is_valid(e));
 393         assert_se(strv_env_clean(e) == e);
 394         assert_se(strv_env_is_valid(e));
 395
 396         assert_se(streq(e[0], "FOOBAR=WALDO"));
 397         assert_se(streq(e[1], "X="));
 398         assert_se(streq(e[2], "F=F"));
 399         assert_se(streq(e[3], "abcd=äöüß"));
 400         assert_se(streq(e[4], "xyz=xyz\n"));
 401         assert_se(streq(e[5], "another=final one"));
 402         assert_se(streq(e[6], "CRLF=\r\n"));
 403         assert_se(streq(e[7], "LESS_TERMCAP_mb=\x1b[01;31m"));
 404         assert_se(e[8] == NULL);
 405 }
 406
 407 TEST(env_name_is_valid) {
 408         assert_se(env_name_is_valid("test"));
 409
 410         assert_se(!env_name_is_valid(NULL));
 411         assert_se(!env_name_is_valid(""));
 412         assert_se(!env_name_is_valid("xxx\a"));
 413         assert_se(!env_name_is_valid("xxx\007b"));
 414         assert_se(!env_name_is_valid("\007\009"));
 415         assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
 416         assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
 417 }
 418
 419 TEST(env_value_is_valid) {
 420         assert_se(env_value_is_valid(""));
 421         assert_se(env_value_is_valid("głąb kapuściany"));
 422         assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
 423         assert_se(env_value_is_valid("tab\tcharacter"));
 424         assert_se(env_value_is_valid("new\nline"));
 425         assert_se(env_value_is_valid("Show this?\rNope. Show that!"));
 426         assert_se(env_value_is_valid("new DOS\r\nline"));
 427
 428         assert_se(!env_value_is_valid("\xc5")); /* A truncated utf-8-encoded "ł".
 429                                                  * We currently disallow that. */
 430 }
 431
 432 TEST(env_assignment_is_valid) {
 433         assert_se(env_assignment_is_valid("a="));
 434         assert_se(env_assignment_is_valid("b=głąb kapuściany"));
 435         assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
 436         assert_se(env_assignment_is_valid("e=printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
 437         assert_se(env_assignment_is_valid("f=tab\tcharacter"));
 438         assert_se(env_assignment_is_valid("g=new\nline"));
 439
 440         assert_se(!env_assignment_is_valid("="));
 441         assert_se(!env_assignment_is_valid("a b="));
 442         assert_se(!env_assignment_is_valid("a ="));
 443         assert_se(!env_assignment_is_valid(" b="));
 444         /* no dots or dashes: http://tldp.org/LDP/abs/html/gotchas.html */
 445         assert_se(!env_assignment_is_valid("a.b="));
 446         assert_se(!env_assignment_is_valid("a-b="));
 447         assert_se(!env_assignment_is_valid("\007=głąb kapuściany"));
 448         assert_se(!env_assignment_is_valid("c\009=\007\009\011"));
 449         assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
 450 }
 451
 452 TEST(putenv_dup) {
 453         assert_se(putenv_dup("A=a1", true) == 0);
 454         assert_se(streq_ptr(getenv("A"), "a1"));
 455         assert_se(putenv_dup("A=a1", true) == 0);
 456         assert_se(streq_ptr(getenv("A"), "a1"));
 457         assert_se(putenv_dup("A=a2", false) == 0);
 458         assert_se(streq_ptr(getenv("A"), "a1"));
 459         assert_se(putenv_dup("A=a2", true) == 0);
 460         assert_se(streq_ptr(getenv("A"), "a2"));
 461 }
 462
 463 TEST(setenv_systemd_exec_pid) {
 464         _cleanup_free_ char *saved = NULL;
 465         const char *e;
 466         pid_t p;
 467
 468         e = getenv("SYSTEMD_EXEC_PID");
 469         if (e)
 470                 assert_se(saved = strdup(e));
 471
 472         assert_se(unsetenv("SYSTEMD_EXEC_PID") >= 0);
 473         assert_se(setenv_systemd_exec_pid(true) == 0);
 474         assert_se(!getenv("SYSTEMD_EXEC_PID"));
 475
 476         assert_se(setenv("SYSTEMD_EXEC_PID", "*", 1) >= 0);
 477         assert_se(setenv_systemd_exec_pid(true) == 0);
 478         assert_se(e = getenv("SYSTEMD_EXEC_PID"));
 479         assert_se(streq(e, "*"));
 480
 481         assert_se(setenv("SYSTEMD_EXEC_PID", "123abc", 1) >= 0);
 482         assert_se(setenv_systemd_exec_pid(true) == 1);
 483         assert_se(e = getenv("SYSTEMD_EXEC_PID"));
 484         assert_se(parse_pid(e, &p) >= 0);
 485         assert_se(p == getpid_cached());
 486
 487         assert_se(unsetenv("SYSTEMD_EXEC_PID") >= 0);
 488         assert_se(setenv_systemd_exec_pid(false) == 1);
 489         assert_se(e = getenv("SYSTEMD_EXEC_PID"));
 490         assert_se(parse_pid(e, &p) >= 0);
 491         assert_se(p == getpid_cached());
 492
 493         assert_se(set_unset_env("SYSTEMD_EXEC_PID", saved, 1) >= 0);
 494 }
 495
 496 TEST(getenv_steal_erase) {
 497         int r;
 498
 499         r = safe_fork("(sd-getenvstealerase)", FORK_DEATHSIG_SIGTERM|FORK_LOG|FORK_WAIT, NULL);
 500         if (r == 0) {
 501                 _cleanup_strv_free_ char **l = NULL;
 502
 503                 /* child */
 504
 505                 assert_se(getenv_steal_erase("thisenvvardefinitelywontexist", NULL) == 0);
 506
 507                 l = strv_new("FOO=BAR", "QUUX=PIFF", "ONE=TWO", "A=B");
 508                 assert_se(strv_length(l) == 4);
 509
 510                 environ = l;
 511
 512                 STRV_FOREACH(e, environ) {
 513                         _cleanup_free_ char *n = NULL, *copy1 = NULL, *copy2 = NULL;
 514                         char *eq;
 515
 516                         eq = strchr(*e, '=');
 517                         if (!eq)
 518                                 continue;
 519
 520                         n = strndup(*e, eq - *e);
 521                         assert_se(n);
 522
 523                         copy1 = strdup(eq + 1);
 524                         assert_se(copy1);
 525
 526                         assert_se(streq_ptr(getenv(n), copy1));
 527                         assert_se(getenv(n) == eq + 1);
 528                         assert_se(getenv_steal_erase(n, &copy2) > 0);
 529                         assert_se(streq_ptr(copy1, copy2));
 530                         assert_se(isempty(eq + 1));
 531                         assert_se(!getenv(n));
 532                 }
 533
 534                 environ = NULL;
 535                 l = strv_free(l);
 536
 537                 _exit(EXIT_SUCCESS);
 538         }
 539
 540         assert_se(r > 0);
 541 }
 542
 543 TEST(strv_env_name_is_valid) {
 544         assert_se(strv_env_name_is_valid(STRV_MAKE("HOME", "USER", "SHELL", "PATH")));
 545         assert_se(!strv_env_name_is_valid(STRV_MAKE("", "PATH", "home", "user", "SHELL")));
 546         assert_se(!strv_env_name_is_valid(STRV_MAKE("HOME", "USER", "SHELL", "USER")));
 547 }
 548
 549 TEST(getenv_path_list) {
 550         _cleanup_strv_free_ char **path_list = NULL;
 551
 552         /* Empty paths */
 553         FOREACH_STRING(s, "", ":", ":::::", " : ::: :: :") {
 554                 assert_se(setenv("TEST_GETENV_PATH_LIST", s, 1) >= 0);
 555                 assert_se(getenv_path_list("TEST_GETENV_PATH_LIST", &path_list) == -EINVAL);
 556                 assert_se(!path_list);
 557         }
 558
 559         /* Invalid paths */
 560         FOREACH_STRING(s, ".", "..", "/../", "/", "/foo/bar/baz/../foo", "foo/bar/baz") {
 561                 assert_se(setenv("TEST_GETENV_PATH_LIST", s, 1) >= 0);
 562                 assert_se(getenv_path_list("TEST_GETENV_PATH_LIST", &path_list) == -EINVAL);
 563                 assert_se(!path_list);
 564         }
 565
 566         /* Valid paths mixed with invalid ones */
 567         assert_se(setenv("TEST_GETENV_PATH_LIST", "/foo:/bar/baz:/../:/hello", 1) >= 0);
 568         assert_se(getenv_path_list("TEST_GETENV_PATH_LIST", &path_list) == -EINVAL);
 569         assert_se(!path_list);
 570
 571         /* Finally some valid paths */
 572         assert_se(setenv("TEST_GETENV_PATH_LIST", "/foo:/bar/baz:/hello/world:/path with spaces:/final", 1) >= 0);
 573         assert_se(getenv_path_list("TEST_GETENV_PATH_LIST", &path_list) >= 0);
 574         assert_se(streq(path_list[0], "/foo"));
 575         assert_se(streq(path_list[1], "/bar/baz"));
 576         assert_se(streq(path_list[2], "/hello/world"));
 577         assert_se(streq(path_list[3], "/path with spaces"));
 578         assert_se(streq(path_list[4], "/final"));
 579         assert_se(path_list[5] == NULL);
 580
 581         assert_se(unsetenv("TEST_GETENV_PATH_LIST") >= 0);
 582 }
 583
 584 DEFINE_TEST_MAIN(LOG_DEBUG);