]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
686d13b9 | 2 | |
686d13b9 LP |
3 | #include "alloc-util.h" |
4 | #include "env-file.h" | |
5 | #include "env-util.h" | |
6 | #include "escape.h" | |
7 | #include "fd-util.h" | |
8 | #include "fileio.h" | |
9 | #include "fs-util.h" | |
10 | #include "string-util.h" | |
11 | #include "strv.h" | |
12 | #include "tmpfile-util.h" | |
13 | #include "utf8.h" | |
14 | ||
15 | static int parse_env_file_internal( | |
16 | FILE *f, | |
17 | const char *fname, | |
18 | int (*push) (const char *filename, unsigned line, | |
19 | const char *key, char *value, void *userdata, int *n_pushed), | |
20 | void *userdata, | |
21 | int *n_pushed) { | |
22 | ||
f5fbe71d | 23 | size_t key_alloc = 0, n_key = 0, value_alloc = 0, n_value = 0, last_value_whitespace = SIZE_MAX, last_key_whitespace = SIZE_MAX; |
686d13b9 LP |
24 | _cleanup_free_ char *contents = NULL, *key = NULL, *value = NULL; |
25 | unsigned line = 1; | |
26 | char *p; | |
27 | int r; | |
28 | ||
29 | enum { | |
30 | PRE_KEY, | |
31 | KEY, | |
32 | PRE_VALUE, | |
33 | VALUE, | |
34 | VALUE_ESCAPE, | |
35 | SINGLE_QUOTE_VALUE, | |
686d13b9 LP |
36 | DOUBLE_QUOTE_VALUE, |
37 | DOUBLE_QUOTE_VALUE_ESCAPE, | |
38 | COMMENT, | |
39 | COMMENT_ESCAPE | |
40 | } state = PRE_KEY; | |
41 | ||
42 | if (f) | |
43 | r = read_full_stream(f, &contents, NULL); | |
44 | else | |
45 | r = read_full_file(fname, &contents, NULL); | |
46 | if (r < 0) | |
47 | return r; | |
48 | ||
49 | for (p = contents; *p; p++) { | |
50 | char c = *p; | |
51 | ||
52 | switch (state) { | |
53 | ||
54 | case PRE_KEY: | |
55 | if (strchr(COMMENTS, c)) | |
56 | state = COMMENT; | |
57 | else if (!strchr(WHITESPACE, c)) { | |
58 | state = KEY; | |
f5fbe71d | 59 | last_key_whitespace = SIZE_MAX; |
686d13b9 LP |
60 | |
61 | if (!GREEDY_REALLOC(key, key_alloc, n_key+2)) | |
62 | return -ENOMEM; | |
63 | ||
64 | key[n_key++] = c; | |
65 | } | |
66 | break; | |
67 | ||
68 | case KEY: | |
69 | if (strchr(NEWLINE, c)) { | |
70 | state = PRE_KEY; | |
71 | line++; | |
72 | n_key = 0; | |
73 | } else if (c == '=') { | |
74 | state = PRE_VALUE; | |
f5fbe71d | 75 | last_value_whitespace = SIZE_MAX; |
686d13b9 LP |
76 | } else { |
77 | if (!strchr(WHITESPACE, c)) | |
f5fbe71d YW |
78 | last_key_whitespace = SIZE_MAX; |
79 | else if (last_key_whitespace == SIZE_MAX) | |
686d13b9 LP |
80 | last_key_whitespace = n_key; |
81 | ||
82 | if (!GREEDY_REALLOC(key, key_alloc, n_key+2)) | |
83 | return -ENOMEM; | |
84 | ||
85 | key[n_key++] = c; | |
86 | } | |
87 | ||
88 | break; | |
89 | ||
90 | case PRE_VALUE: | |
91 | if (strchr(NEWLINE, c)) { | |
92 | state = PRE_KEY; | |
93 | line++; | |
94 | key[n_key] = 0; | |
95 | ||
96 | if (value) | |
97 | value[n_value] = 0; | |
98 | ||
99 | /* strip trailing whitespace from key */ | |
f5fbe71d | 100 | if (last_key_whitespace != SIZE_MAX) |
686d13b9 LP |
101 | key[last_key_whitespace] = 0; |
102 | ||
103 | r = push(fname, line, key, value, userdata, n_pushed); | |
104 | if (r < 0) | |
105 | return r; | |
106 | ||
107 | n_key = 0; | |
108 | value = NULL; | |
109 | value_alloc = n_value = 0; | |
110 | ||
111 | } else if (c == '\'') | |
112 | state = SINGLE_QUOTE_VALUE; | |
e768a4f0 | 113 | else if (c == '"') |
686d13b9 LP |
114 | state = DOUBLE_QUOTE_VALUE; |
115 | else if (c == '\\') | |
116 | state = VALUE_ESCAPE; | |
117 | else if (!strchr(WHITESPACE, c)) { | |
118 | state = VALUE; | |
119 | ||
120 | if (!GREEDY_REALLOC(value, value_alloc, n_value+2)) | |
121 | return -ENOMEM; | |
122 | ||
123 | value[n_value++] = c; | |
124 | } | |
125 | ||
126 | break; | |
127 | ||
128 | case VALUE: | |
129 | if (strchr(NEWLINE, c)) { | |
130 | state = PRE_KEY; | |
131 | line++; | |
132 | ||
133 | key[n_key] = 0; | |
134 | ||
135 | if (value) | |
136 | value[n_value] = 0; | |
137 | ||
138 | /* Chomp off trailing whitespace from value */ | |
f5fbe71d | 139 | if (last_value_whitespace != SIZE_MAX) |
686d13b9 LP |
140 | value[last_value_whitespace] = 0; |
141 | ||
142 | /* strip trailing whitespace from key */ | |
f5fbe71d | 143 | if (last_key_whitespace != SIZE_MAX) |
686d13b9 LP |
144 | key[last_key_whitespace] = 0; |
145 | ||
146 | r = push(fname, line, key, value, userdata, n_pushed); | |
147 | if (r < 0) | |
148 | return r; | |
149 | ||
150 | n_key = 0; | |
151 | value = NULL; | |
152 | value_alloc = n_value = 0; | |
153 | ||
154 | } else if (c == '\\') { | |
155 | state = VALUE_ESCAPE; | |
f5fbe71d | 156 | last_value_whitespace = SIZE_MAX; |
686d13b9 LP |
157 | } else { |
158 | if (!strchr(WHITESPACE, c)) | |
f5fbe71d YW |
159 | last_value_whitespace = SIZE_MAX; |
160 | else if (last_value_whitespace == SIZE_MAX) | |
686d13b9 LP |
161 | last_value_whitespace = n_value; |
162 | ||
163 | if (!GREEDY_REALLOC(value, value_alloc, n_value+2)) | |
164 | return -ENOMEM; | |
165 | ||
166 | value[n_value++] = c; | |
167 | } | |
168 | ||
169 | break; | |
170 | ||
171 | case VALUE_ESCAPE: | |
172 | state = VALUE; | |
173 | ||
174 | if (!strchr(NEWLINE, c)) { | |
175 | /* Escaped newlines we eat up entirely */ | |
176 | if (!GREEDY_REALLOC(value, value_alloc, n_value+2)) | |
177 | return -ENOMEM; | |
178 | ||
179 | value[n_value++] = c; | |
180 | } | |
181 | break; | |
182 | ||
183 | case SINGLE_QUOTE_VALUE: | |
184 | if (c == '\'') | |
185 | state = PRE_VALUE; | |
686d13b9 LP |
186 | else { |
187 | if (!GREEDY_REALLOC(value, value_alloc, n_value+2)) | |
188 | return -ENOMEM; | |
189 | ||
190 | value[n_value++] = c; | |
191 | } | |
192 | ||
193 | break; | |
194 | ||
686d13b9 | 195 | case DOUBLE_QUOTE_VALUE: |
e768a4f0 | 196 | if (c == '"') |
686d13b9 LP |
197 | state = PRE_VALUE; |
198 | else if (c == '\\') | |
199 | state = DOUBLE_QUOTE_VALUE_ESCAPE; | |
200 | else { | |
201 | if (!GREEDY_REALLOC(value, value_alloc, n_value+2)) | |
202 | return -ENOMEM; | |
203 | ||
204 | value[n_value++] = c; | |
205 | } | |
206 | ||
207 | break; | |
208 | ||
209 | case DOUBLE_QUOTE_VALUE_ESCAPE: | |
210 | state = DOUBLE_QUOTE_VALUE; | |
211 | ||
de008e53 LP |
212 | if (strchr(SHELL_NEED_ESCAPE, c)) { |
213 | /* If this is a char that needs escaping, just unescape it. */ | |
686d13b9 LP |
214 | if (!GREEDY_REALLOC(value, value_alloc, n_value+2)) |
215 | return -ENOMEM; | |
de008e53 LP |
216 | value[n_value++] = c; |
217 | } else if (c != '\n') { | |
218 | /* If other char than what needs escaping, keep the "\" in place, like the | |
219 | * real shell does. */ | |
e4a8db1f LT |
220 | if (!GREEDY_REALLOC(value, value_alloc, n_value+3)) |
221 | return -ENOMEM; | |
222 | value[n_value++] = '\\'; | |
686d13b9 LP |
223 | value[n_value++] = c; |
224 | } | |
e4a8db1f | 225 | |
de008e53 | 226 | /* Escaped newlines (aka "continuation lines") are eaten up entirely */ |
686d13b9 LP |
227 | break; |
228 | ||
229 | case COMMENT: | |
230 | if (c == '\\') | |
231 | state = COMMENT_ESCAPE; | |
232 | else if (strchr(NEWLINE, c)) { | |
233 | state = PRE_KEY; | |
234 | line++; | |
235 | } | |
236 | break; | |
237 | ||
238 | case COMMENT_ESCAPE: | |
239 | state = COMMENT; | |
240 | break; | |
241 | } | |
242 | } | |
243 | ||
244 | if (IN_SET(state, | |
245 | PRE_VALUE, | |
246 | VALUE, | |
247 | VALUE_ESCAPE, | |
248 | SINGLE_QUOTE_VALUE, | |
686d13b9 LP |
249 | DOUBLE_QUOTE_VALUE, |
250 | DOUBLE_QUOTE_VALUE_ESCAPE)) { | |
251 | ||
252 | key[n_key] = 0; | |
253 | ||
254 | if (value) | |
255 | value[n_value] = 0; | |
256 | ||
257 | if (state == VALUE) | |
f5fbe71d | 258 | if (last_value_whitespace != SIZE_MAX) |
686d13b9 LP |
259 | value[last_value_whitespace] = 0; |
260 | ||
261 | /* strip trailing whitespace from key */ | |
f5fbe71d | 262 | if (last_key_whitespace != SIZE_MAX) |
686d13b9 LP |
263 | key[last_key_whitespace] = 0; |
264 | ||
265 | r = push(fname, line, key, value, userdata, n_pushed); | |
266 | if (r < 0) | |
267 | return r; | |
268 | ||
269 | value = NULL; | |
270 | } | |
271 | ||
272 | return 0; | |
273 | } | |
274 | ||
275 | static int check_utf8ness_and_warn( | |
276 | const char *filename, unsigned line, | |
277 | const char *key, char *value) { | |
278 | ||
279 | if (!utf8_is_valid(key)) { | |
280 | _cleanup_free_ char *p = NULL; | |
281 | ||
282 | p = utf8_escape_invalid(key); | |
283 | return log_error_errno(SYNTHETIC_ERRNO(EINVAL), | |
284 | "%s:%u: invalid UTF-8 in key '%s', ignoring.", | |
285 | strna(filename), line, p); | |
286 | } | |
287 | ||
288 | if (value && !utf8_is_valid(value)) { | |
289 | _cleanup_free_ char *p = NULL; | |
290 | ||
291 | p = utf8_escape_invalid(value); | |
292 | return log_error_errno(SYNTHETIC_ERRNO(EINVAL), | |
293 | "%s:%u: invalid UTF-8 value for key %s: '%s', ignoring.", | |
294 | strna(filename), line, key, p); | |
295 | } | |
296 | ||
297 | return 0; | |
298 | } | |
299 | ||
300 | static int parse_env_file_push( | |
301 | const char *filename, unsigned line, | |
302 | const char *key, char *value, | |
303 | void *userdata, | |
304 | int *n_pushed) { | |
305 | ||
306 | const char *k; | |
307 | va_list aq, *ap = userdata; | |
308 | int r; | |
309 | ||
310 | r = check_utf8ness_and_warn(filename, line, key, value); | |
311 | if (r < 0) | |
312 | return r; | |
313 | ||
314 | va_copy(aq, *ap); | |
315 | ||
316 | while ((k = va_arg(aq, const char *))) { | |
317 | char **v; | |
318 | ||
319 | v = va_arg(aq, char **); | |
320 | ||
321 | if (streq(key, k)) { | |
322 | va_end(aq); | |
323 | free(*v); | |
324 | *v = value; | |
325 | ||
326 | if (n_pushed) | |
327 | (*n_pushed)++; | |
328 | ||
329 | return 1; | |
330 | } | |
331 | } | |
332 | ||
333 | va_end(aq); | |
334 | free(value); | |
335 | ||
336 | return 0; | |
337 | } | |
338 | ||
339 | int parse_env_filev( | |
340 | FILE *f, | |
341 | const char *fname, | |
342 | va_list ap) { | |
343 | ||
344 | int r, n_pushed = 0; | |
345 | va_list aq; | |
346 | ||
347 | va_copy(aq, ap); | |
348 | r = parse_env_file_internal(f, fname, parse_env_file_push, &aq, &n_pushed); | |
349 | va_end(aq); | |
350 | if (r < 0) | |
351 | return r; | |
352 | ||
353 | return n_pushed; | |
354 | } | |
355 | ||
356 | int parse_env_file_sentinel( | |
357 | FILE *f, | |
358 | const char *fname, | |
359 | ...) { | |
360 | ||
361 | va_list ap; | |
362 | int r; | |
363 | ||
364 | va_start(ap, fname); | |
365 | r = parse_env_filev(f, fname, ap); | |
366 | va_end(ap); | |
367 | ||
368 | return r; | |
369 | } | |
370 | ||
371 | static int load_env_file_push( | |
372 | const char *filename, unsigned line, | |
373 | const char *key, char *value, | |
374 | void *userdata, | |
375 | int *n_pushed) { | |
376 | char ***m = userdata; | |
377 | char *p; | |
378 | int r; | |
379 | ||
380 | r = check_utf8ness_and_warn(filename, line, key, value); | |
381 | if (r < 0) | |
382 | return r; | |
383 | ||
384 | p = strjoin(key, "=", value); | |
385 | if (!p) | |
386 | return -ENOMEM; | |
387 | ||
13734c75 ZJS |
388 | r = strv_env_replace_consume(m, p); |
389 | if (r < 0) | |
686d13b9 | 390 | return r; |
686d13b9 LP |
391 | |
392 | if (n_pushed) | |
393 | (*n_pushed)++; | |
394 | ||
395 | free(value); | |
396 | return 0; | |
397 | } | |
398 | ||
399 | int load_env_file(FILE *f, const char *fname, char ***rl) { | |
400 | char **m = NULL; | |
401 | int r; | |
402 | ||
403 | r = parse_env_file_internal(f, fname, load_env_file_push, &m, NULL); | |
404 | if (r < 0) { | |
405 | strv_free(m); | |
406 | return r; | |
407 | } | |
408 | ||
409 | *rl = m; | |
410 | return 0; | |
411 | } | |
412 | ||
413 | static int load_env_file_push_pairs( | |
414 | const char *filename, unsigned line, | |
415 | const char *key, char *value, | |
416 | void *userdata, | |
417 | int *n_pushed) { | |
418 | char ***m = userdata; | |
419 | int r; | |
420 | ||
421 | r = check_utf8ness_and_warn(filename, line, key, value); | |
422 | if (r < 0) | |
423 | return r; | |
424 | ||
425 | r = strv_extend(m, key); | |
426 | if (r < 0) | |
427 | return -ENOMEM; | |
428 | ||
429 | if (!value) { | |
430 | r = strv_extend(m, ""); | |
431 | if (r < 0) | |
432 | return -ENOMEM; | |
433 | } else { | |
434 | r = strv_push(m, value); | |
435 | if (r < 0) | |
436 | return r; | |
437 | } | |
438 | ||
439 | if (n_pushed) | |
440 | (*n_pushed)++; | |
441 | ||
442 | return 0; | |
443 | } | |
444 | ||
445 | int load_env_file_pairs(FILE *f, const char *fname, char ***rl) { | |
446 | char **m = NULL; | |
447 | int r; | |
448 | ||
449 | r = parse_env_file_internal(f, fname, load_env_file_push_pairs, &m, NULL); | |
450 | if (r < 0) { | |
451 | strv_free(m); | |
452 | return r; | |
453 | } | |
454 | ||
455 | *rl = m; | |
456 | return 0; | |
457 | } | |
458 | ||
459 | static int merge_env_file_push( | |
460 | const char *filename, unsigned line, | |
461 | const char *key, char *value, | |
462 | void *userdata, | |
463 | int *n_pushed) { | |
464 | ||
465 | char ***env = userdata; | |
466 | char *expanded_value; | |
467 | ||
468 | assert(env); | |
469 | ||
470 | if (!value) { | |
471 | log_error("%s:%u: invalid syntax (around \"%s\"), ignoring.", strna(filename), line, key); | |
472 | return 0; | |
473 | } | |
474 | ||
475 | if (!env_name_is_valid(key)) { | |
476 | log_error("%s:%u: invalid variable name \"%s\", ignoring.", strna(filename), line, key); | |
477 | free(value); | |
478 | return 0; | |
479 | } | |
480 | ||
481 | expanded_value = replace_env(value, *env, | |
482 | REPLACE_ENV_USE_ENVIRONMENT| | |
483 | REPLACE_ENV_ALLOW_BRACELESS| | |
484 | REPLACE_ENV_ALLOW_EXTENDED); | |
485 | if (!expanded_value) | |
486 | return -ENOMEM; | |
487 | ||
488 | free_and_replace(value, expanded_value); | |
489 | ||
f6301bdc ZJS |
490 | log_debug("%s:%u: setting %s=%s", filename, line, key, value); |
491 | ||
686d13b9 LP |
492 | return load_env_file_push(filename, line, key, value, env, n_pushed); |
493 | } | |
494 | ||
495 | int merge_env_file( | |
496 | char ***env, | |
497 | FILE *f, | |
498 | const char *fname) { | |
499 | ||
500 | /* NOTE: this function supports braceful and braceless variable expansions, | |
501 | * plus "extended" substitutions, unlike other exported parsing functions. | |
502 | */ | |
503 | ||
504 | return parse_env_file_internal(f, fname, merge_env_file_push, env, NULL); | |
505 | } | |
506 | ||
507 | static void write_env_var(FILE *f, const char *v) { | |
508 | const char *p; | |
509 | ||
510 | p = strchr(v, '='); | |
511 | if (!p) { | |
512 | /* Fallback */ | |
513 | fputs_unlocked(v, f); | |
514 | fputc_unlocked('\n', f); | |
515 | return; | |
516 | } | |
517 | ||
518 | p++; | |
519 | fwrite_unlocked(v, 1, p-v, f); | |
520 | ||
521 | if (string_has_cc(p, NULL) || chars_intersect(p, WHITESPACE SHELL_NEED_QUOTES)) { | |
e768a4f0 | 522 | fputc_unlocked('"', f); |
686d13b9 LP |
523 | |
524 | for (; *p; p++) { | |
525 | if (strchr(SHELL_NEED_ESCAPE, *p)) | |
526 | fputc_unlocked('\\', f); | |
527 | ||
528 | fputc_unlocked(*p, f); | |
529 | } | |
530 | ||
e768a4f0 | 531 | fputc_unlocked('"', f); |
686d13b9 LP |
532 | } else |
533 | fputs_unlocked(p, f); | |
534 | ||
535 | fputc_unlocked('\n', f); | |
536 | } | |
537 | ||
538 | int write_env_file(const char *fname, char **l) { | |
539 | _cleanup_fclose_ FILE *f = NULL; | |
540 | _cleanup_free_ char *p = NULL; | |
541 | char **i; | |
542 | int r; | |
543 | ||
544 | assert(fname); | |
545 | ||
546 | r = fopen_temporary(fname, &f, &p); | |
547 | if (r < 0) | |
548 | return r; | |
549 | ||
686d13b9 LP |
550 | (void) fchmod_umask(fileno(f), 0644); |
551 | ||
552 | STRV_FOREACH(i, l) | |
553 | write_env_var(f, *i); | |
554 | ||
555 | r = fflush_and_check(f); | |
556 | if (r >= 0) { | |
557 | if (rename(p, fname) >= 0) | |
558 | return 0; | |
559 | ||
560 | r = -errno; | |
561 | } | |
562 | ||
57d2db22 | 563 | (void) unlink(p); |
686d13b9 LP |
564 | return r; |
565 | } |