]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/test/test-env-util.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #30550 from yuwata/network-nexthop-cleanups-3
[thirdparty/systemd.git] / src / test / test-env-util.c
CommitLineData
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"
5#include "fileio.h"
75e7d50e 6#include "fs-util.h"
cfd1c6e2
YW		 7#include "parse-util.h"
8#include "process-util.h"
d68c645b 9#include "serialize.h"
07630cea
LP		 10#include "string-util.h"
11#include "strv.h"
2824374f 12#include "tests.h"
c24eb49e 13
4f7452a8 14TEST(strv_env_delete) {
940bd473
TA		 15 _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
16
bea1a013 17 a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
9b5d6bd9
LP		 18 assert_se(a);
19
bea1a013 20 b = strv_new("PIEP", "FOO");
9b5d6bd9
LP		 21 assert_se(b);
22
bea1a013 23 c = strv_new("SCHLUMPF");
9b5d6bd9 24 assert_se(c);
940bd473
TA		 25
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}
33
4f7452a8 34TEST(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 42TEST(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 51TEST(strv_env_unset) {
940bd473
TA		 52 _cleanup_strv_free_ char **l = NULL;
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}
63
4f7452a8 64TEST(strv_env_merge) {
43cadb64
ZJS		 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");
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}
88
4f7452a8 89TEST(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 103TEST(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 122TEST(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
20f8b345
LP		 136TEST(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
40975963
YW		 157TEST(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
4f7452a8 183TEST(env_strv_get_n) {
37f3ffca
RS		 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));
1890c538
ZJS		 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")));
37f3ffca
RS		 211}
212
4f7452a8 213static void test_replace_env1(bool braceless) {
0b345642
ZJS		 214 log_info("/* %s(braceless=%s) */", __func__, yes_no(braceless));
215
ccad1fd0
ZJS		 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
f331434d 224 assert_se(replace_env("FOO=$FOO=${FOO}", (char**) env, flags, &t) >= 0);
ccad1fd0
ZJS		 225 assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));
226
f331434d 227 assert_se(replace_env("BAR=$BAR=${BAR}", (char**) env, flags, &s) >= 0);
ccad1fd0
ZJS		 228 assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));
229
f331434d 230 assert_se(replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags, &q) >= 0);
ccad1fd0
ZJS		 231 assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));
232
f331434d 233 assert_se(replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags, &r) >= 0);
a93236aa 234 assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));
ccad1fd0 235
f331434d 236 assert_se(replace_env("${BAR}$BAR$BAR", (char**) env, flags, &p) >= 0);
ccad1fd0
ZJS		 237 assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
238}
239
f50ce8fc 240static void test_replace_env2(bool extended) {
0b345642
ZJS		 241 log_info("/* %s(extended=%s) */", __func__, yes_no(extended));
242
f50ce8fc
ZJS		 243 const char *env[] = {
244 "FOO=foo",
245 "BAR=bar",
246 NULL
247 };
5ef97a71 248 _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL, *x = NULL, *y = NULL;
f50ce8fc
ZJS		 249 unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;
250
f331434d 251 assert_se(replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags, &t) >= 0);
f50ce8fc
ZJS		 252 assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));
253
f331434d 254 assert_se(replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags, &s) >= 0);
f50ce8fc
ZJS		 255 assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));
256
f331434d 257 assert_se(replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags, &q) >= 0);
f50ce8fc
ZJS		 258 assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));
259
f331434d 260 assert_se(replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags, &r) >= 0);
f50ce8fc
ZJS		 261 assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));
262
f331434d 263 assert_se(replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags, &p) >= 0);
f50ce8fc
ZJS		 264 assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));
265
f331434d 266 assert_se(replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags, &x) >= 0);
f50ce8fc 267 assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
5ef97a71 268
f331434d 269 assert_se(replace_env("FOO=${FOO}between${BAR:-baz}", (char**) env, flags, &y) >= 0);
5ef97a71 270 assert_se(streq(y, extended ? "FOO=foobetweenbar" : "FOO=foobetween${BAR:-baz}"));
f50ce8fc
ZJS		 271}
272
4f7452a8
JJ		 273TEST(replace_env) {
274 test_replace_env1(false);
275 test_replace_env1(true);
276 test_replace_env2(false);
277 test_replace_env2(true);
278}
0b345642 279
4f7452a8 280TEST(replace_env_argv) {
c24eb49e
LP		 281 const char *env[] = {
282 "FOO=BAR BAR",
283 "BAR=waldo",
284 NULL
285 };
c24eb49e
LP		 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",
df553b58
MS		 296 "FOO$$${FOO}",
297 "$$FOO${FOO}",
b82f58bf
RS		 298 "${FOO:-${BAR}}",
299 "${QUUX:-${FOO}}",
300 "${FOO:+${BAR}}",
301 "${QUUX:+${BAR}}",
302 "${FOO:+|${BAR}|}}",
303 "${FOO:+|${BAR}{|}",
c24eb49e
LP		 304 NULL
305 };
1f28b2de 306 _cleanup_strv_free_ char **r = NULL;
c24eb49e 307
f331434d 308 assert_se(replace_env_argv((char**) line, (char**) env, &r, NULL, NULL) >= 0);
9b5d6bd9
LP		 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"));
df553b58
MS		 319 assert_se(streq(r[9], "FOO$BAR BAR"));
320 assert_se(streq(r[10], "$FOOBAR BAR"));
b82f58bf
RS		 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);
1f28b2de 328}
a6ff950e 329
f331434d
LP		 330TEST(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
4f7452a8 371TEST(env_clean) {
0b345642
ZJS		 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",
b45c068d 387 "another=final one",
e1e8c60a 388 "CRLF=\r\n",
30927a24 389 "LESS_TERMCAP_mb=\x1b[01;31m",
b45c068d 390 "BASH_FUNC_foo%%=() { echo foo\n}");
9b5d6bd9
LP		 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));
4d1a6904
LP		 395
396 assert_se(streq(e[0], "FOOBAR=WALDO"));
397 assert_se(streq(e[1], "X="));
398 assert_se(streq(e[2], "F=F"));
ff461576
ZJS		 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"));
30927a24
ZJS		 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);
4d1a6904
LP		 405}
406
4f7452a8 407TEST(env_name_is_valid) {
8354c34e
TA		 408 assert_se(env_name_is_valid("test"));
409
410 assert_se(!env_name_is_valid(NULL));
411 assert_se(!env_name_is_valid(""));
b8c83cfc
ZJS		 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"));
ff461576 415 assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
8354c34e
TA		 416 assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
417}
418
4f7452a8 419TEST(env_value_is_valid) {
b8c83cfc
ZJS		 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>\""));
b4346b9a
FB		 423 assert_se(env_value_is_valid("tab\tcharacter"));
424 assert_se(env_value_is_valid("new\nline"));
30927a24
ZJS		 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. */
b8c83cfc
ZJS		 430}
431
4f7452a8 432TEST(env_assignment_is_valid) {
b8c83cfc
ZJS		 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>\""));
b4346b9a
FB		 437 assert_se(env_assignment_is_valid("f=tab\tcharacter"));
438 assert_se(env_assignment_is_valid("g=new\nline"));
b8c83cfc
ZJS		 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="));
ff461576
ZJS		 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="));
b8c83cfc
ZJS		 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
4f7452a8 452TEST(putenv_dup) {
fa256f43 453 assert_se(putenv_dup("A=a1", true) == 0);
05576809 454 assert_se(streq_ptr(getenv("A"), "a1"));
fa256f43 455 assert_se(putenv_dup("A=a1", true) == 0);
05576809 456 assert_se(streq_ptr(getenv("A"), "a1"));
fa256f43 457 assert_se(putenv_dup("A=a2", false) == 0);
05576809 458 assert_se(streq_ptr(getenv("A"), "a1"));
fa256f43 459 assert_se(putenv_dup("A=a2", true) == 0);
05576809 460 assert_se(streq_ptr(getenv("A"), "a2"));
fa256f43
ZJS		 461}
462
4f7452a8 463TEST(setenv_systemd_exec_pid) {
cfd1c6e2
YW		 464 _cleanup_free_ char *saved = NULL;
465 const char *e;
466 pid_t p;
467
cfd1c6e2
YW		 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
e99ca147 496TEST(getenv_steal_erase) {
7a6abbe9
LP		 497 int r;
498
e9ccae31 499 r = safe_fork("(sd-getenvstealerase)", FORK_DEATHSIG_SIGTERM|FORK_LOG|FORK_WAIT, NULL);
7a6abbe9
LP		 500 if (r == 0) {
501 _cleanup_strv_free_ char **l = NULL;
7a6abbe9
LP		 502
503 /* child */
504
e99ca147 505 assert_se(getenv_steal_erase("thisenvvardefinitelywontexist", NULL) == 0);
7a6abbe9
LP		 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) {
e99ca147 513 _cleanup_free_ char *n = NULL, *copy1 = NULL, *copy2 = NULL;
7a6abbe9
LP		 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
e99ca147
LP		 523 copy1 = strdup(eq + 1);
524 assert_se(copy1);
525
526 assert_se(streq_ptr(getenv(n), copy1));
7a6abbe9 527 assert_se(getenv(n) == eq + 1);
e99ca147
LP		 528 assert_se(getenv_steal_erase(n, &copy2) > 0);
529 assert_se(streq_ptr(copy1, copy2));
7a6abbe9
LP		 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
6cc19afa 543TEST(strv_env_name_is_valid) {
fd762319
T		 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")));
6cc19afa 547}
548
192242c9
FS		 549TEST(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
4f7452a8 584DEFINE_TEST_MAIN(LOG_DEBUG);
Unnamed repository; edit this file 'description' to name the repository.