Debian Codegraph @

src/nspawn/nspawn-settings.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "sd-bus.h"
4
5 #include "alloc-util.h"
6 #include "capability-list.h"
7 #include "conf-parser.h"
8 #include "cpu-set-util.h"
9 #include "extract-word.h"
10 #include "namespace-util.h"
11 #include "nspawn-expose-ports.h"
12 #include "nspawn-mount.h"
13 #include "nspawn-network.h"
14 #include "nspawn-settings.h"
15 #include "parse-helpers.h"
16 #include "parse-util.h"
17 #include "process-util.h"
18 #include "rlimit-util.h"
19 #include "set.h"
20 #include "socket-util.h"
21 #include "string-table.h"
22 #include "string-util.h"
23 #include "strv.h"
24 #include "user-util.h"
25
26 Settings *settings_new(void) {
27 Settings *s;
28
29 s = new(Settings, 1);
30 if (!s)
31 return NULL;
32
33 *s = (Settings) {
34 .start_mode = _START_MODE_INVALID,
35 .ephemeral = -1,
36 .personality = PERSONALITY_INVALID,
37
38 .resolv_conf = _RESOLV_CONF_MODE_INVALID,
39 .link_journal = _LINK_JOURNAL_INVALID,
40 .timezone = _TIMEZONE_MODE_INVALID,
41
42 .userns_mode = _USER_NAMESPACE_MODE_INVALID,
43 .userns_ownership = _USER_NAMESPACE_OWNERSHIP_INVALID,
44 .uid_shift = UID_INVALID,
45 .uid_range = UID_INVALID,
46
47 .no_new_privileges = -1,
48
49 .read_only = -1,
50 .volatile_mode = _VOLATILE_MODE_INVALID,
51
52 .private_network = -1,
53 .network_veth = -1,
54
55 .full_capabilities = CAPABILITY_QUINTET_NULL,
56
57 .uid = UID_INVALID,
58 .gid = GID_INVALID,
59
60 .console_mode = _CONSOLE_MODE_INVALID,
61 .console_width = UINT_MAX,
62 .console_height = UINT_MAX,
63
64 .clone_ns_flags = ULONG_MAX,
65 .use_cgns = -1,
66
67 .notify_ready = -1,
68 .suppress_sync = -1,
69 };
70
71 return s;
72 }
73
74 int settings_load(FILE *f, const char *path, Settings **ret) {
75 _cleanup_(settings_freep) Settings *s = NULL;
76 int r;
77
78 assert(path);
79 assert(ret);
80
81 s = settings_new();
82 if (!s)
83 return -ENOMEM;
84
85 r = config_parse(NULL, path, f,
86 "Exec\0"
87 "Network\0"
88 "Files\0",
89 config_item_perf_lookup, nspawn_gperf_lookup,
90 CONFIG_PARSE_WARN,
91 s, NULL);
92 if (r < 0)
93 return r;
94
95 /* Make sure that if userns_mode is set, userns_chown is set to something appropriate, and vice versa. Either
96 * both fields shall be initialized or neither. */
97 if (s->userns_mode >= 0 && s->userns_ownership < 0)
98 s->userns_ownership = s->userns_mode == USER_NAMESPACE_PICK ? USER_NAMESPACE_OWNERSHIP_CHOWN : USER_NAMESPACE_OWNERSHIP_OFF;
99 if (s->userns_ownership >= 0 && s->userns_mode < 0)
100 s->userns_mode = USER_NAMESPACE_NO;
101
102 *ret = TAKE_PTR(s);
103 return 0;
104 }
105
106 static void free_oci_hooks(OciHook *hooks, size_t n) {
107 assert(hooks || n == 0);
108
109 FOREACH_ARRAY(hook, hooks, n) {
110 free(hook->path);
111 strv_free(hook->args);
112 strv_free(hook->env);
113 }
114
115 free(hooks);
116 }
117
118 void device_node_array_free(DeviceNode *nodes, size_t n) {
119 assert(nodes || n == 0);
120
121 FOREACH_ARRAY(node, nodes, n)
122 free(node->path);
123
124 free(nodes);
125 }
126
127 Settings* settings_free(Settings *s) {
128 if (!s)
129 return NULL;
130
131 strv_free(s->parameters);
132 strv_free(s->environment);
133 free(s->user);
134 free(s->pivot_root_new);
135 free(s->pivot_root_old);
136 free(s->working_directory);
137 strv_free(s->syscall_allow_list);
138 strv_free(s->syscall_deny_list);
139 rlimit_free_all(s->rlimit);
140 free(s->hostname);
141 cpu_set_done(&s->cpu_set);
142 set_free(s->restrict_address_families);
143 strv_free(s->bind_user);
144 free(s->bind_user_shell);
145
146 strv_free(s->network_interfaces);
147 strv_free(s->network_macvlan);
148 strv_free(s->network_ipvlan);
149 strv_free(s->network_veth_extra);
150 free(s->network_bridge);
151 free(s->network_zone);
152 expose_port_free_all(s->expose_ports);
153
154 custom_mount_free_all(s->custom_mounts, s->n_custom_mounts);
155
156 free(s->bundle);
157 free(s->root);
158
159 free_oci_hooks(s->oci_hooks_prestart, s->n_oci_hooks_prestart);
160 free_oci_hooks(s->oci_hooks_poststart, s->n_oci_hooks_poststart);
161 free_oci_hooks(s->oci_hooks_poststop, s->n_oci_hooks_poststop);
162
163 free(s->slice);
164 sd_bus_message_unref(s->properties);
165
166 free(s->supplementary_gids);
167 device_node_array_free(s->extra_nodes, s->n_extra_nodes);
168 free(s->network_namespace_path);
169
170 strv_free(s->sysctl);
171
172 #if HAVE_SECCOMP
173 if (s->seccomp)
174 sym_seccomp_release(s->seccomp);
175 #endif
176
177 return mfree(s);
178 }
179
180 bool settings_private_network(Settings *s) {
181 assert(s);
182
183 /* Determines whether we shall open up our own private network */
184
185 return
186 s->private_network > 0 ||
187 s->network_veth > 0 ||
188 s->network_bridge ||
189 s->network_zone ||
190 s->network_interfaces ||
191 s->network_macvlan ||
192 s->network_ipvlan ||
193 s->network_veth_extra;
194 }
195
196 bool settings_network_veth(Settings *s) {
197 assert(s);
198
199 return
200 s->network_veth > 0 ||
201 s->network_bridge ||
202 s->network_zone;
203 }
204
205 bool settings_network_configured(Settings *s) {
206 assert(s);
207
208 /* Determines whether any network configuration setting was used. (i.e. in contrast to
209 * settings_private_network() above this might also indicate if private networking was explicitly
210 * turned off.) */
211
212 return
213 s->private_network >= 0 ||
214 s->network_veth >= 0 ||
215 s->network_bridge ||
216 s->network_zone ||
217 s->network_interfaces ||
218 s->network_macvlan ||
219 s->network_ipvlan ||
220 s->network_veth_extra ||
221 s->network_namespace_path;
222 }
223
224 int settings_allocate_properties(Settings *s) {
225 _cleanup_(sd_bus_unrefp) sd_bus *bus = NULL;
226 int r;
227
228 assert(s);
229
230 if (s->properties)
231 return 0;
232
233 r = sd_bus_default_system(&bus);
234 if (r < 0)
235 return r;
236
237 r = sd_bus_message_new(bus, &s->properties, SD_BUS_MESSAGE_METHOD_CALL);
238 if (r < 0)
239 return r;
240
241 return 0;
242 }
243
244 DEFINE_CONFIG_PARSE_ENUM(config_parse_volatile_mode, volatile_mode, VolatileMode);
245
246 int config_parse_expose_port(
247 const char *unit,
248 const char *filename,
249 unsigned line,
250 const char *section,
251 unsigned section_line,
252 const char *lvalue,
253 int ltype,
254 const char *rvalue,
255 void *data,
256 void *userdata) {
257
258 Settings *s = data;
259 int r;
260
261 assert(filename);
262 assert(lvalue);
263 assert(rvalue);
264
265 r = expose_port_parse(&s->expose_ports, rvalue);
266 if (r == -EEXIST)
267 log_syntax(unit, LOG_WARNING, filename, line, r, "Duplicate port specification, ignoring: %s", rvalue);
268 else if (r < 0)
269 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse host port %s: %m", rvalue);
270
271 return 0;
272 }
273
274 int config_parse_capability(
275 const char *unit,
276 const char *filename,
277 unsigned line,
278 const char *section,
279 unsigned section_line,
280 const char *lvalue,
281 int ltype,
282 const char *rvalue,
283 void *data,
284 void *userdata) {
285
286 uint64_t u = 0, *result = data;
287 int r;
288
289 assert(filename);
290 assert(lvalue);
291 assert(rvalue);
292
293 for (;;) {
294 _cleanup_free_ char *word = NULL;
295
296 r = extract_first_word(&rvalue, &word, NULL, 0);
297 if (r == -ENOMEM)
298 return log_oom();
299 if (r < 0) {
300 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to extract capability string, ignoring: %s", rvalue);
301 return 0;
302 }
303 if (r == 0)
304 break;
305
306 if (streq(word, "all"))
307 u = UINT64_MAX;
308 else {
309 r = capability_from_name(word);
310 if (r < 0) {
311 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse capability, ignoring: %s", word);
312 continue;
313 }
314
315 u |= UINT64_C(1) << r;
316 }
317 }
318
319 *result |= u;
320 return 0;
321 }
322
323 int config_parse_pivot_root(
324 const char *unit,
325 const char *filename,
326 unsigned line,
327 const char *section,
328 unsigned section_line,
329 const char *lvalue,
330 int ltype,
331 const char *rvalue,
332 void *data,
333 void *userdata) {
334
335 Settings *settings = data;
336 int r;
337
338 assert(filename);
339 assert(lvalue);
340 assert(rvalue);
341
342 r = pivot_root_parse(&settings->pivot_root_new, &settings->pivot_root_old, rvalue);
343 if (r < 0)
344 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid pivot root mount specification %s: %m", rvalue);
345
346 return 0;
347 }
348
349 int config_parse_bind(
350 const char *unit,
351 const char *filename,
352 unsigned line,
353 const char *section,
354 unsigned section_line,
355 const char *lvalue,
356 int ltype,
357 const char *rvalue,
358 void *data,
359 void *userdata) {
360
361 Settings *settings = data;
362 int r;
363
364 assert(filename);
365 assert(lvalue);
366 assert(rvalue);
367
368 r = bind_mount_parse(&settings->custom_mounts, &settings->n_custom_mounts, rvalue, ltype);
369 if (r < 0)
370 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid bind mount specification %s: %m", rvalue);
371
372 return 0;
373 }
374
375 int config_parse_tmpfs(
376 const char *unit,
377 const char *filename,
378 unsigned line,
379 const char *section,
380 unsigned section_line,
381 const char *lvalue,
382 int ltype,
383 const char *rvalue,
384 void *data,
385 void *userdata) {
386
387 Settings *settings = data;
388 int r;
389
390 assert(filename);
391 assert(lvalue);
392 assert(rvalue);
393
394 r = tmpfs_mount_parse(&settings->custom_mounts, &settings->n_custom_mounts, rvalue);
395 if (r < 0)
396 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid temporary file system specification %s: %m", rvalue);
397
398 return 0;
399 }
400
401 int config_parse_inaccessible(
402 const char *unit,
403 const char *filename,
404 unsigned line,
405 const char *section,
406 unsigned section_line,
407 const char *lvalue,
408 int ltype,
409 const char *rvalue,
410 void *data,
411 void *userdata) {
412
413 Settings *settings = data;
414 int r;
415
416 assert(filename);
417 assert(lvalue);
418 assert(rvalue);
419
420 r = inaccessible_mount_parse(&settings->custom_mounts, &settings->n_custom_mounts, rvalue);
421 if (r < 0)
422 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid inaccessible file system specification %s: %m", rvalue);
423
424 return 0;
425 }
426
427 int config_parse_overlay(
428 const char *unit,
429 const char *filename,
430 unsigned line,
431 const char *section,
432 unsigned section_line,
433 const char *lvalue,
434 int ltype,
435 const char *rvalue,
436 void *data,
437 void *userdata) {
438
439 Settings *settings = data;
440 int r;
441
442 assert(filename);
443 assert(lvalue);
444 assert(rvalue);
445
446 r = overlay_mount_parse(&settings->custom_mounts, &settings->n_custom_mounts, rvalue, ltype);
447 if (r < 0)
448 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid overlay file system specification %s, ignoring: %m", rvalue);
449
450 return 0;
451 }
452
453 int config_parse_veth_extra(
454 const char *unit,
455 const char *filename,
456 unsigned line,
457 const char *section,
458 unsigned section_line,
459 const char *lvalue,
460 int ltype,
461 const char *rvalue,
462 void *data,
463 void *userdata) {
464
465 Settings *settings = data;
466 int r;
467
468 assert(filename);
469 assert(lvalue);
470 assert(rvalue);
471
472 r = veth_extra_parse(&settings->network_veth_extra, rvalue);
473 if (r < 0)
474 log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid extra virtual Ethernet link specification %s: %m", rvalue);
475
476 return 0;
477 }
478
479 int config_parse_network_iface_pair(
480 const char *unit,
481 const char *filename,
482 unsigned line,
483 const char *section,
484 unsigned section_line,
485 const char *lvalue,
486 int ltype,
487 const char *rvalue,
488 void *data,
489 void *userdata) {
490
491 char*** l = data;
492
493 assert(filename);
494 assert(lvalue);
495 assert(rvalue);
496
497 return interface_pair_parse(l, rvalue);
498 }
499
500 int config_parse_macvlan_iface_pair(
501 const char *unit,
502 const char *filename,
503 unsigned line,
504 const char *section,
505 unsigned section_line,
506 const char *lvalue,
507 int ltype,
508 const char *rvalue,
509 void *data,
510 void *userdata) {
511
512 char*** l = data;
513
514 assert(filename);
515 assert(lvalue);
516 assert(rvalue);
517
518 return macvlan_pair_parse(l, rvalue);
519 }
520
521 int config_parse_ipvlan_iface_pair(
522 const char *unit,
523 const char *filename,
524 unsigned line,
525 const char *section,
526 unsigned section_line,
527 const char *lvalue,
528 int ltype,
529 const char *rvalue,
530 void *data,
531 void *userdata) {
532
533 char*** l = data;
534
535 assert(filename);
536 assert(lvalue);
537 assert(rvalue);
538
539 return ipvlan_pair_parse(l, rvalue);
540 }
541
542 int config_parse_network_zone(
543 const char *unit,
544 const char *filename,
545 unsigned line,
546 const char *section,
547 unsigned section_line,
548 const char *lvalue,
549 int ltype,
550 const char *rvalue,
551 void *data,
552 void *userdata) {
553
554 Settings *settings = data;
555 _cleanup_free_ char *j = NULL;
556
557 assert(filename);
558 assert(lvalue);
559 assert(rvalue);
560
561 j = strjoin("vz-", rvalue);
562 if (!ifname_valid(j)) {
563 log_syntax(unit, LOG_WARNING, filename, line, 0, "Invalid network zone name, ignoring: %s", rvalue);
564 return 0;
565 }
566
567 return free_and_replace(settings->network_zone, j);
568 }
569
570 int config_parse_boot(
571 const char *unit,
572 const char *filename,
573 unsigned line,
574 const char *section,
575 unsigned section_line,
576 const char *lvalue,
577 int ltype,
578 const char *rvalue,
579 void *data,
580 void *userdata) {
581
582 Settings *settings = data;
583 int r;
584
585 assert(filename);
586 assert(lvalue);
587 assert(rvalue);
588
589 r = parse_boolean(rvalue);
590 if (r < 0) {
591 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse Boot= parameter %s, ignoring: %m", rvalue);
592 return 0;
593 }
594
595 if (r) {
596 if (settings->start_mode == START_PID2)
597 goto conflict;
598
599 settings->start_mode = START_BOOT;
600 } else {
601 if (settings->start_mode == START_BOOT)
602 goto conflict;
603
604 if (settings->start_mode < 0)
605 settings->start_mode = START_PID1;
606 }
607
608 return 0;
609
610 conflict:
611 log_syntax(unit, LOG_WARNING, filename, line, 0, "Conflicting Boot= or ProcessTwo= setting found. Ignoring.");
612 return 0;
613 }
614
615 int config_parse_pid2(
616 const char *unit,
617 const char *filename,
618 unsigned line,
619 const char *section,
620 unsigned section_line,
621 const char *lvalue,
622 int ltype,
623 const char *rvalue,
624 void *data,
625 void *userdata) {
626
627 Settings *settings = data;
628 int r;
629
630 assert(filename);
631 assert(lvalue);
632 assert(rvalue);
633
634 r = parse_boolean(rvalue);
635 if (r < 0) {
636 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse ProcessTwo= parameter %s, ignoring: %m", rvalue);
637 return 0;
638 }
639
640 if (r) {
641 if (settings->start_mode == START_BOOT)
642 goto conflict;
643
644 settings->start_mode = START_PID2;
645 } else {
646 if (settings->start_mode == START_PID2)
647 goto conflict;
648
649 if (settings->start_mode < 0)
650 settings->start_mode = START_PID1;
651 }
652
653 return 0;
654
655 conflict:
656 log_syntax(unit, LOG_WARNING, filename, line, 0, "Conflicting Boot= or ProcessTwo= setting found. Ignoring.");
657 return 0;
658 }
659
660 int config_parse_private_users(
661 const char *unit,
662 const char *filename,
663 unsigned line,
664 const char *section,
665 unsigned section_line,
666 const char *lvalue,
667 int ltype,
668 const char *rvalue,
669 void *data,
670 void *userdata) {
671
672 Settings *settings = data;
673 int r;
674
675 assert(filename);
676 assert(lvalue);
677 assert(rvalue);
678
679 r = parse_boolean(rvalue);
680 if (r == 0) {
681 /* no: User namespacing off */
682 settings->userns_mode = USER_NAMESPACE_NO;
683 settings->uid_shift = UID_INVALID;
684 settings->uid_range = UINT32_C(0x10000);
685 } else if (r > 0) {
686 /* yes: User namespacing on, UID range is read from root dir */
687 settings->userns_mode = USER_NAMESPACE_FIXED;
688 settings->uid_shift = UID_INVALID;
689 settings->uid_range = UINT32_C(0x10000);
690 } else if (streq(rvalue, "pick")) {
691 /* pick: User namespacing on, UID range is picked randomly */
692 settings->userns_mode = USER_NAMESPACE_PICK;
693 settings->uid_shift = UID_INVALID;
694 settings->uid_range = UINT32_C(0x10000);
695 } else if (streq(rvalue, "identity")) {
696 /* identity: User namespacing on, UID range is 0:65536 */
697 settings->userns_mode = USER_NAMESPACE_FIXED;
698 settings->uid_shift = 0;
699 settings->uid_range = UINT32_C(0x10000);
700 } else if (streq(rvalue, "managed")) {
701 /* managed: User namespace on, and acquire it from systemd-nsresourced */
702 settings->userns_mode = USER_NAMESPACE_MANAGED;
703 settings->uid_shift = UID_INVALID;
704 settings->uid_range = UINT32_C(0x10000);
705 } else {
706 const char *range, *shift;
707 uid_t sh, rn;
708
709 /* anything else: User namespacing on, UID range is explicitly configured */
710
711 range = strchr(rvalue, ':');
712 if (range) {
713 shift = strndupa_safe(rvalue, range - rvalue);
714 range++;
715
716 r = safe_atou32(range, &rn);
717 if (r < 0) {
718 log_syntax(unit, LOG_WARNING, filename, line, r, "UID/GID range invalid, ignoring: %s", range);
719 return 0;
720 }
721 } else {
722 shift = rvalue;
723 rn = UINT32_C(0x10000);
724 }
725
726 r = parse_uid(shift, &sh);
727 if (r < 0) {
728 log_syntax(unit, LOG_WARNING, filename, line, r, "UID/GID shift invalid, ignoring: %s", rvalue);
729 return 0;
730 }
731
732 if (!userns_shift_range_valid(sh, rn)) {
733 log_syntax(unit, LOG_WARNING, filename, line, 0, "UID/GID shift and range combination invalid, ignoring: %s", rvalue);
734 return 0;
735 }
736
737 settings->userns_mode = USER_NAMESPACE_FIXED;
738 settings->uid_shift = sh;
739 settings->uid_range = rn;
740 }
741
742 return 0;
743 }
744
745 int config_parse_syscall_filter(
746 const char *unit,
747 const char *filename,
748 unsigned line,
749 const char *section,
750 unsigned section_line,
751 const char *lvalue,
752 int ltype,
753 const char *rvalue,
754 void *data,
755 void *userdata) {
756
757 Settings *settings = data;
758 bool negative;
759 const char *items;
760 int r;
761
762 assert(filename);
763 assert(lvalue);
764 assert(rvalue);
765
766 negative = rvalue[0] == '~';
767 items = negative ? rvalue + 1 : rvalue;
768
769 for (;;) {
770 _cleanup_free_ char *word = NULL;
771
772 r = extract_first_word(&items, &word, NULL, 0);
773 if (r == 0)
774 return 0;
775 if (r == -ENOMEM)
776 return log_oom();
777 if (r < 0) {
778 log_syntax(unit, LOG_WARNING, filename, line, r,
779 "Failed to parse SystemCallFilter= parameter %s, ignoring: %m", rvalue);
780 return 0;
781 }
782
783 if (negative)
784 r = strv_extend(&settings->syscall_deny_list, word);
785 else
786 r = strv_extend(&settings->syscall_allow_list, word);
787 if (r < 0)
788 return log_oom();
789 }
790 }
791
792 int config_parse_oom_score_adjust(
793 const char *unit,
794 const char *filename,
795 unsigned line,
796 const char *section,
797 unsigned section_line,
798 const char *lvalue,
799 int ltype,
800 const char *rvalue,
801 void *data,
802 void *userdata) {
803
804 Settings *settings = ASSERT_PTR(data);
805 int oa, r;
806
807 assert(rvalue);
808
809 if (isempty(rvalue)) {
810 settings->oom_score_adjust_set = false;
811 return 0;
812 }
813
814 r = parse_oom_score_adjust(rvalue, &oa);
815 if (r == -ERANGE) {
816 log_syntax(unit, LOG_WARNING, filename, line, r, "OOM score adjust value out of range, ignoring: %s", rvalue);
817 return 0;
818 }
819 if (r < 0) {
820 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse the OOM score adjust value, ignoring: %s", rvalue);
821 return 0;
822 }
823
824 settings->oom_score_adjust = oa;
825 settings->oom_score_adjust_set = true;
826
827 return 0;
828 }
829
830 DEFINE_CONFIG_PARSE_ENUM(config_parse_resolv_conf, resolv_conf_mode, ResolvConfMode);
831
832 static const char *const resolv_conf_mode_table[_RESOLV_CONF_MODE_MAX] = {
833 [RESOLV_CONF_OFF] = "off",
834 [RESOLV_CONF_COPY_HOST] = "copy-host",
835 [RESOLV_CONF_COPY_STATIC] = "copy-static",
836 [RESOLV_CONF_COPY_UPLINK] = "copy-uplink",
837 [RESOLV_CONF_COPY_STUB] = "copy-stub",
838 [RESOLV_CONF_REPLACE_HOST] = "replace-host",
839 [RESOLV_CONF_REPLACE_STATIC] = "replace-static",
840 [RESOLV_CONF_REPLACE_UPLINK] = "replace-uplink",
841 [RESOLV_CONF_REPLACE_STUB] = "replace-stub",
842 [RESOLV_CONF_BIND_HOST] = "bind-host",
843 [RESOLV_CONF_BIND_STATIC] = "bind-static",
844 [RESOLV_CONF_BIND_UPLINK] = "bind-uplink",
845 [RESOLV_CONF_BIND_STUB] = "bind-stub",
846 [RESOLV_CONF_DELETE] = "delete",
847 [RESOLV_CONF_AUTO] = "auto",
848 };
849
850 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(resolv_conf_mode, ResolvConfMode, RESOLV_CONF_AUTO);
851
852 int parse_link_journal(const char *s, LinkJournal *ret_mode, bool *ret_try) {
853 int r;
854
855 assert(s);
856 assert(ret_mode);
857 assert(ret_try);
858
859 if (streq(s, "auto")) {
860 *ret_mode = LINK_AUTO;
861 *ret_try = false;
862 } else if (streq(s, "guest")) {
863 *ret_mode = LINK_GUEST;
864 *ret_try = false;
865 } else if (streq(s, "host")) {
866 *ret_mode = LINK_HOST;
867 *ret_try = false;
868 } else if (streq(s, "try-guest")) {
869 *ret_mode = LINK_GUEST;
870 *ret_try = true;
871 } else if (streq(s, "try-host")) {
872 *ret_mode = LINK_HOST;
873 *ret_try = true;
874 } else {
875 /* Also support boolean values, to make things less confusing. */
876 r = parse_boolean(s);
877 if (r < 0)
878 return r;
879
880 /* Let's consider "true" to be equivalent to "auto". */
881 *ret_mode = r ? LINK_AUTO : LINK_NO;
882 *ret_try = false;
883 }
884
885 return 0;
886 }
887
888 int config_parse_link_journal(
889 const char *unit,
890 const char *filename,
891 unsigned line,
892 const char *section,
893 unsigned section_line,
894 const char *lvalue,
895 int ltype,
896 const char *rvalue,
897 void *data,
898 void *userdata) {
899
900 Settings *settings = ASSERT_PTR(data);
901 int r;
902
903 assert(rvalue);
904
905 r = parse_link_journal(rvalue, &settings->link_journal, &settings->link_journal_try);
906 if (r < 0)
907 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse link journal mode, ignoring: %s", rvalue);
908
909 return 0;
910 }
911
912 DEFINE_CONFIG_PARSE_ENUM(config_parse_timezone_mode, timezone_mode, TimezoneMode);
913
914 static const char *const timezone_mode_table[_TIMEZONE_MODE_MAX] = {
915 [TIMEZONE_OFF] = "off",
916 [TIMEZONE_COPY] = "copy",
917 [TIMEZONE_BIND] = "bind",
918 [TIMEZONE_SYMLINK] = "symlink",
919 [TIMEZONE_DELETE] = "delete",
920 [TIMEZONE_AUTO] = "auto",
921 };
922
923 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(timezone_mode, TimezoneMode, TIMEZONE_AUTO);
924
925 static const char *const console_mode_table[_CONSOLE_MODE_MAX] = {
926 [CONSOLE_AUTOPIPE] = "autopipe",
927 [CONSOLE_INTERACTIVE] = "interactive",
928 [CONSOLE_READ_ONLY] = "read-only",
929 [CONSOLE_PASSIVE] = "passive",
930 [CONSOLE_PIPE] = "pipe",
931 };
932
933 DEFINE_STRING_TABLE_LOOKUP(console_mode, ConsoleMode);
934
935 DEFINE_CONFIG_PARSE_ENUM(config_parse_userns_ownership, user_namespace_ownership, UserNamespaceOwnership);
936
937 static const char *const user_namespace_ownership_table[_USER_NAMESPACE_OWNERSHIP_MAX] = {
938 [USER_NAMESPACE_OWNERSHIP_OFF] = "off",
939 [USER_NAMESPACE_OWNERSHIP_CHOWN] = "chown",
940 [USER_NAMESPACE_OWNERSHIP_MAP] = "map",
941 [USER_NAMESPACE_OWNERSHIP_FOREIGN] = "foreign",
942 [USER_NAMESPACE_OWNERSHIP_AUTO] = "auto",
943 };
944
945 /* Note: while "yes" maps to "auto" here, we don't really document that, in order to make things clearer and less confusing to users. */
946 DEFINE_STRING_TABLE_LOOKUP_WITH_BOOLEAN(user_namespace_ownership, UserNamespaceOwnership, USER_NAMESPACE_OWNERSHIP_AUTO);
947
948 int config_parse_userns_chown(
949 const char *unit,
950 const char *filename,
951 unsigned line,
952 const char *section,
953 unsigned section_line,
954 const char *lvalue,
955 int ltype,
956 const char *rvalue,
957 void *data,
958 void *userdata) {
959
960 UserNamespaceOwnership *ownership = ASSERT_PTR(data);
961 int r;
962
963 assert(rvalue);
964
965 /* Compatibility support for UserNamespaceChown=, whose job has been taken over by UserNamespaceOwnership= */
966
967 r = parse_boolean(rvalue);
968 if (r < 0) {
969 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse user namespace ownership mode, ignoring: %s", rvalue);
970 return 0;
971 }
972
973 *ownership = r ? USER_NAMESPACE_OWNERSHIP_CHOWN : USER_NAMESPACE_OWNERSHIP_OFF;
974 return 0;
975 }
976
977 int config_parse_bind_user(
978 const char *unit,
979 const char *filename,
980 unsigned line,
981 const char *section,
982 unsigned section_line,
983 const char *lvalue,
984 int ltype,
985 const char *rvalue,
986 void *data,
987 void *userdata) {
988
989 char ***bind_user = ASSERT_PTR(data);
990 int r;
991
992 assert(rvalue);
993
994 if (isempty(rvalue)) {
995 *bind_user = strv_free(*bind_user);
996 return 0;
997 }
998
999 for (const char* p = rvalue;;) {
1000 _cleanup_free_ char *word = NULL;
1001
1002 r = extract_first_word(&p, &word, NULL, 0);
1003 if (r == -ENOMEM)
1004 return log_oom();
1005 if (r < 0) {
1006 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse BindUser= list, ignoring: %s", rvalue);
1007 return 0;
1008 }
1009 if (r == 0)
1010 break;
1011
1012 if (!valid_user_group_name(word, 0)) {
1013 log_syntax(unit, LOG_WARNING, filename, line, 0, "User name '%s' not valid, ignoring.", word);
1014 return 0;
1015 }
1016
1017 if (strv_consume(bind_user, TAKE_PTR(word)) < 0)
1018 return log_oom();
1019 }
1020
1021 return 0;
1022 }
1023
1024 int config_parse_bind_user_shell(
1025 const char *unit,
1026 const char *filename,
1027 unsigned line,
1028 const char *section,
1029 unsigned section_line,
1030 const char *lvalue,
1031 int ltype,
1032 const char *rvalue,
1033 void *data,
1034 void *userdata) {
1035
1036 Settings *settings = ASSERT_PTR(data);
1037 char *sh = NULL;
1038 bool copy = false;
1039 int r;
1040
1041 assert(rvalue);
1042
1043 if (isempty(rvalue)) {
1044 settings->bind_user_shell = mfree(settings->bind_user_shell);
1045 settings->bind_user_shell_copy = false;
1046 settings->bind_user_shell_set = false;
1047
1048 return 0;
1049 }
1050
1051 r = parse_user_shell(rvalue, &sh, &copy);
1052 if (r == -ENOMEM)
1053 return log_oom();
1054 if (r < 0) {
1055 log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse BindUserShell= value, ignoring: %s", rvalue);
1056 return 0;
1057 }
1058
1059 free_and_replace(settings->bind_user_shell, sh);
1060 settings->bind_user_shell_copy = copy;
1061 settings->bind_user_shell_set = true;
1062
1063 return 0;
1064 }
1065
1066 int config_parse_restrict_address_families(
1067 const char *unit,
1068 const char *filename,
1069 unsigned line,
1070 const char *section,
1071 unsigned section_line,
1072 const char *lvalue,
1073 int ltype,
1074 const char *rvalue,
1075 void *data,
1076 void *userdata) {
1077
1078 Settings *settings = ASSERT_PTR(data);
1079 int r;
1080
1081 assert(rvalue);
1082
1083 r = parse_address_families(rvalue, &settings->restrict_address_families, &settings->restrict_address_families_is_allowlist);
1084 if (r == -ENOMEM)
1085 return log_oom();
1086 if (r < 0) {
1087 log_syntax(unit, LOG_WARNING, filename, line, r,
1088 "Failed to parse address family, ignoring: %s", rvalue);
1089 return 0;
1090 }
1091
1092 return 0;
1093 }