]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/basic/env-util.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ci: enable build/unit test jobs on ppc64le
[thirdparty/systemd.git] / src / basic / env-util.c
... / ...
CommitLineData
1/* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3#include <stdlib.h>
4#include <unistd.h>
5
6#include "alloc-util.h"
7#include "env-util.h"
8#include "errno-util.h"
9#include "extract-word.h"
10#include "format-util.h"
11#include "log.h"
12#include "parse-util.h"
13#include "path-util.h"
14#include "process-util.h"
15#include "string-util.h"
16#include "strv.h"
17#include "syslog-util.h"
18#include "utf8.h"
19
20/* We follow bash for the character set. Different shells have different rules. */
21#define VALID_BASH_ENV_NAME_CHARS \
22 DIGITS LETTERS \
23 "_"
24
25size_t sc_arg_max(void) {
26 long l = sysconf(_SC_ARG_MAX);
27 assert(l > 0);
28 return (size_t) l;
29}
30
31static bool env_name_is_valid_n(const char *e, size_t n) {
32
33 if (n == SIZE_MAX)
34 n = strlen_ptr(e);
35
36 if (n == 0)
37 return false;
38
39 assert(e);
40
41 if (ascii_isdigit(e[0]))
42 return false;
43
44 /* POSIX says the overall size of the environment block cannot be > ARG_MAX, an individual assignment
45 * hence cannot be either. Discounting the equal sign and trailing NUL this hence leaves ARG_MAX-2 as
46 * longest possible variable name. */
47 if (_unlikely_(n > sc_arg_max() - 2))
48 return false;
49
50 for (const char *p = e; p < e + n; p++)
51 if (!strchr(VALID_BASH_ENV_NAME_CHARS, *p))
52 return false;
53
54 return true;
55}
56
57bool env_name_is_valid(const char *e) {
58 return env_name_is_valid_n(e, SIZE_MAX);
59}
60
61bool env_value_is_valid(const char *e) {
62 if (!e)
63 return false;
64
65 if (!utf8_is_valid(e))
66 return false;
67
68 /* Note that variable *values* may contain control characters, in particular NL, TAB, BS, DEL, ESC…
69 * When printing those variables with show-environment, we'll escape them. Make sure to print
70 * environment variables carefully! */
71
72 /* POSIX says the overall size of the environment block cannot be > ARG_MAX, an individual assignment
73 * hence cannot be either. Discounting the shortest possible variable name of length 1, the equal
74 * sign and trailing NUL this hence leaves ARG_MAX-3 as longest possible variable value. */
75 if (_unlikely_(strlen(e) > sc_arg_max() - 3))
76 return false;
77
78 return true;
79}
80
81bool env_assignment_is_valid(const char *e) {
82 const char *eq;
83
84 assert(e);
85
86 eq = strchr(e, '=');
87 if (!eq)
88 return false;
89
90 if (!env_name_is_valid_n(e, eq - e))
91 return false;
92
93 if (!env_value_is_valid(eq + 1))
94 return false;
95
96 /* POSIX says the overall size of the environment block cannot be > ARG_MAX, hence the individual
97 * variable assignments cannot be either, but let's leave room for one trailing NUL byte. */
98 if (_unlikely_(strlen(e) > sc_arg_max() - 1))
99 return false;
100
101 return true;
102}
103
104bool strv_env_is_valid(char * const *e) {
105 STRV_FOREACH(p, e) {
106 size_t k;
107
108 if (!env_assignment_is_valid(*p))
109 return false;
110
111 /* Check if there are duplicate assignments */
112 k = strcspn(*p, "=");
113 STRV_FOREACH(q, p + 1)
114 if (strneq(*p, *q, k) && (*q)[k] == '=')
115 return false;
116 }
117
118 return true;
119}
120
121bool strv_env_name_is_valid(char * const *l) {
122 STRV_FOREACH(p, l) {
123 if (!env_name_is_valid(*p))
124 return false;
125
126 if (strv_contains(p + 1, *p))
127 return false;
128 }
129
130 return true;
131}
132
133bool strv_env_name_or_assignment_is_valid(char * const *l) {
134 STRV_FOREACH(p, l) {
135 if (!env_assignment_is_valid(*p) && !env_name_is_valid(*p))
136 return false;
137
138 if (strv_contains(p + 1, *p))
139 return false;
140 }
141
142 return true;
143}
144
145static int env_append(char **e, char ***k, char **a) {
146 assert(e);
147 assert(k);
148 assert(*k >= e);
149
150 if (!a)
151 return 0;
152
153 /* Expects the following arguments: 'e' shall point to the beginning of an strv we are going to append to, 'k'
154 * to a pointer pointing to the NULL entry at the end of the same array. 'a' shall point to another strv.
155 *
156 * This call adds every entry of 'a' to 'e', either overriding an existing matching entry, or appending to it.
157 *
158 * This call assumes 'e' has enough pre-allocated space to grow by all of 'a''s items. */
159
160 for (; *a; a++) {
161 char **j, *c;
162 size_t n;
163
164 n = strcspn(*a, "=");
165 if ((*a)[n] == '=')
166 n++;
167
168 for (j = e; j < *k; j++)
169 if (strneq(*j, *a, n))
170 break;
171
172 c = strdup(*a);
173 if (!c)
174 return -ENOMEM;
175
176 if (j >= *k) { /* Append to the end? */
177 (*k)[0] = c;
178 (*k)[1] = NULL;
179 (*k)++;
180 } else
181 free_and_replace(*j, c); /* Override existing item */
182 }
183
184 return 0;
185}
186
187char** _strv_env_merge(char **first, ...) {
188 _cleanup_strv_free_ char **merged = NULL;
189 char **k;
190 va_list ap;
191
192 /* Merges an arbitrary number of environment sets */
193
194 size_t n = strv_length(first);
195
196 va_start(ap, first);
197 for (;;) {
198 char **l;
199
200 l = va_arg(ap, char**);
201 if (l == POINTER_MAX)
202 break;
203
204 n += strv_length(l);
205 }
206 va_end(ap);
207
208 k = merged = new(char*, n + 1);
209 if (!merged)
210 return NULL;
211 merged[0] = NULL;
212
213 if (env_append(merged, &k, first) < 0)
214 return NULL;
215
216 va_start(ap, first);
217 for (;;) {
218 char **l;
219
220 l = va_arg(ap, char**);
221 if (l == POINTER_MAX)
222 break;
223
224 if (env_append(merged, &k, l) < 0) {
225 va_end(ap);
226 return NULL;
227 }
228 }
229 va_end(ap);
230
231 return TAKE_PTR(merged);
232}
233
234static bool env_match(const char *t, const char *pattern) {
235 assert(t);
236 assert(pattern);
237
238 /* pattern a matches string a
239 * a matches a=
240 * a matches a=b
241 * a= matches a=
242 * a=b matches a=b
243 * a= does not match a
244 * a=b does not match a=
245 * a=b does not match a
246 * a=b does not match a=c */
247
248 if (streq(t, pattern))
249 return true;
250
251 if (!strchr(pattern, '=')) {
252 t = startswith(t, pattern);
253
254 return t && *t == '=';
255 }
256
257 return false;
258}
259
260static bool env_entry_has_name(const char *entry, const char *name) {
261 const char *t;
262
263 assert(entry);
264 assert(name);
265
266 t = startswith(entry, name);
267 if (!t)
268 return false;
269
270 return *t == '=';
271}
272
273char** strv_env_delete(char **x, size_t n_lists, ...) {
274 size_t n, i = 0;
275 _cleanup_strv_free_ char **t = NULL;
276 va_list ap;
277
278 /* Deletes every entry from x that is mentioned in the other
279 * string lists */
280
281 n = strv_length(x);
282
283 t = new(char*, n+1);
284 if (!t)
285 return NULL;
286
287 STRV_FOREACH(k, x) {
288 va_start(ap, n_lists);
289 for (size_t v = 0; v < n_lists; v++) {
290 char **l;
291
292 l = va_arg(ap, char**);
293 STRV_FOREACH(j, l)
294 if (env_match(*k, *j))
295 goto skip;
296 }
297 va_end(ap);
298
299 t[i] = strdup(*k);
300 if (!t[i])
301 return NULL;
302
303 i++;
304 continue;
305
306 skip:
307 va_end(ap);
308 }
309
310 t[i] = NULL;
311
312 assert(i <= n);
313
314 return TAKE_PTR(t);
315}
316
317char** strv_env_unset(char **l, const char *p) {
318 assert(p);
319
320 if (!l)
321 return NULL;
322
323 /* Drops every occurrence of the env var setting p in the
324 * string list. Edits in-place. */
325
326 char **f, **t;
327 for (f = t = l; *f; f++) {
328 if (env_match(*f, p)) {
329 free(*f);
330 continue;
331 }
332
333 *(t++) = *f;
334 }
335
336 *t = NULL;
337 return l;
338}
339
340char** strv_env_unset_many_internal(char **l, ...) {
341 if (!l)
342 return NULL;
343
344 /* Like strv_env_unset() but applies many at once. Edits in-place. */
345
346 char **f, **t;
347 for (f = t = l; *f; f++) {
348 bool found = false;
349 const char *p;
350 va_list ap;
351
352 va_start(ap, l);
353
354 while ((p = va_arg(ap, const char*)))
355 if (env_match(*f, p)) {
356 found = true;
357 break;
358 }
359
360 va_end(ap);
361
362 if (found) {
363 free(*f);
364 continue;
365 }
366
367 *(t++) = *f;
368 }
369
370 *t = NULL;
371 return l;
372}
373
374int strv_env_replace_consume(char ***l, char *p) {
375 const char *t, *name;
376 int r;
377
378 assert(l);
379 assert(p);
380
381 /* Replace first occurrence of the env var or add a new one in the string list. Drop other
382 * occurrences. Edits in-place. Does not copy p and CONSUMES p EVEN ON FAILURE.
383 *
384 * p must be a valid key=value assignment. */
385
386 t = strchr(p, '=');
387 if (!t) {
388 free(p);
389 return -EINVAL;
390 }
391
392 name = strndupa_safe(p, t - p);
393
394 STRV_FOREACH(f, *l)
395 if (env_entry_has_name(*f, name)) {
396 free_and_replace(*f, p);
397 strv_env_unset(f + 1, *f);
398 return 0;
399 }
400
401 /* We didn't find a match, we need to append p or create a new strv */
402 r = strv_consume(l, p);
403 if (r < 0)
404 return r;
405
406 return 1;
407}
408
409int strv_env_replace_strdup(char ***l, const char *assignment) {
410 /* Like strv_env_replace_consume(), but copies the argument. */
411
412 assert(l);
413 assert(assignment);
414
415 char *p = strdup(assignment);
416 if (!p)
417 return -ENOMEM;
418
419 return strv_env_replace_consume(l, p);
420}
421
422int strv_env_replace_strdup_passthrough(char ***l, const char *assignment) {
423 char *p;
424
425 /* Like strv_env_replace_strdup(), but pulls the variable from the environment of
426 * the calling program, if a variable name without value is specified. */
427
428 assert(l);
429 assert(assignment);
430
431 if (strchr(assignment, '=')) {
432 if (!env_assignment_is_valid(assignment))
433 return -EINVAL;
434
435 p = strdup(assignment);
436 } else {
437 if (!env_name_is_valid(assignment))
438 return -EINVAL;
439
440 /* If we can't find the variable in our environment, we will use
441 * the empty string. This way "passthrough" is equivalent to passing
442 * --setenv=FOO=$FOO in the shell. */
443 p = strjoin(assignment, "=", secure_getenv(assignment));
444 }
445 if (!p)
446 return -ENOMEM;
447
448 return strv_env_replace_consume(l, p);
449}
450
451int strv_env_assign(char ***l, const char *key, const char *value) {
452 assert(l);
453
454 if (!env_name_is_valid(key))
455 return -EINVAL;
456
457 /* NULL removes assignment, "" creates an empty assignment. */
458
459 if (!value) {
460 strv_env_unset(*l, key);
461 return 0;
462 }
463
464 char *p = strjoin(key, "=", value);
465 if (!p)
466 return -ENOMEM;
467
468 return strv_env_replace_consume(l, p);
469}
470
471int strv_env_assignf(char ***l, const char *key, const char *valuef, ...) {
472 int r;
473
474 assert(l);
475 assert(key);
476
477 if (!env_name_is_valid(key))
478 return -EINVAL;
479
480 if (!valuef) {
481 strv_env_unset(*l, key);
482 return 0;
483 }
484
485 _cleanup_free_ char *value = NULL;
486 va_list ap;
487 va_start(ap, valuef);
488 r = vasprintf(&value, valuef, ap);
489 va_end(ap);
490 if (r < 0)
491 return -ENOMEM;
492
493 char *p = strjoin(key, "=", value);
494 if (!p)
495 return -ENOMEM;
496
497 return strv_env_replace_consume(l, p);
498}
499
500int _strv_env_assign_many(char ***l, ...) {
501 va_list ap;
502 int r;
503
504 assert(l);
505
506 va_start(ap, l);
507 for (;;) {
508 const char *key, *value;
509
510 key = va_arg(ap, const char *);
511 if (!key)
512 break;
513
514 if (!env_name_is_valid(key)) {
515 va_end(ap);
516 return -EINVAL;
517 }
518
519 value = va_arg(ap, const char *);
520 if (!value) {
521 strv_env_unset(*l, key);
522 continue;
523 }
524
525 char *p = strjoin(key, "=", value);
526 if (!p) {
527 va_end(ap);
528 return -ENOMEM;
529 }
530
531 r = strv_env_replace_consume(l, p);
532 if (r < 0) {
533 va_end(ap);
534 return r;
535 }
536 }
537 va_end(ap);
538
539 return 0;
540}
541
542char* strv_env_get_n(char * const *l, const char *name, size_t k, ReplaceEnvFlags flags) {
543 assert(name);
544
545 if (k == SIZE_MAX)
546 k = strlen(name);
547 if (k <= 0)
548 return NULL;
549
550 STRV_FOREACH_BACKWARDS(i, l)
551 if (strneq(*i, name, k) && (*i)[k] == '=')
552 return (char*) *i + k + 1;
553
554 if (flags & REPLACE_ENV_USE_ENVIRONMENT) {
555 const char *t;
556
557 /* Safety check that the name is not overly long, before we do a stack allocation */
558 if (k > (size_t) sysconf(_SC_ARG_MAX) - 2)
559 return NULL;
560
561 t = strndupa_safe(name, k);
562 return secure_getenv(t);
563 };
564
565 return NULL;
566}
567
568char* strv_env_pairs_get(char **l, const char *name) {
569 char *result = NULL;
570
571 assert(name);
572
573 STRV_FOREACH_PAIR(key, value, l)
574 if (streq(*key, name))
575 result = *value;
576
577 return result;
578}
579
580int strv_env_get_merged(char **l, char ***ret) {
581 _cleanup_strv_free_ char **v = NULL;
582 size_t n = 0;
583 int r;
584
585 assert(ret);
586
587 /* This converts a strv with pairs of environment variable name + value into a strv of name and
588 * value concatenated with a "=" separator. E.g.
589 * input : { "NAME", "value", "FOO", "var" }
590 * output : { "NAME=value", "FOO=var" } */
591
592 STRV_FOREACH_PAIR(key, value, l) {
593 char *s;
594
595 s = strjoin(*key, "=", *value);
596 if (!s)
597 return -ENOMEM;
598
599 r = strv_consume_with_size(&v, &n, s);
600 if (r < 0)
601 return r;
602 }
603
604 *ret = TAKE_PTR(v);
605 return 0;
606}
607
608char** strv_env_clean_with_callback(char **e, void (*invalid_callback)(const char *p, void *userdata), void *userdata) {
609 int k = 0;
610
611 STRV_FOREACH(p, e) {
612 size_t n;
613 bool duplicate = false;
614
615 if (!env_assignment_is_valid(*p)) {
616 if (invalid_callback)
617 invalid_callback(*p, userdata);
618 free(*p);
619 continue;
620 }
621
622 n = strcspn(*p, "=");
623 STRV_FOREACH(q, p + 1)
624 if (strneq(*p, *q, n) && (*q)[n] == '=') {
625 duplicate = true;
626 break;
627 }
628
629 if (duplicate) {
630 free(*p);
631 continue;
632 }
633
634 e[k++] = *p;
635 }
636
637 if (e)
638 e[k] = NULL;
639
640 return e;
641}
642
643static int strv_extend_with_length(char ***l, const char *s, size_t n) {
644 char *c;
645
646 c = strndup(s, n);
647 if (!c)
648 return -ENOMEM;
649
650 return strv_consume(l, c);
651}
652
653static int strv_env_get_n_validated(
654 char **env,
655 const char *name,
656 size_t l,
657 ReplaceEnvFlags flags,
658 char **ret, /* points into the env block! do not free! */
659 char ***unset_variables, /* updated in place */
660 char ***bad_variables) { /* ditto */
661
662 char *e;
663 int r;
664
665 assert(l == 0 || name);
666 assert(ret);
667
668 if (env_name_is_valid_n(name, l)) {
669 e = strv_env_get_n(env, name, l, flags);
670 if (!e && unset_variables) {
671 r = strv_extend_with_length(unset_variables, name, l);
672 if (r < 0)
673 return r;
674 }
675 } else {
676 e = NULL; /* Resolve invalid variable names the same way as unset ones */
677
678 if (bad_variables) {
679 r = strv_extend_with_length(bad_variables, name, l);
680 if (r < 0)
681 return r;
682 }
683 }
684
685 *ret = e;
686 return !!e;
687}
688
689int replace_env_full(
690 const char *format,
691 size_t length,
692 char **env,
693 ReplaceEnvFlags flags,
694 char **ret,
695 char ***ret_unset_variables,
696 char ***ret_bad_variables) {
697
698 enum {
699 WORD,
700 CURLY,
701 VARIABLE,
702 VARIABLE_RAW,
703 TEST,
704 DEFAULT_VALUE,
705 ALTERNATE_VALUE,
706 } state = WORD;
707
708 _cleanup_strv_free_ char **unset_variables = NULL, **bad_variables = NULL;
709 const char *e, *word = format, *test_value = NULL; /* test_value is initialized to appease gcc */
710 _cleanup_free_ char *s = NULL;
711 char ***pu, ***pb;
712 size_t i, len = 0; /* len is initialized to appease gcc */
713 int nest = 0, r;
714
715 assert(format);
716
717 if (length == SIZE_MAX)
718 length = strlen(format);
719
720 pu = ret_unset_variables ? &unset_variables : NULL;
721 pb = ret_bad_variables ? &bad_variables : NULL;
722
723 for (e = format, i = 0; *e && i < length; e++, i++)
724 switch (state) {
725
726 case WORD:
727 if (*e == '$')
728 state = CURLY;
729 break;
730
731 case CURLY:
732 if (*e == '{') {
733 if (!strextendn(&s, word, e-word-1))
734 return -ENOMEM;
735
736 word = e-1;
737 state = VARIABLE;
738 nest++;
739
740 } else if (*e == '$') {
741 if (!strextendn(&s, word, e-word))
742 return -ENOMEM;
743
744 word = e+1;
745 state = WORD;
746
747 } else if (FLAGS_SET(flags, REPLACE_ENV_ALLOW_BRACELESS) && strchr(VALID_BASH_ENV_NAME_CHARS, *e)) {
748 if (!strextendn(&s, word, e-word-1))
749 return -ENOMEM;
750
751 word = e-1;
752 state = VARIABLE_RAW;
753
754 } else
755 state = WORD;
756 break;
757
758 case VARIABLE:
759 if (*e == '}') {
760 char *t;
761
762 r = strv_env_get_n_validated(env, word+2, e-word-2, flags, &t, pu, pb);
763 if (r < 0)
764 return r;
765
766 if (!strextend(&s, t))
767 return -ENOMEM;
768
769 word = e+1;
770 state = WORD;
771 nest--;
772 } else if (*e == ':') {
773 if (flags & REPLACE_ENV_ALLOW_EXTENDED) {
774 len = e - word - 2;
775 state = TEST;
776 } else
777 /* Treat this as unsupported syntax, i.e. do no replacement */
778 state = WORD;
779 }
780 break;
781
782 case TEST:
783 if (*e == '-')
784 state = DEFAULT_VALUE;
785 else if (*e == '+')
786 state = ALTERNATE_VALUE;
787 else {
788 state = WORD;
789 break;
790 }
791
792 test_value = e+1;
793 break;
794
795 case DEFAULT_VALUE: /* fall through */
796 case ALTERNATE_VALUE:
797 assert(flags & REPLACE_ENV_ALLOW_EXTENDED);
798
799 if (*e == '{') {
800 nest++;
801 break;
802 }
803
804 if (*e != '}')
805 break;
806
807 nest--;
808 if (nest == 0) {
809 _cleanup_strv_free_ char **u = NULL, **b = NULL;
810 _cleanup_free_ char *v = NULL;
811 char *t = NULL;
812
813 r = strv_env_get_n_validated(env, word+2, len, flags, &t, pu, pb);
814 if (r < 0)
815 return r;
816
817 if (t && state == ALTERNATE_VALUE) {
818 r = replace_env_full(test_value, e-test_value, env, flags, &v, pu ? &u : NULL, pb ? &b : NULL);
819 if (r < 0)
820 return r;
821
822 t = v;
823 } else if (!t && state == DEFAULT_VALUE) {
824 r = replace_env_full(test_value, e-test_value, env, flags, &v, pu ? &u : NULL, pb ? &b : NULL);
825 if (r < 0)
826 return r;
827
828 t = v;
829 }
830
831 r = strv_extend_strv_consume(&unset_variables, TAKE_PTR(u), /* filter_duplicates= */ true);
832 if (r < 0)
833 return r;
834 r = strv_extend_strv_consume(&bad_variables, TAKE_PTR(b), /* filter_duplicates= */ true);
835 if (r < 0)
836 return r;
837
838 if (!strextend(&s, t))
839 return -ENOMEM;
840
841 word = e+1;
842 state = WORD;
843 }
844 break;
845
846 case VARIABLE_RAW:
847 assert(flags & REPLACE_ENV_ALLOW_BRACELESS);
848
849 if (!strchr(VALID_BASH_ENV_NAME_CHARS, *e)) {
850 char *t = NULL;
851
852 r = strv_env_get_n_validated(env, word+1, e-word-1, flags, &t, &unset_variables, &bad_variables);
853 if (r < 0)
854 return r;
855
856 if (!strextend(&s, t))
857 return -ENOMEM;
858
859 word = e--;
860 i--;
861 state = WORD;
862 }
863 break;
864 }
865
866 if (state == VARIABLE_RAW) {
867 char *t;
868
869 assert(flags & REPLACE_ENV_ALLOW_BRACELESS);
870
871 r = strv_env_get_n_validated(env, word+1, e-word-1, flags, &t, &unset_variables, &bad_variables);
872 if (r < 0)
873 return r;
874
875 if (!strextend(&s, t))
876 return -ENOMEM;
877
878 } else if (!strextendn(&s, word, e-word))
879 return -ENOMEM;
880
881 if (ret_unset_variables)
882 *ret_unset_variables = TAKE_PTR(unset_variables);
883 if (ret_bad_variables)
884 *ret_bad_variables = TAKE_PTR(bad_variables);
885
886 if (ret)
887 *ret = TAKE_PTR(s);
888
889 return 0;
890}
891
892int replace_env_argv(
893 char **argv,
894 char **env,
895 char ***ret,
896 char ***ret_unset_variables,
897 char ***ret_bad_variables) {
898
899 _cleanup_strv_free_ char **n = NULL, **unset_variables = NULL, **bad_variables = NULL;
900 size_t k = 0, l;
901 int r;
902
903 assert(!strv_isempty(argv));
904 assert(ret);
905
906 l = strv_length(argv);
907
908 n = new(char*, l+1);
909 if (!n)
910 return -ENOMEM;
911
912 STRV_FOREACH(i, argv) {
913 const char *word = *i;
914
915 /* If $FOO appears as single word, replace it by the split up variable */
916 if (word[0] == '$' && !IN_SET(word[1], '{', '$')) {
917 _cleanup_strv_free_ char **m = NULL;
918 const char *name = word + 1;
919 char *e, **w;
920 size_t q;
921
922 if (env_name_is_valid(name)) {
923 e = strv_env_get(env, name);
924 if (e)
925 r = strv_split_full(&m, e, WHITESPACE, EXTRACT_RELAX|EXTRACT_UNQUOTE);
926 else if (ret_unset_variables)
927 r = strv_extend(&unset_variables, name);
928 else
929 r = 0;
930 } else if (ret_bad_variables)
931 r = strv_extend(&bad_variables, name);
932 else
933 r = 0;
934 if (r < 0)
935 return r;
936
937 q = strv_length(m);
938 l = l + q - 1;
939
940 w = reallocarray(n, l + 1, sizeof(char*));
941 if (!w)
942 return -ENOMEM;
943
944 n = w;
945 if (m) {
946 memcpy(n + k, m, (q + 1) * sizeof(char*));
947 m = mfree(m);
948 }
949
950 k += q;
951 continue;
952 }
953
954 _cleanup_strv_free_ char **u = NULL, **b = NULL;
955
956 /* If ${FOO} appears as part of a word, replace it by the variable as-is */
957 r = replace_env_full(
958 word,
959 /* length= */ SIZE_MAX,
960 env,
961 /* flags= */ 0,
962 n + k,
963 ret_unset_variables ? &u : NULL,
964 ret_bad_variables ? &b : NULL);
965 if (r < 0)
966 return r;
967 n[++k] = NULL;
968
969 r = strv_extend_strv_consume(&unset_variables, TAKE_PTR(u), /* filter_duplicates= */ true);
970 if (r < 0)
971 return r;
972
973 r = strv_extend_strv_consume(&bad_variables, TAKE_PTR(b), /* filter_duplicates= */ true);
974 if (r < 0)
975 return r;
976 }
977
978 if (ret_unset_variables) {
979 strv_sort_uniq(unset_variables);
980 *ret_unset_variables = TAKE_PTR(unset_variables);
981 }
982 if (ret_bad_variables) {
983 strv_sort_uniq(bad_variables);
984 *ret_bad_variables = TAKE_PTR(bad_variables);
985 }
986
987 *ret = TAKE_PTR(n);
988 return 0;
989}
990
991int getenv_bool(const char *p) {
992 const char *e;
993
994 e = getenv(p);
995 if (!e)
996 return -ENXIO;
997
998 return parse_boolean(e);
999}
1000
1001int secure_getenv_bool(const char *p) {
1002 const char *e;
1003
1004 e = secure_getenv(p);
1005 if (!e)
1006 return -ENXIO;
1007
1008 return parse_boolean(e);
1009}
1010
1011int secure_getenv_uint64(const char *p, uint64_t *ret) {
1012 const char *e;
1013
1014 assert(p);
1015
1016 e = secure_getenv(p);
1017 if (!e)
1018 return -ENXIO;
1019
1020 return safe_atou64(e, ret);
1021}
1022
1023int set_unset_env(const char *name, const char *value, bool overwrite) {
1024 assert(name);
1025
1026 if (value)
1027 return RET_NERRNO(setenv(name, value, overwrite));
1028
1029 return RET_NERRNO(unsetenv(name));
1030}
1031
1032int putenv_dup(const char *assignment, bool override) {
1033 const char *e, *n;
1034
1035 e = strchr(assignment, '=');
1036 if (!e)
1037 return -EINVAL;
1038
1039 n = strndupa_safe(assignment, e - assignment);
1040
1041 /* This is like putenv(), but uses setenv() so that our memory doesn't become part of environ[]. */
1042 return RET_NERRNO(setenv(n, e + 1, override));
1043}
1044
1045int setenv_systemd_exec_pid(bool update_only) {
1046 const char *e;
1047 int r;
1048
1049 /* Update $SYSTEMD_EXEC_PID=pid except when '*' is set for the variable. */
1050
1051 e = secure_getenv("SYSTEMD_EXEC_PID");
1052 if (!e && update_only)
1053 return 0;
1054
1055 if (streq_ptr(e, "*"))
1056 return 0;
1057
1058 r = setenvf("SYSTEMD_EXEC_PID", /* overwrite= */ 1, PID_FMT, getpid_cached());
1059 if (r < 0)
1060 return r;
1061
1062 return 1;
1063}
1064
1065int setenv_systemd_log_level(void) {
1066 _cleanup_free_ char *val = NULL;
1067 int r;
1068
1069 r = log_level_to_string_alloc(log_get_max_level(), &val);
1070 if (r < 0)
1071 return r;
1072
1073 return RET_NERRNO(setenv("SYSTEMD_LOG_LEVEL", val, /* overwrite= */ true));
1074}
1075
1076int getenv_path_list(const char *name, char ***ret_paths) {
1077 _cleanup_strv_free_ char **l = NULL;
1078 const char *e;
1079 int r;
1080
1081 assert(name);
1082 assert(ret_paths);
1083
1084 e = secure_getenv(name);
1085 if (!e)
1086 return -ENXIO;
1087
1088 r = strv_split_full(&l, e, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1089 if (r < 0)
1090 return log_debug_errno(r, "Failed to parse $%s: %m", name);
1091
1092 STRV_FOREACH(p, l) {
1093 if (!path_is_absolute(*p))
1094 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
1095 "Path '%s' is not absolute, refusing.", *p);
1096
1097 if (!path_is_normalized(*p))
1098 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
1099 "Path '%s' is not normalized, refusing.", *p);
1100
1101 if (path_equal(*p, "/"))
1102 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
1103 "Path '%s' is the root fs, refusing.", *p);
1104 }
1105
1106 if (strv_isempty(l))
1107 return log_debug_errno(SYNTHETIC_ERRNO(EINVAL),
1108 "No paths specified, refusing.");
1109
1110 *ret_paths = TAKE_PTR(l);
1111 return 1;
1112}
1113
1114int getenv_steal_erase(const char *name, char **ret) {
1115 _cleanup_(erase_and_freep) char *a = NULL;
1116 char *e;
1117
1118 assert(name);
1119
1120 /* Reads an environment variable, makes a copy of it, erases its memory in the environment block and removes
1121 * it from there. Usecase: reading passwords from the env block (which is a bad idea, but useful for
1122 * testing, and given that people are likely going to misuse this, be thorough) */
1123
1124 e = secure_getenv(name);
1125 if (!e) {
1126 if (ret)
1127 *ret = NULL;
1128 return 0;
1129 }
1130
1131 if (ret) {
1132 a = strdup(e);
1133 if (!a)
1134 return -ENOMEM;
1135 }
1136
1137 string_erase(e);
1138
1139 if (unsetenv(name) < 0)
1140 return -errno;
1141
1142 if (ret)
1143 *ret = TAKE_PTR(a);
1144
1145 return 1;
1146}
1147
1148int setenvf(const char *name, bool overwrite, const char *valuef, ...) {
1149 _cleanup_free_ char *value = NULL;
1150 va_list ap;
1151 int r;
1152
1153 assert(name);
1154
1155 if (!valuef)
1156 return RET_NERRNO(unsetenv(name));
1157
1158 va_start(ap, valuef);
1159 r = vasprintf(&value, valuef, ap);
1160 va_end(ap);
1161
1162 if (r < 0)
1163 return -ENOMEM;
1164
1165 /* Try to suppress writes if the value is already set correctly (simply because memory management of
1166 * environment variables sucks a bit. */
1167 if (streq_ptr(getenv(name), value))
1168 return 0;
1169
1170 return RET_NERRNO(setenv(name, value, overwrite));
1171}
Unnamed repository; edit this file 'description' to name the repository.