]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/dbus-execute.c
network: also introduce UseDomains= for [DHCPv6] section
[thirdparty/systemd.git] / src / core / dbus-execute.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <sys/mount.h>
4 #include <sys/prctl.h>
5
6 #if HAVE_SECCOMP
7 #include <seccomp.h>
8 #endif
9
10 #include "af-list.h"
11 #include "alloc-util.h"
12 #include "bus-get-properties.h"
13 #include "cap-list.h"
14 #include "capability-util.h"
15 #include "cpu-set-util.h"
16 #include "dbus-execute.h"
17 #include "dbus-util.h"
18 #include "env-util.h"
19 #include "errno-list.h"
20 #include "escape.h"
21 #include "execute.h"
22 #include "fd-util.h"
23 #include "fileio.h"
24 #include "hexdecoct.h"
25 #include "io-util.h"
26 #include "ioprio.h"
27 #include "journal-file.h"
28 #include "mountpoint-util.h"
29 #include "namespace.h"
30 #include "parse-util.h"
31 #include "path-util.h"
32 #include "process-util.h"
33 #include "rlimit-util.h"
34 #if HAVE_SECCOMP
35 #include "seccomp-util.h"
36 #endif
37 #include "securebits-util.h"
38 #include "specifier.h"
39 #include "strv.h"
40 #include "syslog-util.h"
41 #include "unit-printf.h"
42 #include "user-util.h"
43 #include "utf8.h"
44
45 BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_output, exec_output, ExecOutput);
46 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_input, exec_input, ExecInput);
47 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode);
48 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_preserve_mode, exec_preserve_mode, ExecPreserveMode);
49 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_keyring_mode, exec_keyring_mode, ExecKeyringMode);
50 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_proc, protect_proc, ProtectProc);
51 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_proc_subset, proc_subset, ProcSubset);
52 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_home, protect_home, ProtectHome);
53 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_system, protect_system, ProtectSystem);
54 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_personality, personality, unsigned long);
55 static BUS_DEFINE_PROPERTY_GET(property_get_ioprio, "i", ExecContext, exec_context_get_effective_ioprio);
56 static BUS_DEFINE_PROPERTY_GET(property_get_mount_apivfs, "b", ExecContext, exec_context_get_effective_mount_apivfs);
57 static BUS_DEFINE_PROPERTY_GET2(property_get_ioprio_class, "i", ExecContext, exec_context_get_effective_ioprio, IOPRIO_PRIO_CLASS);
58 static BUS_DEFINE_PROPERTY_GET2(property_get_ioprio_priority, "i", ExecContext, exec_context_get_effective_ioprio, IOPRIO_PRIO_DATA);
59 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_empty_string, "s", NULL);
60 static BUS_DEFINE_PROPERTY_GET_REF(property_get_syslog_level, "i", int, LOG_PRI);
61 static BUS_DEFINE_PROPERTY_GET_REF(property_get_syslog_facility, "i", int, LOG_FAC);
62 static BUS_DEFINE_PROPERTY_GET(property_get_cpu_affinity_from_numa, "b", ExecContext, exec_context_get_cpu_affinity_from_numa);
63
64 static int property_get_environment_files(
65 sd_bus *bus,
66 const char *path,
67 const char *interface,
68 const char *property,
69 sd_bus_message *reply,
70 void *userdata,
71 sd_bus_error *error) {
72
73 ExecContext *c = userdata;
74 char **j;
75 int r;
76
77 assert(bus);
78 assert(reply);
79 assert(c);
80
81 r = sd_bus_message_open_container(reply, 'a', "(sb)");
82 if (r < 0)
83 return r;
84
85 STRV_FOREACH(j, c->environment_files) {
86 const char *fn = *j;
87
88 r = sd_bus_message_append(reply, "(sb)", fn[0] == '-' ? fn + 1 : fn, fn[0] == '-');
89 if (r < 0)
90 return r;
91 }
92
93 return sd_bus_message_close_container(reply);
94 }
95
96 static int property_get_oom_score_adjust(
97 sd_bus *bus,
98 const char *path,
99 const char *interface,
100 const char *property,
101 sd_bus_message *reply,
102 void *userdata,
103 sd_bus_error *error) {
104
105 ExecContext *c = userdata;
106 int32_t n;
107 int r;
108
109 assert(bus);
110 assert(reply);
111 assert(c);
112
113 if (c->oom_score_adjust_set)
114 n = c->oom_score_adjust;
115 else {
116 _cleanup_free_ char *t = NULL;
117
118 n = 0;
119 r = read_one_line_file("/proc/self/oom_score_adj", &t);
120 if (r < 0)
121 log_debug_errno(r, "Failed to read /proc/self/oom_score_adj, ignoring: %m");
122 else {
123 r = safe_atoi32(t, &n);
124 if (r < 0)
125 log_debug_errno(r, "Failed to parse \"%s\" from /proc/self/oom_score_adj, ignoring: %m", t);
126 }
127 }
128
129 return sd_bus_message_append(reply, "i", n);
130 }
131
132 static int property_get_coredump_filter(
133 sd_bus *bus,
134 const char *path,
135 const char *interface,
136 const char *property,
137 sd_bus_message *reply,
138 void *userdata,
139 sd_bus_error *error) {
140
141 ExecContext *c = userdata;
142 uint64_t n;
143 int r;
144
145 assert(bus);
146 assert(reply);
147 assert(c);
148
149 if (c->coredump_filter_set)
150 n = c->coredump_filter;
151 else {
152 _cleanup_free_ char *t = NULL;
153
154 n = COREDUMP_FILTER_MASK_DEFAULT;
155 r = read_one_line_file("/proc/self/coredump_filter", &t);
156 if (r < 0)
157 log_debug_errno(r, "Failed to read /proc/self/coredump_filter, ignoring: %m");
158 else {
159 r = safe_atoux64(t, &n);
160 if (r < 0)
161 log_debug_errno(r, "Failed to parse \"%s\" from /proc/self/coredump_filter, ignoring: %m", t);
162 }
163 }
164
165 return sd_bus_message_append(reply, "t", n);
166 }
167
168 static int property_get_nice(
169 sd_bus *bus,
170 const char *path,
171 const char *interface,
172 const char *property,
173 sd_bus_message *reply,
174 void *userdata,
175 sd_bus_error *error) {
176
177 ExecContext *c = userdata;
178 int32_t n;
179
180 assert(bus);
181 assert(reply);
182 assert(c);
183
184 if (c->nice_set)
185 n = c->nice;
186 else {
187 errno = 0;
188 n = getpriority(PRIO_PROCESS, 0);
189 if (errno > 0)
190 n = 0;
191 }
192
193 return sd_bus_message_append(reply, "i", n);
194 }
195
196 static int property_get_cpu_sched_policy(
197 sd_bus *bus,
198 const char *path,
199 const char *interface,
200 const char *property,
201 sd_bus_message *reply,
202 void *userdata,
203 sd_bus_error *error) {
204
205 ExecContext *c = userdata;
206 int32_t n;
207
208 assert(bus);
209 assert(reply);
210 assert(c);
211
212 if (c->cpu_sched_set)
213 n = c->cpu_sched_policy;
214 else {
215 n = sched_getscheduler(0);
216 if (n < 0)
217 n = SCHED_OTHER;
218 }
219
220 return sd_bus_message_append(reply, "i", n);
221 }
222
223 static int property_get_cpu_sched_priority(
224 sd_bus *bus,
225 const char *path,
226 const char *interface,
227 const char *property,
228 sd_bus_message *reply,
229 void *userdata,
230 sd_bus_error *error) {
231
232 ExecContext *c = userdata;
233 int32_t n;
234
235 assert(bus);
236 assert(reply);
237 assert(c);
238
239 if (c->cpu_sched_set)
240 n = c->cpu_sched_priority;
241 else {
242 struct sched_param p = {};
243
244 if (sched_getparam(0, &p) >= 0)
245 n = p.sched_priority;
246 else
247 n = 0;
248 }
249
250 return sd_bus_message_append(reply, "i", n);
251 }
252
253 static int property_get_cpu_affinity(
254 sd_bus *bus,
255 const char *path,
256 const char *interface,
257 const char *property,
258 sd_bus_message *reply,
259 void *userdata,
260 sd_bus_error *error) {
261
262 ExecContext *c = userdata;
263 _cleanup_(cpu_set_reset) CPUSet s = {};
264 _cleanup_free_ uint8_t *array = NULL;
265 size_t allocated;
266
267 assert(bus);
268 assert(reply);
269 assert(c);
270
271 if (c->cpu_affinity_from_numa) {
272 int r;
273
274 r = numa_to_cpu_set(&c->numa_policy, &s);
275 if (r < 0)
276 return r;
277 }
278
279 (void) cpu_set_to_dbus(c->cpu_affinity_from_numa ? &s : &c->cpu_set, &array, &allocated);
280
281 return sd_bus_message_append_array(reply, 'y', array, allocated);
282 }
283
284 static int property_get_numa_mask(
285 sd_bus *bus,
286 const char *path,
287 const char *interface,
288 const char *property,
289 sd_bus_message *reply,
290 void *userdata,
291 sd_bus_error *error) {
292
293 ExecContext *c = userdata;
294 _cleanup_free_ uint8_t *array = NULL;
295 size_t allocated;
296
297 assert(bus);
298 assert(reply);
299 assert(c);
300
301 (void) cpu_set_to_dbus(&c->numa_policy.nodes, &array, &allocated);
302
303 return sd_bus_message_append_array(reply, 'y', array, allocated);
304 }
305
306 static int property_get_numa_policy(
307 sd_bus *bus,
308 const char *path,
309 const char *interface,
310 const char *property,
311 sd_bus_message *reply,
312 void *userdata,
313 sd_bus_error *error) {
314 ExecContext *c = userdata;
315 int32_t policy;
316
317 assert(bus);
318 assert(reply);
319 assert(c);
320
321 policy = numa_policy_get_type(&c->numa_policy);
322
323 return sd_bus_message_append_basic(reply, 'i', &policy);
324 }
325
326 static int property_get_timer_slack_nsec(
327 sd_bus *bus,
328 const char *path,
329 const char *interface,
330 const char *property,
331 sd_bus_message *reply,
332 void *userdata,
333 sd_bus_error *error) {
334
335 ExecContext *c = userdata;
336 uint64_t u;
337
338 assert(bus);
339 assert(reply);
340 assert(c);
341
342 if (c->timer_slack_nsec != NSEC_INFINITY)
343 u = (uint64_t) c->timer_slack_nsec;
344 else
345 u = (uint64_t) prctl(PR_GET_TIMERSLACK);
346
347 return sd_bus_message_append(reply, "t", u);
348 }
349
350 static int property_get_syscall_filter(
351 sd_bus *bus,
352 const char *path,
353 const char *interface,
354 const char *property,
355 sd_bus_message *reply,
356 void *userdata,
357 sd_bus_error *error) {
358
359 ExecContext *c = userdata;
360 _cleanup_strv_free_ char **l = NULL;
361 int r;
362
363 #if HAVE_SECCOMP
364 void *id, *val;
365 #endif
366
367 assert(bus);
368 assert(reply);
369 assert(c);
370
371 r = sd_bus_message_open_container(reply, 'r', "bas");
372 if (r < 0)
373 return r;
374
375 r = sd_bus_message_append(reply, "b", c->syscall_allow_list);
376 if (r < 0)
377 return r;
378
379 #if HAVE_SECCOMP
380 HASHMAP_FOREACH_KEY(val, id, c->syscall_filter) {
381 _cleanup_free_ char *name = NULL;
382 const char *e = NULL;
383 char *s;
384 int num = PTR_TO_INT(val);
385
386 name = seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1);
387 if (!name)
388 continue;
389
390 if (num >= 0) {
391 e = seccomp_errno_or_action_to_string(num);
392 if (e) {
393 s = strjoin(name, ":", e);
394 if (!s)
395 return -ENOMEM;
396 } else {
397 r = asprintf(&s, "%s:%d", name, num);
398 if (r < 0)
399 return -ENOMEM;
400 }
401 } else
402 s = TAKE_PTR(name);
403
404 r = strv_consume(&l, s);
405 if (r < 0)
406 return r;
407 }
408 #endif
409
410 strv_sort(l);
411
412 r = sd_bus_message_append_strv(reply, l);
413 if (r < 0)
414 return r;
415
416 return sd_bus_message_close_container(reply);
417 }
418
419 static int property_get_syscall_log(
420 sd_bus *bus,
421 const char *path,
422 const char *interface,
423 const char *property,
424 sd_bus_message *reply,
425 void *userdata,
426 sd_bus_error *error) {
427
428 ExecContext *c = userdata;
429 _cleanup_strv_free_ char **l = NULL;
430 int r;
431
432 #if HAVE_SECCOMP
433 void *id, *val;
434 #endif
435
436 assert(bus);
437 assert(reply);
438 assert(c);
439
440 r = sd_bus_message_open_container(reply, 'r', "bas");
441 if (r < 0)
442 return r;
443
444 r = sd_bus_message_append(reply, "b", c->syscall_log_allow_list);
445 if (r < 0)
446 return r;
447
448 #if HAVE_SECCOMP
449 HASHMAP_FOREACH_KEY(val, id, c->syscall_log) {
450 char *name = NULL;
451
452 name = seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1);
453 if (!name)
454 continue;
455
456 r = strv_consume(&l, name);
457 if (r < 0)
458 return r;
459 }
460 #endif
461
462 strv_sort(l);
463
464 r = sd_bus_message_append_strv(reply, l);
465 if (r < 0)
466 return r;
467
468 return sd_bus_message_close_container(reply);
469 }
470
471 static int property_get_syscall_archs(
472 sd_bus *bus,
473 const char *path,
474 const char *interface,
475 const char *property,
476 sd_bus_message *reply,
477 void *userdata,
478 sd_bus_error *error) {
479
480 ExecContext *c = userdata;
481 _cleanup_strv_free_ char **l = NULL;
482 int r;
483
484 #if HAVE_SECCOMP
485 void *id;
486 #endif
487
488 assert(bus);
489 assert(reply);
490 assert(c);
491
492 #if HAVE_SECCOMP
493 SET_FOREACH(id, c->syscall_archs) {
494 const char *name;
495
496 name = seccomp_arch_to_string(PTR_TO_UINT32(id) - 1);
497 if (!name)
498 continue;
499
500 r = strv_extend(&l, name);
501 if (r < 0)
502 return -ENOMEM;
503 }
504 #endif
505
506 strv_sort(l);
507
508 r = sd_bus_message_append_strv(reply, l);
509 if (r < 0)
510 return r;
511
512 return 0;
513 }
514
515 static int property_get_selinux_context(
516 sd_bus *bus,
517 const char *path,
518 const char *interface,
519 const char *property,
520 sd_bus_message *reply,
521 void *userdata,
522 sd_bus_error *error) {
523
524 ExecContext *c = userdata;
525
526 assert(bus);
527 assert(reply);
528 assert(c);
529
530 return sd_bus_message_append(reply, "(bs)", c->selinux_context_ignore, c->selinux_context);
531 }
532
533 static int property_get_apparmor_profile(
534 sd_bus *bus,
535 const char *path,
536 const char *interface,
537 const char *property,
538 sd_bus_message *reply,
539 void *userdata,
540 sd_bus_error *error) {
541
542 ExecContext *c = userdata;
543
544 assert(bus);
545 assert(reply);
546 assert(c);
547
548 return sd_bus_message_append(reply, "(bs)", c->apparmor_profile_ignore, c->apparmor_profile);
549 }
550
551 static int property_get_smack_process_label(
552 sd_bus *bus,
553 const char *path,
554 const char *interface,
555 const char *property,
556 sd_bus_message *reply,
557 void *userdata,
558 sd_bus_error *error) {
559
560 ExecContext *c = userdata;
561
562 assert(bus);
563 assert(reply);
564 assert(c);
565
566 return sd_bus_message_append(reply, "(bs)", c->smack_process_label_ignore, c->smack_process_label);
567 }
568
569 static int property_get_address_families(
570 sd_bus *bus,
571 const char *path,
572 const char *interface,
573 const char *property,
574 sd_bus_message *reply,
575 void *userdata,
576 sd_bus_error *error) {
577
578 ExecContext *c = userdata;
579 _cleanup_strv_free_ char **l = NULL;
580 void *af;
581 int r;
582
583 assert(bus);
584 assert(reply);
585 assert(c);
586
587 r = sd_bus_message_open_container(reply, 'r', "bas");
588 if (r < 0)
589 return r;
590
591 r = sd_bus_message_append(reply, "b", c->address_families_allow_list);
592 if (r < 0)
593 return r;
594
595 SET_FOREACH(af, c->address_families) {
596 const char *name;
597
598 name = af_to_name(PTR_TO_INT(af));
599 if (!name)
600 continue;
601
602 r = strv_extend(&l, name);
603 if (r < 0)
604 return -ENOMEM;
605 }
606
607 strv_sort(l);
608
609 r = sd_bus_message_append_strv(reply, l);
610 if (r < 0)
611 return r;
612
613 return sd_bus_message_close_container(reply);
614 }
615
616 static int property_get_working_directory(
617 sd_bus *bus,
618 const char *path,
619 const char *interface,
620 const char *property,
621 sd_bus_message *reply,
622 void *userdata,
623 sd_bus_error *error) {
624
625 ExecContext *c = userdata;
626 const char *wd;
627
628 assert(bus);
629 assert(reply);
630 assert(c);
631
632 if (c->working_directory_home)
633 wd = "~";
634 else
635 wd = c->working_directory;
636
637 if (c->working_directory_missing_ok)
638 wd = strjoina("!", wd);
639
640 return sd_bus_message_append(reply, "s", wd);
641 }
642
643 static int property_get_stdio_fdname(
644 sd_bus *bus,
645 const char *path,
646 const char *interface,
647 const char *property,
648 sd_bus_message *reply,
649 void *userdata,
650 sd_bus_error *error) {
651
652 ExecContext *c = userdata;
653 int fileno;
654
655 assert(bus);
656 assert(c);
657 assert(property);
658 assert(reply);
659
660 if (streq(property, "StandardInputFileDescriptorName"))
661 fileno = STDIN_FILENO;
662 else if (streq(property, "StandardOutputFileDescriptorName"))
663 fileno = STDOUT_FILENO;
664 else {
665 assert(streq(property, "StandardErrorFileDescriptorName"));
666 fileno = STDERR_FILENO;
667 }
668
669 return sd_bus_message_append(reply, "s", exec_context_fdname(c, fileno));
670 }
671
672 static int property_get_input_data(
673 sd_bus *bus,
674 const char *path,
675 const char *interface,
676 const char *property,
677 sd_bus_message *reply,
678 void *userdata,
679 sd_bus_error *error) {
680
681 ExecContext *c = userdata;
682
683 assert(bus);
684 assert(c);
685 assert(property);
686 assert(reply);
687
688 return sd_bus_message_append_array(reply, 'y', c->stdin_data, c->stdin_data_size);
689 }
690
691 static int property_get_bind_paths(
692 sd_bus *bus,
693 const char *path,
694 const char *interface,
695 const char *property,
696 sd_bus_message *reply,
697 void *userdata,
698 sd_bus_error *error) {
699
700 ExecContext *c = userdata;
701 bool ro;
702 int r;
703
704 assert(bus);
705 assert(c);
706 assert(property);
707 assert(reply);
708
709 ro = strstr(property, "ReadOnly");
710
711 r = sd_bus_message_open_container(reply, 'a', "(ssbt)");
712 if (r < 0)
713 return r;
714
715 for (size_t i = 0; i < c->n_bind_mounts; i++) {
716
717 if (ro != c->bind_mounts[i].read_only)
718 continue;
719
720 r = sd_bus_message_append(
721 reply, "(ssbt)",
722 c->bind_mounts[i].source,
723 c->bind_mounts[i].destination,
724 c->bind_mounts[i].ignore_enoent,
725 c->bind_mounts[i].recursive ? (uint64_t) MS_REC : (uint64_t) 0);
726 if (r < 0)
727 return r;
728 }
729
730 return sd_bus_message_close_container(reply);
731 }
732
733 static int property_get_temporary_filesystems(
734 sd_bus *bus,
735 const char *path,
736 const char *interface,
737 const char *property,
738 sd_bus_message *reply,
739 void *userdata,
740 sd_bus_error *error) {
741
742 ExecContext *c = userdata;
743 int r;
744
745 assert(bus);
746 assert(c);
747 assert(property);
748 assert(reply);
749
750 r = sd_bus_message_open_container(reply, 'a', "(ss)");
751 if (r < 0)
752 return r;
753
754 for (unsigned i = 0; i < c->n_temporary_filesystems; i++) {
755 TemporaryFileSystem *t = c->temporary_filesystems + i;
756
757 r = sd_bus_message_append(
758 reply, "(ss)",
759 t->path,
760 t->options);
761 if (r < 0)
762 return r;
763 }
764
765 return sd_bus_message_close_container(reply);
766 }
767
768 static int property_get_log_extra_fields(
769 sd_bus *bus,
770 const char *path,
771 const char *interface,
772 const char *property,
773 sd_bus_message *reply,
774 void *userdata,
775 sd_bus_error *error) {
776
777 ExecContext *c = userdata;
778 int r;
779
780 assert(bus);
781 assert(c);
782 assert(property);
783 assert(reply);
784
785 r = sd_bus_message_open_container(reply, 'a', "ay");
786 if (r < 0)
787 return r;
788
789 for (size_t i = 0; i < c->n_log_extra_fields; i++) {
790 r = sd_bus_message_append_array(reply, 'y', c->log_extra_fields[i].iov_base, c->log_extra_fields[i].iov_len);
791 if (r < 0)
792 return r;
793 }
794
795 return sd_bus_message_close_container(reply);
796 }
797
798 static int property_get_set_credential(
799 sd_bus *bus,
800 const char *path,
801 const char *interface,
802 const char *property,
803 sd_bus_message *reply,
804 void *userdata,
805 sd_bus_error *error) {
806
807 ExecContext *c = userdata;
808 ExecSetCredential *sc;
809 int r;
810
811 assert(bus);
812 assert(c);
813 assert(property);
814 assert(reply);
815
816 r = sd_bus_message_open_container(reply, 'a', "(say)");
817 if (r < 0)
818 return r;
819
820 HASHMAP_FOREACH(sc, c->set_credentials) {
821
822 r = sd_bus_message_open_container(reply, 'r', "say");
823 if (r < 0)
824 return r;
825
826 r = sd_bus_message_append(reply, "s", sc->id);
827 if (r < 0)
828 return r;
829
830 r = sd_bus_message_append_array(reply, 'y', sc->data, sc->size);
831 if (r < 0)
832 return r;
833
834 r = sd_bus_message_close_container(reply);
835 if (r < 0)
836 return r;
837 }
838
839 return sd_bus_message_close_container(reply);
840 }
841
842 static int property_get_load_credential(
843 sd_bus *bus,
844 const char *path,
845 const char *interface,
846 const char *property,
847 sd_bus_message *reply,
848 void *userdata,
849 sd_bus_error *error) {
850
851 ExecContext *c = userdata;
852 char **i, **j;
853 int r;
854
855 assert(bus);
856 assert(c);
857 assert(property);
858 assert(reply);
859
860 r = sd_bus_message_open_container(reply, 'a', "(ss)");
861 if (r < 0)
862 return r;
863
864 STRV_FOREACH_PAIR(i, j, c->load_credentials) {
865 r = sd_bus_message_append(reply, "(ss)", *i, *j);
866 if (r < 0)
867 return r;
868 }
869
870 return sd_bus_message_close_container(reply);
871 }
872
873 static int property_get_root_hash(
874 sd_bus *bus,
875 const char *path,
876 const char *interface,
877 const char *property,
878 sd_bus_message *reply,
879 void *userdata,
880 sd_bus_error *error) {
881
882 ExecContext *c = userdata;
883
884 assert(bus);
885 assert(c);
886 assert(property);
887 assert(reply);
888
889 return sd_bus_message_append_array(reply, 'y', c->root_hash, c->root_hash_size);
890 }
891
892 static int property_get_root_hash_sig(
893 sd_bus *bus,
894 const char *path,
895 const char *interface,
896 const char *property,
897 sd_bus_message *reply,
898 void *userdata,
899 sd_bus_error *error) {
900
901 ExecContext *c = userdata;
902
903 assert(bus);
904 assert(c);
905 assert(property);
906 assert(reply);
907
908 return sd_bus_message_append_array(reply, 'y', c->root_hash_sig, c->root_hash_sig_size);
909 }
910
911 static int property_get_root_image_options(
912 sd_bus *bus,
913 const char *path,
914 const char *interface,
915 const char *property,
916 sd_bus_message *reply,
917 void *userdata,
918 sd_bus_error *error) {
919
920 ExecContext *c = userdata;
921 MountOptions *m;
922 int r;
923
924 assert(bus);
925 assert(c);
926 assert(property);
927 assert(reply);
928
929 r = sd_bus_message_open_container(reply, 'a', "(ss)");
930 if (r < 0)
931 return r;
932
933 LIST_FOREACH(mount_options, m, c->root_image_options) {
934 r = sd_bus_message_append(reply, "(ss)",
935 partition_designator_to_string(m->partition_designator),
936 m->options);
937 if (r < 0)
938 return r;
939 }
940
941 return sd_bus_message_close_container(reply);
942 }
943
944 static int property_get_mount_images(
945 sd_bus *bus,
946 const char *path,
947 const char *interface,
948 const char *property,
949 sd_bus_message *reply,
950 void *userdata,
951 sd_bus_error *error) {
952
953 ExecContext *c = userdata;
954 int r;
955
956 assert(bus);
957 assert(c);
958 assert(property);
959 assert(reply);
960
961 r = sd_bus_message_open_container(reply, 'a', "(ssba(ss))");
962 if (r < 0)
963 return r;
964
965 for (size_t i = 0; i < c->n_mount_images; i++) {
966 MountOptions *m;
967
968 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_STRUCT, "ssba(ss)");
969 if (r < 0)
970 return r;
971 r = sd_bus_message_append(
972 reply, "ssb",
973 c->mount_images[i].source,
974 c->mount_images[i].destination,
975 c->mount_images[i].ignore_enoent);
976 if (r < 0)
977 return r;
978 r = sd_bus_message_open_container(reply, 'a', "(ss)");
979 if (r < 0)
980 return r;
981 LIST_FOREACH(mount_options, m, c->mount_images[i].mount_options) {
982 r = sd_bus_message_append(reply, "(ss)",
983 partition_designator_to_string(m->partition_designator),
984 m->options);
985 if (r < 0)
986 return r;
987 }
988 r = sd_bus_message_close_container(reply);
989 if (r < 0)
990 return r;
991 r = sd_bus_message_close_container(reply);
992 if (r < 0)
993 return r;
994 }
995
996 return sd_bus_message_close_container(reply);
997 }
998
999 static int property_get_extension_images(
1000 sd_bus *bus,
1001 const char *path,
1002 const char *interface,
1003 const char *property,
1004 sd_bus_message *reply,
1005 void *userdata,
1006 sd_bus_error *error) {
1007
1008 ExecContext *c = userdata;
1009 int r;
1010
1011 assert(bus);
1012 assert(c);
1013 assert(property);
1014 assert(reply);
1015
1016 r = sd_bus_message_open_container(reply, 'a', "(sba(ss))");
1017 if (r < 0)
1018 return r;
1019
1020 for (size_t i = 0; i < c->n_extension_images; i++) {
1021 MountOptions *m;
1022
1023 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_STRUCT, "sba(ss)");
1024 if (r < 0)
1025 return r;
1026 r = sd_bus_message_append(
1027 reply, "sb",
1028 c->extension_images[i].source,
1029 c->extension_images[i].ignore_enoent);
1030 if (r < 0)
1031 return r;
1032 r = sd_bus_message_open_container(reply, 'a', "(ss)");
1033 if (r < 0)
1034 return r;
1035 LIST_FOREACH(mount_options, m, c->extension_images[i].mount_options) {
1036 r = sd_bus_message_append(reply, "(ss)",
1037 partition_designator_to_string(m->partition_designator),
1038 m->options);
1039 if (r < 0)
1040 return r;
1041 }
1042 r = sd_bus_message_close_container(reply);
1043 if (r < 0)
1044 return r;
1045 r = sd_bus_message_close_container(reply);
1046 if (r < 0)
1047 return r;
1048 }
1049
1050 return sd_bus_message_close_container(reply);
1051 }
1052
1053 const sd_bus_vtable bus_exec_vtable[] = {
1054 SD_BUS_VTABLE_START(0),
1055 SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(ExecContext, environment), SD_BUS_VTABLE_PROPERTY_CONST),
1056 SD_BUS_PROPERTY("EnvironmentFiles", "a(sb)", property_get_environment_files, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1057 SD_BUS_PROPERTY("PassEnvironment", "as", NULL, offsetof(ExecContext, pass_environment), SD_BUS_VTABLE_PROPERTY_CONST),
1058 SD_BUS_PROPERTY("UnsetEnvironment", "as", NULL, offsetof(ExecContext, unset_environment), SD_BUS_VTABLE_PROPERTY_CONST),
1059 SD_BUS_PROPERTY("UMask", "u", bus_property_get_mode, offsetof(ExecContext, umask), SD_BUS_VTABLE_PROPERTY_CONST),
1060 SD_BUS_PROPERTY("LimitCPU", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
1061 SD_BUS_PROPERTY("LimitCPUSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
1062 SD_BUS_PROPERTY("LimitFSIZE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
1063 SD_BUS_PROPERTY("LimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
1064 SD_BUS_PROPERTY("LimitDATA", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
1065 SD_BUS_PROPERTY("LimitDATASoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
1066 SD_BUS_PROPERTY("LimitSTACK", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
1067 SD_BUS_PROPERTY("LimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
1068 SD_BUS_PROPERTY("LimitCORE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
1069 SD_BUS_PROPERTY("LimitCORESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
1070 SD_BUS_PROPERTY("LimitRSS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
1071 SD_BUS_PROPERTY("LimitRSSSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
1072 SD_BUS_PROPERTY("LimitNOFILE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
1073 SD_BUS_PROPERTY("LimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
1074 SD_BUS_PROPERTY("LimitAS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
1075 SD_BUS_PROPERTY("LimitASSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
1076 SD_BUS_PROPERTY("LimitNPROC", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
1077 SD_BUS_PROPERTY("LimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
1078 SD_BUS_PROPERTY("LimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
1079 SD_BUS_PROPERTY("LimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
1080 SD_BUS_PROPERTY("LimitLOCKS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
1081 SD_BUS_PROPERTY("LimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
1082 SD_BUS_PROPERTY("LimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
1083 SD_BUS_PROPERTY("LimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
1084 SD_BUS_PROPERTY("LimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
1085 SD_BUS_PROPERTY("LimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
1086 SD_BUS_PROPERTY("LimitNICE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
1087 SD_BUS_PROPERTY("LimitNICESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
1088 SD_BUS_PROPERTY("LimitRTPRIO", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
1089 SD_BUS_PROPERTY("LimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
1090 SD_BUS_PROPERTY("LimitRTTIME", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
1091 SD_BUS_PROPERTY("LimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
1092 SD_BUS_PROPERTY("WorkingDirectory", "s", property_get_working_directory, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1093 SD_BUS_PROPERTY("RootDirectory", "s", NULL, offsetof(ExecContext, root_directory), SD_BUS_VTABLE_PROPERTY_CONST),
1094 SD_BUS_PROPERTY("RootImage", "s", NULL, offsetof(ExecContext, root_image), SD_BUS_VTABLE_PROPERTY_CONST),
1095 SD_BUS_PROPERTY("RootImageOptions", "a(ss)", property_get_root_image_options, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1096 SD_BUS_PROPERTY("RootHash", "ay", property_get_root_hash, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1097 SD_BUS_PROPERTY("RootHashPath", "s", NULL, offsetof(ExecContext, root_hash_path), SD_BUS_VTABLE_PROPERTY_CONST),
1098 SD_BUS_PROPERTY("RootHashSignature", "ay", property_get_root_hash_sig, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1099 SD_BUS_PROPERTY("RootHashSignaturePath", "s", NULL, offsetof(ExecContext, root_hash_sig_path), SD_BUS_VTABLE_PROPERTY_CONST),
1100 SD_BUS_PROPERTY("RootVerity", "s", NULL, offsetof(ExecContext, root_verity), SD_BUS_VTABLE_PROPERTY_CONST),
1101 SD_BUS_PROPERTY("ExtensionImages", "a(sba(ss))", property_get_extension_images, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1102 SD_BUS_PROPERTY("MountImages", "a(ssba(ss))", property_get_mount_images, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1103 SD_BUS_PROPERTY("OOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1104 SD_BUS_PROPERTY("CoredumpFilter", "t", property_get_coredump_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1105 SD_BUS_PROPERTY("Nice", "i", property_get_nice, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1106 SD_BUS_PROPERTY("IOSchedulingClass", "i", property_get_ioprio_class, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1107 SD_BUS_PROPERTY("IOSchedulingPriority", "i", property_get_ioprio_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1108 SD_BUS_PROPERTY("CPUSchedulingPolicy", "i", property_get_cpu_sched_policy, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1109 SD_BUS_PROPERTY("CPUSchedulingPriority", "i", property_get_cpu_sched_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1110 SD_BUS_PROPERTY("CPUAffinity", "ay", property_get_cpu_affinity, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1111 SD_BUS_PROPERTY("CPUAffinityFromNUMA", "b", property_get_cpu_affinity_from_numa, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1112 SD_BUS_PROPERTY("NUMAPolicy", "i", property_get_numa_policy, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1113 SD_BUS_PROPERTY("NUMAMask", "ay", property_get_numa_mask, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1114 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1115 SD_BUS_PROPERTY("CPUSchedulingResetOnFork", "b", bus_property_get_bool, offsetof(ExecContext, cpu_sched_reset_on_fork), SD_BUS_VTABLE_PROPERTY_CONST),
1116 SD_BUS_PROPERTY("NonBlocking", "b", bus_property_get_bool, offsetof(ExecContext, non_blocking), SD_BUS_VTABLE_PROPERTY_CONST),
1117 SD_BUS_PROPERTY("StandardInput", "s", property_get_exec_input, offsetof(ExecContext, std_input), SD_BUS_VTABLE_PROPERTY_CONST),
1118 SD_BUS_PROPERTY("StandardInputFileDescriptorName", "s", property_get_stdio_fdname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1119 SD_BUS_PROPERTY("StandardInputData", "ay", property_get_input_data, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1120 SD_BUS_PROPERTY("StandardOutput", "s", bus_property_get_exec_output, offsetof(ExecContext, std_output), SD_BUS_VTABLE_PROPERTY_CONST),
1121 SD_BUS_PROPERTY("StandardOutputFileDescriptorName", "s", property_get_stdio_fdname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1122 SD_BUS_PROPERTY("StandardError", "s", bus_property_get_exec_output, offsetof(ExecContext, std_error), SD_BUS_VTABLE_PROPERTY_CONST),
1123 SD_BUS_PROPERTY("StandardErrorFileDescriptorName", "s", property_get_stdio_fdname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1124 SD_BUS_PROPERTY("TTYPath", "s", NULL, offsetof(ExecContext, tty_path), SD_BUS_VTABLE_PROPERTY_CONST),
1125 SD_BUS_PROPERTY("TTYReset", "b", bus_property_get_bool, offsetof(ExecContext, tty_reset), SD_BUS_VTABLE_PROPERTY_CONST),
1126 SD_BUS_PROPERTY("TTYVHangup", "b", bus_property_get_bool, offsetof(ExecContext, tty_vhangup), SD_BUS_VTABLE_PROPERTY_CONST),
1127 SD_BUS_PROPERTY("TTYVTDisallocate", "b", bus_property_get_bool, offsetof(ExecContext, tty_vt_disallocate), SD_BUS_VTABLE_PROPERTY_CONST),
1128 SD_BUS_PROPERTY("SyslogPriority", "i", bus_property_get_int, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
1129 SD_BUS_PROPERTY("SyslogIdentifier", "s", NULL, offsetof(ExecContext, syslog_identifier), SD_BUS_VTABLE_PROPERTY_CONST),
1130 SD_BUS_PROPERTY("SyslogLevelPrefix", "b", bus_property_get_bool, offsetof(ExecContext, syslog_level_prefix), SD_BUS_VTABLE_PROPERTY_CONST),
1131 SD_BUS_PROPERTY("SyslogLevel", "i", property_get_syslog_level, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
1132 SD_BUS_PROPERTY("SyslogFacility", "i", property_get_syslog_facility, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
1133 SD_BUS_PROPERTY("LogLevelMax", "i", bus_property_get_int, offsetof(ExecContext, log_level_max), SD_BUS_VTABLE_PROPERTY_CONST),
1134 SD_BUS_PROPERTY("LogRateLimitIntervalUSec", "t", bus_property_get_usec, offsetof(ExecContext, log_ratelimit_interval_usec), SD_BUS_VTABLE_PROPERTY_CONST),
1135 SD_BUS_PROPERTY("LogRateLimitBurst", "u", bus_property_get_unsigned, offsetof(ExecContext, log_ratelimit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
1136 SD_BUS_PROPERTY("LogExtraFields", "aay", property_get_log_extra_fields, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1137 SD_BUS_PROPERTY("LogNamespace", "s", NULL, offsetof(ExecContext, log_namespace), SD_BUS_VTABLE_PROPERTY_CONST),
1138 SD_BUS_PROPERTY("SecureBits", "i", bus_property_get_int, offsetof(ExecContext, secure_bits), SD_BUS_VTABLE_PROPERTY_CONST),
1139 SD_BUS_PROPERTY("CapabilityBoundingSet", "t", NULL, offsetof(ExecContext, capability_bounding_set), SD_BUS_VTABLE_PROPERTY_CONST),
1140 SD_BUS_PROPERTY("AmbientCapabilities", "t", NULL, offsetof(ExecContext, capability_ambient_set), SD_BUS_VTABLE_PROPERTY_CONST),
1141 SD_BUS_PROPERTY("User", "s", NULL, offsetof(ExecContext, user), SD_BUS_VTABLE_PROPERTY_CONST),
1142 SD_BUS_PROPERTY("Group", "s", NULL, offsetof(ExecContext, group), SD_BUS_VTABLE_PROPERTY_CONST),
1143 SD_BUS_PROPERTY("DynamicUser", "b", bus_property_get_bool, offsetof(ExecContext, dynamic_user), SD_BUS_VTABLE_PROPERTY_CONST),
1144 SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool, offsetof(ExecContext, remove_ipc), SD_BUS_VTABLE_PROPERTY_CONST),
1145 SD_BUS_PROPERTY("SetCredential", "a(say)", property_get_set_credential, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1146 SD_BUS_PROPERTY("LoadCredential", "a(ss)", property_get_load_credential, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1147 SD_BUS_PROPERTY("SupplementaryGroups", "as", NULL, offsetof(ExecContext, supplementary_groups), SD_BUS_VTABLE_PROPERTY_CONST),
1148 SD_BUS_PROPERTY("PAMName", "s", NULL, offsetof(ExecContext, pam_name), SD_BUS_VTABLE_PROPERTY_CONST),
1149 SD_BUS_PROPERTY("ReadWritePaths", "as", NULL, offsetof(ExecContext, read_write_paths), SD_BUS_VTABLE_PROPERTY_CONST),
1150 SD_BUS_PROPERTY("ReadOnlyPaths", "as", NULL, offsetof(ExecContext, read_only_paths), SD_BUS_VTABLE_PROPERTY_CONST),
1151 SD_BUS_PROPERTY("InaccessiblePaths", "as", NULL, offsetof(ExecContext, inaccessible_paths), SD_BUS_VTABLE_PROPERTY_CONST),
1152 SD_BUS_PROPERTY("ExecPaths", "as", NULL, offsetof(ExecContext, exec_paths), SD_BUS_VTABLE_PROPERTY_CONST),
1153 SD_BUS_PROPERTY("NoExecPaths", "as", NULL, offsetof(ExecContext, no_exec_paths), SD_BUS_VTABLE_PROPERTY_CONST),
1154 SD_BUS_PROPERTY("MountFlags", "t", bus_property_get_ulong, offsetof(ExecContext, mount_flags), SD_BUS_VTABLE_PROPERTY_CONST),
1155 SD_BUS_PROPERTY("PrivateTmp", "b", bus_property_get_bool, offsetof(ExecContext, private_tmp), SD_BUS_VTABLE_PROPERTY_CONST),
1156 SD_BUS_PROPERTY("PrivateDevices", "b", bus_property_get_bool, offsetof(ExecContext, private_devices), SD_BUS_VTABLE_PROPERTY_CONST),
1157 SD_BUS_PROPERTY("ProtectClock", "b", bus_property_get_bool, offsetof(ExecContext, protect_clock), SD_BUS_VTABLE_PROPERTY_CONST),
1158 SD_BUS_PROPERTY("ProtectKernelTunables", "b", bus_property_get_bool, offsetof(ExecContext, protect_kernel_tunables), SD_BUS_VTABLE_PROPERTY_CONST),
1159 SD_BUS_PROPERTY("ProtectKernelModules", "b", bus_property_get_bool, offsetof(ExecContext, protect_kernel_modules), SD_BUS_VTABLE_PROPERTY_CONST),
1160 SD_BUS_PROPERTY("ProtectKernelLogs", "b", bus_property_get_bool, offsetof(ExecContext, protect_kernel_logs), SD_BUS_VTABLE_PROPERTY_CONST),
1161 SD_BUS_PROPERTY("ProtectControlGroups", "b", bus_property_get_bool, offsetof(ExecContext, protect_control_groups), SD_BUS_VTABLE_PROPERTY_CONST),
1162 SD_BUS_PROPERTY("PrivateNetwork", "b", bus_property_get_bool, offsetof(ExecContext, private_network), SD_BUS_VTABLE_PROPERTY_CONST),
1163 SD_BUS_PROPERTY("PrivateUsers", "b", bus_property_get_bool, offsetof(ExecContext, private_users), SD_BUS_VTABLE_PROPERTY_CONST),
1164 SD_BUS_PROPERTY("PrivateMounts", "b", bus_property_get_bool, offsetof(ExecContext, private_mounts), SD_BUS_VTABLE_PROPERTY_CONST),
1165 SD_BUS_PROPERTY("PrivateIPC", "b", bus_property_get_bool, offsetof(ExecContext, private_ipc), SD_BUS_VTABLE_PROPERTY_CONST),
1166 SD_BUS_PROPERTY("ProtectHome", "s", property_get_protect_home, offsetof(ExecContext, protect_home), SD_BUS_VTABLE_PROPERTY_CONST),
1167 SD_BUS_PROPERTY("ProtectSystem", "s", property_get_protect_system, offsetof(ExecContext, protect_system), SD_BUS_VTABLE_PROPERTY_CONST),
1168 SD_BUS_PROPERTY("SameProcessGroup", "b", bus_property_get_bool, offsetof(ExecContext, same_pgrp), SD_BUS_VTABLE_PROPERTY_CONST),
1169 SD_BUS_PROPERTY("UtmpIdentifier", "s", NULL, offsetof(ExecContext, utmp_id), SD_BUS_VTABLE_PROPERTY_CONST),
1170 SD_BUS_PROPERTY("UtmpMode", "s", property_get_exec_utmp_mode, offsetof(ExecContext, utmp_mode), SD_BUS_VTABLE_PROPERTY_CONST),
1171 SD_BUS_PROPERTY("SELinuxContext", "(bs)", property_get_selinux_context, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1172 SD_BUS_PROPERTY("AppArmorProfile", "(bs)", property_get_apparmor_profile, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1173 SD_BUS_PROPERTY("SmackProcessLabel", "(bs)", property_get_smack_process_label, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1174 SD_BUS_PROPERTY("IgnoreSIGPIPE", "b", bus_property_get_bool, offsetof(ExecContext, ignore_sigpipe), SD_BUS_VTABLE_PROPERTY_CONST),
1175 SD_BUS_PROPERTY("NoNewPrivileges", "b", bus_property_get_bool, offsetof(ExecContext, no_new_privileges), SD_BUS_VTABLE_PROPERTY_CONST),
1176 SD_BUS_PROPERTY("SystemCallFilter", "(bas)", property_get_syscall_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1177 SD_BUS_PROPERTY("SystemCallArchitectures", "as", property_get_syscall_archs, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1178 SD_BUS_PROPERTY("SystemCallErrorNumber", "i", bus_property_get_int, offsetof(ExecContext, syscall_errno), SD_BUS_VTABLE_PROPERTY_CONST),
1179 SD_BUS_PROPERTY("SystemCallLog", "(bas)", property_get_syscall_log, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1180 SD_BUS_PROPERTY("Personality", "s", property_get_personality, offsetof(ExecContext, personality), SD_BUS_VTABLE_PROPERTY_CONST),
1181 SD_BUS_PROPERTY("LockPersonality", "b", bus_property_get_bool, offsetof(ExecContext, lock_personality), SD_BUS_VTABLE_PROPERTY_CONST),
1182 SD_BUS_PROPERTY("RestrictAddressFamilies", "(bas)", property_get_address_families, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1183 SD_BUS_PROPERTY("RuntimeDirectoryPreserve", "s", property_get_exec_preserve_mode, offsetof(ExecContext, runtime_directory_preserve_mode), SD_BUS_VTABLE_PROPERTY_CONST),
1184 SD_BUS_PROPERTY("RuntimeDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_RUNTIME].mode), SD_BUS_VTABLE_PROPERTY_CONST),
1185 SD_BUS_PROPERTY("RuntimeDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_RUNTIME].paths), SD_BUS_VTABLE_PROPERTY_CONST),
1186 SD_BUS_PROPERTY("StateDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_STATE].mode), SD_BUS_VTABLE_PROPERTY_CONST),
1187 SD_BUS_PROPERTY("StateDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_STATE].paths), SD_BUS_VTABLE_PROPERTY_CONST),
1188 SD_BUS_PROPERTY("CacheDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_CACHE].mode), SD_BUS_VTABLE_PROPERTY_CONST),
1189 SD_BUS_PROPERTY("CacheDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_CACHE].paths), SD_BUS_VTABLE_PROPERTY_CONST),
1190 SD_BUS_PROPERTY("LogsDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_LOGS].mode), SD_BUS_VTABLE_PROPERTY_CONST),
1191 SD_BUS_PROPERTY("LogsDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_LOGS].paths), SD_BUS_VTABLE_PROPERTY_CONST),
1192 SD_BUS_PROPERTY("ConfigurationDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_CONFIGURATION].mode), SD_BUS_VTABLE_PROPERTY_CONST),
1193 SD_BUS_PROPERTY("ConfigurationDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_CONFIGURATION].paths), SD_BUS_VTABLE_PROPERTY_CONST),
1194 SD_BUS_PROPERTY("TimeoutCleanUSec", "t", bus_property_get_usec, offsetof(ExecContext, timeout_clean_usec), SD_BUS_VTABLE_PROPERTY_CONST),
1195 SD_BUS_PROPERTY("MemoryDenyWriteExecute", "b", bus_property_get_bool, offsetof(ExecContext, memory_deny_write_execute), SD_BUS_VTABLE_PROPERTY_CONST),
1196 SD_BUS_PROPERTY("RestrictRealtime", "b", bus_property_get_bool, offsetof(ExecContext, restrict_realtime), SD_BUS_VTABLE_PROPERTY_CONST),
1197 SD_BUS_PROPERTY("RestrictSUIDSGID", "b", bus_property_get_bool, offsetof(ExecContext, restrict_suid_sgid), SD_BUS_VTABLE_PROPERTY_CONST),
1198 SD_BUS_PROPERTY("RestrictNamespaces", "t", bus_property_get_ulong, offsetof(ExecContext, restrict_namespaces), SD_BUS_VTABLE_PROPERTY_CONST),
1199 SD_BUS_PROPERTY("BindPaths", "a(ssbt)", property_get_bind_paths, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1200 SD_BUS_PROPERTY("BindReadOnlyPaths", "a(ssbt)", property_get_bind_paths, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1201 SD_BUS_PROPERTY("TemporaryFileSystem", "a(ss)", property_get_temporary_filesystems, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1202 SD_BUS_PROPERTY("MountAPIVFS", "b", property_get_mount_apivfs, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1203 SD_BUS_PROPERTY("KeyringMode", "s", property_get_exec_keyring_mode, offsetof(ExecContext, keyring_mode), SD_BUS_VTABLE_PROPERTY_CONST),
1204 SD_BUS_PROPERTY("ProtectProc", "s", property_get_protect_proc, offsetof(ExecContext, protect_proc), SD_BUS_VTABLE_PROPERTY_CONST),
1205 SD_BUS_PROPERTY("ProcSubset", "s", property_get_proc_subset, offsetof(ExecContext, proc_subset), SD_BUS_VTABLE_PROPERTY_CONST),
1206 SD_BUS_PROPERTY("ProtectHostname", "b", bus_property_get_bool, offsetof(ExecContext, protect_hostname), SD_BUS_VTABLE_PROPERTY_CONST),
1207 SD_BUS_PROPERTY("NetworkNamespacePath", "s", NULL, offsetof(ExecContext, network_namespace_path), SD_BUS_VTABLE_PROPERTY_CONST),
1208 SD_BUS_PROPERTY("IPCNamespacePath", "s", NULL, offsetof(ExecContext, ipc_namespace_path), SD_BUS_VTABLE_PROPERTY_CONST),
1209
1210 /* Obsolete/redundant properties: */
1211 SD_BUS_PROPERTY("Capabilities", "s", property_get_empty_string, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
1212 SD_BUS_PROPERTY("ReadWriteDirectories", "as", NULL, offsetof(ExecContext, read_write_paths), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
1213 SD_BUS_PROPERTY("ReadOnlyDirectories", "as", NULL, offsetof(ExecContext, read_only_paths), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
1214 SD_BUS_PROPERTY("InaccessibleDirectories", "as", NULL, offsetof(ExecContext, inaccessible_paths), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
1215 SD_BUS_PROPERTY("IOScheduling", "i", property_get_ioprio, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
1216
1217 SD_BUS_VTABLE_END
1218 };
1219
1220 static int append_exec_command(sd_bus_message *reply, ExecCommand *c) {
1221 int r;
1222
1223 assert(reply);
1224 assert(c);
1225
1226 if (!c->path)
1227 return 0;
1228
1229 r = sd_bus_message_open_container(reply, 'r', "sasbttttuii");
1230 if (r < 0)
1231 return r;
1232
1233 r = sd_bus_message_append(reply, "s", c->path);
1234 if (r < 0)
1235 return r;
1236
1237 r = sd_bus_message_append_strv(reply, c->argv);
1238 if (r < 0)
1239 return r;
1240
1241 r = sd_bus_message_append(reply, "bttttuii",
1242 !!(c->flags & EXEC_COMMAND_IGNORE_FAILURE),
1243 c->exec_status.start_timestamp.realtime,
1244 c->exec_status.start_timestamp.monotonic,
1245 c->exec_status.exit_timestamp.realtime,
1246 c->exec_status.exit_timestamp.monotonic,
1247 (uint32_t) c->exec_status.pid,
1248 (int32_t) c->exec_status.code,
1249 (int32_t) c->exec_status.status);
1250 if (r < 0)
1251 return r;
1252
1253 return sd_bus_message_close_container(reply);
1254 }
1255
1256 static int append_exec_ex_command(sd_bus_message *reply, ExecCommand *c) {
1257 _cleanup_strv_free_ char **ex_opts = NULL;
1258 int r;
1259
1260 assert(reply);
1261 assert(c);
1262
1263 if (!c->path)
1264 return 0;
1265
1266 r = sd_bus_message_open_container(reply, 'r', "sasasttttuii");
1267 if (r < 0)
1268 return r;
1269
1270 r = sd_bus_message_append(reply, "s", c->path);
1271 if (r < 0)
1272 return r;
1273
1274 r = sd_bus_message_append_strv(reply, c->argv);
1275 if (r < 0)
1276 return r;
1277
1278 r = exec_command_flags_to_strv(c->flags, &ex_opts);
1279 if (r < 0)
1280 return r;
1281
1282 r = sd_bus_message_append_strv(reply, ex_opts);
1283 if (r < 0)
1284 return r;
1285
1286 r = sd_bus_message_append(reply, "ttttuii",
1287 c->exec_status.start_timestamp.realtime,
1288 c->exec_status.start_timestamp.monotonic,
1289 c->exec_status.exit_timestamp.realtime,
1290 c->exec_status.exit_timestamp.monotonic,
1291 (uint32_t) c->exec_status.pid,
1292 (int32_t) c->exec_status.code,
1293 (int32_t) c->exec_status.status);
1294 if (r < 0)
1295 return r;
1296
1297 return sd_bus_message_close_container(reply);
1298 }
1299
1300 int bus_property_get_exec_command(
1301 sd_bus *bus,
1302 const char *path,
1303 const char *interface,
1304 const char *property,
1305 sd_bus_message *reply,
1306 void *userdata,
1307 sd_bus_error *ret_error) {
1308
1309 ExecCommand *c = (ExecCommand*) userdata;
1310 int r;
1311
1312 assert(bus);
1313 assert(reply);
1314
1315 r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
1316 if (r < 0)
1317 return r;
1318
1319 r = append_exec_command(reply, c);
1320 if (r < 0)
1321 return r;
1322
1323 return sd_bus_message_close_container(reply);
1324 }
1325
1326 int bus_property_get_exec_command_list(
1327 sd_bus *bus,
1328 const char *path,
1329 const char *interface,
1330 const char *property,
1331 sd_bus_message *reply,
1332 void *userdata,
1333 sd_bus_error *ret_error) {
1334
1335 ExecCommand *c = *(ExecCommand**) userdata;
1336 int r;
1337
1338 assert(bus);
1339 assert(reply);
1340
1341 r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
1342 if (r < 0)
1343 return r;
1344
1345 LIST_FOREACH(command, c, c) {
1346 r = append_exec_command(reply, c);
1347 if (r < 0)
1348 return r;
1349 }
1350
1351 return sd_bus_message_close_container(reply);
1352 }
1353
1354 int bus_property_get_exec_ex_command_list(
1355 sd_bus *bus,
1356 const char *path,
1357 const char *interface,
1358 const char *property,
1359 sd_bus_message *reply,
1360 void *userdata,
1361 sd_bus_error *ret_error) {
1362
1363 ExecCommand *c, *exec_command = *(ExecCommand**) userdata;
1364 int r;
1365
1366 assert(bus);
1367 assert(reply);
1368
1369 r = sd_bus_message_open_container(reply, 'a', "(sasasttttuii)");
1370 if (r < 0)
1371 return r;
1372
1373 LIST_FOREACH(command, c, exec_command) {
1374 r = append_exec_ex_command(reply, c);
1375 if (r < 0)
1376 return r;
1377 }
1378
1379 return sd_bus_message_close_container(reply);
1380 }
1381
1382 static char *exec_command_flags_to_exec_chars(ExecCommandFlags flags) {
1383 return strjoin(FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE) ? "-" : "",
1384 FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND) ? ":" : "",
1385 FLAGS_SET(flags, EXEC_COMMAND_FULLY_PRIVILEGED) ? "+" : "",
1386 FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID) ? "!" : "",
1387 FLAGS_SET(flags, EXEC_COMMAND_AMBIENT_MAGIC) ? "!!" : "");
1388 }
1389
1390 int bus_set_transient_exec_command(
1391 Unit *u,
1392 const char *name,
1393 ExecCommand **exec_command,
1394 sd_bus_message *message,
1395 UnitWriteFlags flags,
1396 sd_bus_error *error) {
1397 bool is_ex_prop = endswith(name, "Ex");
1398 unsigned n = 0;
1399 int r;
1400
1401 r = sd_bus_message_enter_container(message, 'a', is_ex_prop ? "(sasas)" : "(sasb)");
1402 if (r < 0)
1403 return r;
1404
1405 while ((r = sd_bus_message_enter_container(message, 'r', is_ex_prop ? "sasas" : "sasb")) > 0) {
1406 _cleanup_strv_free_ char **argv = NULL, **ex_opts = NULL;
1407 const char *path;
1408 int b;
1409
1410 r = sd_bus_message_read(message, "s", &path);
1411 if (r < 0)
1412 return r;
1413
1414 if (!path_is_absolute(path) && !filename_is_valid(path))
1415 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1416 "\"%s\" is neither a valid executable name nor an absolute path",
1417 path);
1418
1419 r = sd_bus_message_read_strv(message, &argv);
1420 if (r < 0)
1421 return r;
1422
1423 r = is_ex_prop ? sd_bus_message_read_strv(message, &ex_opts) : sd_bus_message_read(message, "b", &b);
1424 if (r < 0)
1425 return r;
1426
1427 r = sd_bus_message_exit_container(message);
1428 if (r < 0)
1429 return r;
1430
1431 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1432 ExecCommand *c;
1433
1434 c = new0(ExecCommand, 1);
1435 if (!c)
1436 return -ENOMEM;
1437
1438 c->path = strdup(path);
1439 if (!c->path) {
1440 free(c);
1441 return -ENOMEM;
1442 }
1443
1444 c->argv = TAKE_PTR(argv);
1445
1446 if (is_ex_prop) {
1447 r = exec_command_flags_from_strv(ex_opts, &c->flags);
1448 if (r < 0)
1449 return r;
1450 } else
1451 c->flags = b ? EXEC_COMMAND_IGNORE_FAILURE : 0;
1452
1453 path_simplify(c->path, false);
1454 exec_command_append_list(exec_command, c);
1455 }
1456
1457 n++;
1458 }
1459 if (r < 0)
1460 return r;
1461
1462 r = sd_bus_message_exit_container(message);
1463 if (r < 0)
1464 return r;
1465
1466 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1467 _cleanup_free_ char *buf = NULL;
1468 _cleanup_fclose_ FILE *f = NULL;
1469 ExecCommand *c;
1470 size_t size = 0;
1471
1472 if (n == 0)
1473 *exec_command = exec_command_free_list(*exec_command);
1474
1475 f = open_memstream_unlocked(&buf, &size);
1476 if (!f)
1477 return -ENOMEM;
1478
1479 fprintf(f, "%s=\n", name);
1480
1481 LIST_FOREACH(command, c, *exec_command) {
1482 _cleanup_free_ char *a = NULL, *exec_chars = NULL;
1483
1484 exec_chars = exec_command_flags_to_exec_chars(c->flags);
1485 if (!exec_chars)
1486 return -ENOMEM;
1487
1488 a = unit_concat_strv(c->argv, UNIT_ESCAPE_C|UNIT_ESCAPE_SPECIFIERS);
1489 if (!a)
1490 return -ENOMEM;
1491
1492 if (streq_ptr(c->path, c->argv ? c->argv[0] : NULL))
1493 fprintf(f, "%s=%s%s\n", name, exec_chars, a);
1494 else {
1495 _cleanup_free_ char *t = NULL;
1496 const char *p;
1497
1498 p = unit_escape_setting(c->path, UNIT_ESCAPE_C|UNIT_ESCAPE_SPECIFIERS, &t);
1499 if (!p)
1500 return -ENOMEM;
1501
1502 fprintf(f, "%s=%s@%s %s\n", name, exec_chars, p, a);
1503 }
1504 }
1505
1506 r = fflush_and_check(f);
1507 if (r < 0)
1508 return r;
1509
1510 unit_write_setting(u, flags, name, buf);
1511 }
1512
1513 return 1;
1514 }
1515
1516 static int parse_personality(const char *s, unsigned long *p) {
1517 unsigned long v;
1518
1519 assert(p);
1520
1521 v = personality_from_string(s);
1522 if (v == PERSONALITY_INVALID)
1523 return -EINVAL;
1524
1525 *p = v;
1526 return 0;
1527 }
1528
1529 static const char* mount_propagation_flags_to_string_with_check(unsigned long n) {
1530 if (!IN_SET(n, 0, MS_SHARED, MS_PRIVATE, MS_SLAVE))
1531 return NULL;
1532
1533 return mount_propagation_flags_to_string(n);
1534 }
1535
1536 static BUS_DEFINE_SET_TRANSIENT(nsec, "t", uint64_t, nsec_t, NSEC_FMT);
1537 static BUS_DEFINE_SET_TRANSIENT_IS_VALID(log_level, "i", int32_t, int, "%" PRIi32, log_level_is_valid);
1538 #if HAVE_SECCOMP
1539 static BUS_DEFINE_SET_TRANSIENT_IS_VALID(errno, "i", int32_t, int, "%" PRIi32, seccomp_errno_or_action_is_valid);
1540 #endif
1541 static BUS_DEFINE_SET_TRANSIENT_PARSE(std_input, ExecInput, exec_input_from_string);
1542 static BUS_DEFINE_SET_TRANSIENT_PARSE(std_output, ExecOutput, exec_output_from_string);
1543 static BUS_DEFINE_SET_TRANSIENT_PARSE(utmp_mode, ExecUtmpMode, exec_utmp_mode_from_string);
1544 static BUS_DEFINE_SET_TRANSIENT_PARSE(protect_system, ProtectSystem, protect_system_from_string);
1545 static BUS_DEFINE_SET_TRANSIENT_PARSE(protect_home, ProtectHome, protect_home_from_string);
1546 static BUS_DEFINE_SET_TRANSIENT_PARSE(keyring_mode, ExecKeyringMode, exec_keyring_mode_from_string);
1547 static BUS_DEFINE_SET_TRANSIENT_PARSE(protect_proc, ProtectProc, protect_proc_from_string);
1548 static BUS_DEFINE_SET_TRANSIENT_PARSE(proc_subset, ProcSubset, proc_subset_from_string);
1549 static BUS_DEFINE_SET_TRANSIENT_PARSE(preserve_mode, ExecPreserveMode, exec_preserve_mode_from_string);
1550 static BUS_DEFINE_SET_TRANSIENT_PARSE_PTR(personality, unsigned long, parse_personality);
1551 static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(secure_bits, "i", int32_t, int, "%" PRIi32, secure_bits_to_string_alloc_with_check);
1552 static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(capability, "t", uint64_t, uint64_t, "%" PRIu64, capability_set_to_string_alloc);
1553 static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(namespace_flag, "t", uint64_t, unsigned long, "%" PRIu64, namespace_flags_to_string);
1554 static BUS_DEFINE_SET_TRANSIENT_TO_STRING(mount_flags, "t", uint64_t, unsigned long, "%" PRIu64, mount_propagation_flags_to_string_with_check);
1555
1556 int bus_exec_context_set_transient_property(
1557 Unit *u,
1558 ExecContext *c,
1559 const char *name,
1560 sd_bus_message *message,
1561 UnitWriteFlags flags,
1562 sd_bus_error *error) {
1563
1564 const char *suffix;
1565 int r;
1566
1567 assert(u);
1568 assert(c);
1569 assert(name);
1570 assert(message);
1571
1572 flags |= UNIT_PRIVATE;
1573
1574 if (streq(name, "User"))
1575 return bus_set_transient_user_relaxed(u, name, &c->user, message, flags, error);
1576
1577 if (streq(name, "Group"))
1578 return bus_set_transient_user_relaxed(u, name, &c->group, message, flags, error);
1579
1580 if (streq(name, "TTYPath"))
1581 return bus_set_transient_path(u, name, &c->tty_path, message, flags, error);
1582
1583 if (streq(name, "RootImage"))
1584 return bus_set_transient_path(u, name, &c->root_image, message, flags, error);
1585
1586 if (streq(name, "RootImageOptions")) {
1587 _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
1588 _cleanup_free_ char *format_str = NULL;
1589
1590 r = bus_read_mount_options(message, error, &options, &format_str, " ");
1591 if (r < 0)
1592 return r;
1593
1594 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1595 if (LIST_IS_EMPTY(options)) {
1596 c->root_image_options = mount_options_free_all(c->root_image_options);
1597 unit_write_settingf(u, flags, name, "%s=", name);
1598 } else {
1599 LIST_JOIN(mount_options, c->root_image_options, options);
1600 unit_write_settingf(
1601 u, flags|UNIT_ESCAPE_SPECIFIERS, name,
1602 "%s=%s",
1603 name,
1604 format_str);
1605 }
1606 }
1607
1608 return 1;
1609 }
1610
1611 if (streq(name, "RootHash")) {
1612 const void *roothash_decoded;
1613 size_t roothash_decoded_size;
1614
1615 r = sd_bus_message_read_array(message, 'y', &roothash_decoded, &roothash_decoded_size);
1616 if (r < 0)
1617 return r;
1618
1619 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1620 _cleanup_free_ char *encoded = NULL;
1621
1622 if (roothash_decoded_size == 0) {
1623 c->root_hash_path = mfree(c->root_hash_path);
1624 c->root_hash = mfree(c->root_hash);
1625 c->root_hash_size = 0;
1626
1627 unit_write_settingf(u, flags, name, "RootHash=");
1628 } else {
1629 _cleanup_free_ void *p;
1630
1631 encoded = hexmem(roothash_decoded, roothash_decoded_size);
1632 if (!encoded)
1633 return -ENOMEM;
1634
1635 p = memdup(roothash_decoded, roothash_decoded_size);
1636 if (!p)
1637 return -ENOMEM;
1638
1639 free_and_replace(c->root_hash, p);
1640 c->root_hash_size = roothash_decoded_size;
1641 c->root_hash_path = mfree(c->root_hash_path);
1642
1643 unit_write_settingf(u, flags, name, "RootHash=%s", encoded);
1644 }
1645 }
1646
1647 return 1;
1648 }
1649
1650 if (streq(name, "RootHashPath")) {
1651 c->root_hash_size = 0;
1652 c->root_hash = mfree(c->root_hash);
1653
1654 return bus_set_transient_path(u, "RootHash", &c->root_hash_path, message, flags, error);
1655 }
1656
1657 if (streq(name, "RootHashSignature")) {
1658 const void *roothash_sig_decoded;
1659 size_t roothash_sig_decoded_size;
1660
1661 r = sd_bus_message_read_array(message, 'y', &roothash_sig_decoded, &roothash_sig_decoded_size);
1662 if (r < 0)
1663 return r;
1664
1665 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1666 _cleanup_free_ char *encoded = NULL;
1667
1668 if (roothash_sig_decoded_size == 0) {
1669 c->root_hash_sig_path = mfree(c->root_hash_sig_path);
1670 c->root_hash_sig = mfree(c->root_hash_sig);
1671 c->root_hash_sig_size = 0;
1672
1673 unit_write_settingf(u, flags, name, "RootHashSignature=");
1674 } else {
1675 _cleanup_free_ void *p;
1676 ssize_t len;
1677
1678 len = base64mem(roothash_sig_decoded, roothash_sig_decoded_size, &encoded);
1679 if (len < 0)
1680 return -ENOMEM;
1681
1682 p = memdup(roothash_sig_decoded, roothash_sig_decoded_size);
1683 if (!p)
1684 return -ENOMEM;
1685
1686 free_and_replace(c->root_hash_sig, p);
1687 c->root_hash_sig_size = roothash_sig_decoded_size;
1688 c->root_hash_sig_path = mfree(c->root_hash_sig_path);
1689
1690 unit_write_settingf(u, flags, name, "RootHashSignature=base64:%s", encoded);
1691 }
1692 }
1693
1694 return 1;
1695 }
1696
1697 if (streq(name, "RootHashSignaturePath")) {
1698 c->root_hash_sig_size = 0;
1699 c->root_hash_sig = mfree(c->root_hash_sig);
1700
1701 return bus_set_transient_path(u, "RootHashSignature", &c->root_hash_sig_path, message, flags, error);
1702 }
1703
1704 if (streq(name, "RootVerity"))
1705 return bus_set_transient_path(u, name, &c->root_verity, message, flags, error);
1706
1707 if (streq(name, "RootDirectory"))
1708 return bus_set_transient_path(u, name, &c->root_directory, message, flags, error);
1709
1710 if (streq(name, "SyslogIdentifier"))
1711 return bus_set_transient_string(u, name, &c->syslog_identifier, message, flags, error);
1712
1713 if (streq(name, "LogLevelMax"))
1714 return bus_set_transient_log_level(u, name, &c->log_level_max, message, flags, error);
1715
1716 if (streq(name, "LogRateLimitIntervalUSec"))
1717 return bus_set_transient_usec(u, name, &c->log_ratelimit_interval_usec, message, flags, error);
1718
1719 if (streq(name, "LogRateLimitBurst"))
1720 return bus_set_transient_unsigned(u, name, &c->log_ratelimit_burst, message, flags, error);
1721
1722 if (streq(name, "Personality"))
1723 return bus_set_transient_personality(u, name, &c->personality, message, flags, error);
1724
1725 if (streq(name, "StandardInput"))
1726 return bus_set_transient_std_input(u, name, &c->std_input, message, flags, error);
1727
1728 if (streq(name, "StandardOutput"))
1729 return bus_set_transient_std_output(u, name, &c->std_output, message, flags, error);
1730
1731 if (streq(name, "StandardError"))
1732 return bus_set_transient_std_output(u, name, &c->std_error, message, flags, error);
1733
1734 if (streq(name, "IgnoreSIGPIPE"))
1735 return bus_set_transient_bool(u, name, &c->ignore_sigpipe, message, flags, error);
1736
1737 if (streq(name, "TTYVHangup"))
1738 return bus_set_transient_bool(u, name, &c->tty_vhangup, message, flags, error);
1739
1740 if (streq(name, "TTYReset"))
1741 return bus_set_transient_bool(u, name, &c->tty_reset, message, flags, error);
1742
1743 if (streq(name, "TTYVTDisallocate"))
1744 return bus_set_transient_bool(u, name, &c->tty_vt_disallocate, message, flags, error);
1745
1746 if (streq(name, "PrivateTmp"))
1747 return bus_set_transient_bool(u, name, &c->private_tmp, message, flags, error);
1748
1749 if (streq(name, "PrivateDevices"))
1750 return bus_set_transient_bool(u, name, &c->private_devices, message, flags, error);
1751
1752 if (streq(name, "PrivateMounts"))
1753 return bus_set_transient_bool(u, name, &c->private_mounts, message, flags, error);
1754
1755 if (streq(name, "PrivateNetwork"))
1756 return bus_set_transient_bool(u, name, &c->private_network, message, flags, error);
1757
1758 if (streq(name, "PrivateIPC"))
1759 return bus_set_transient_bool(u, name, &c->private_ipc, message, flags, error);
1760
1761 if (streq(name, "PrivateUsers"))
1762 return bus_set_transient_bool(u, name, &c->private_users, message, flags, error);
1763
1764 if (streq(name, "NoNewPrivileges"))
1765 return bus_set_transient_bool(u, name, &c->no_new_privileges, message, flags, error);
1766
1767 if (streq(name, "SyslogLevelPrefix"))
1768 return bus_set_transient_bool(u, name, &c->syslog_level_prefix, message, flags, error);
1769
1770 if (streq(name, "MemoryDenyWriteExecute"))
1771 return bus_set_transient_bool(u, name, &c->memory_deny_write_execute, message, flags, error);
1772
1773 if (streq(name, "RestrictRealtime"))
1774 return bus_set_transient_bool(u, name, &c->restrict_realtime, message, flags, error);
1775
1776 if (streq(name, "RestrictSUIDSGID"))
1777 return bus_set_transient_bool(u, name, &c->restrict_suid_sgid, message, flags, error);
1778
1779 if (streq(name, "DynamicUser"))
1780 return bus_set_transient_bool(u, name, &c->dynamic_user, message, flags, error);
1781
1782 if (streq(name, "RemoveIPC"))
1783 return bus_set_transient_bool(u, name, &c->remove_ipc, message, flags, error);
1784
1785 if (streq(name, "ProtectKernelTunables"))
1786 return bus_set_transient_bool(u, name, &c->protect_kernel_tunables, message, flags, error);
1787
1788 if (streq(name, "ProtectKernelModules"))
1789 return bus_set_transient_bool(u, name, &c->protect_kernel_modules, message, flags, error);
1790
1791 if (streq(name, "ProtectKernelLogs"))
1792 return bus_set_transient_bool(u, name, &c->protect_kernel_logs, message, flags, error);
1793
1794 if (streq(name, "ProtectClock"))
1795 return bus_set_transient_bool(u, name, &c->protect_clock, message, flags, error);
1796
1797 if (streq(name, "ProtectControlGroups"))
1798 return bus_set_transient_bool(u, name, &c->protect_control_groups, message, flags, error);
1799
1800 if (streq(name, "CPUSchedulingResetOnFork"))
1801 return bus_set_transient_bool(u, name, &c->cpu_sched_reset_on_fork, message, flags, error);
1802
1803 if (streq(name, "NonBlocking"))
1804 return bus_set_transient_bool(u, name, &c->non_blocking, message, flags, error);
1805
1806 if (streq(name, "LockPersonality"))
1807 return bus_set_transient_bool(u, name, &c->lock_personality, message, flags, error);
1808
1809 if (streq(name, "ProtectHostname"))
1810 return bus_set_transient_bool(u, name, &c->protect_hostname, message, flags, error);
1811
1812 if (streq(name, "UtmpIdentifier"))
1813 return bus_set_transient_string(u, name, &c->utmp_id, message, flags, error);
1814
1815 if (streq(name, "UtmpMode"))
1816 return bus_set_transient_utmp_mode(u, name, &c->utmp_mode, message, flags, error);
1817
1818 if (streq(name, "PAMName"))
1819 return bus_set_transient_string(u, name, &c->pam_name, message, flags, error);
1820
1821 if (streq(name, "TimerSlackNSec"))
1822 return bus_set_transient_nsec(u, name, &c->timer_slack_nsec, message, flags, error);
1823
1824 if (streq(name, "ProtectSystem"))
1825 return bus_set_transient_protect_system(u, name, &c->protect_system, message, flags, error);
1826
1827 if (streq(name, "ProtectHome"))
1828 return bus_set_transient_protect_home(u, name, &c->protect_home, message, flags, error);
1829
1830 if (streq(name, "KeyringMode"))
1831 return bus_set_transient_keyring_mode(u, name, &c->keyring_mode, message, flags, error);
1832
1833 if (streq(name, "ProtectProc"))
1834 return bus_set_transient_protect_proc(u, name, &c->protect_proc, message, flags, error);
1835
1836 if (streq(name, "ProcSubset"))
1837 return bus_set_transient_proc_subset(u, name, &c->proc_subset, message, flags, error);
1838
1839 if (streq(name, "RuntimeDirectoryPreserve"))
1840 return bus_set_transient_preserve_mode(u, name, &c->runtime_directory_preserve_mode, message, flags, error);
1841
1842 if (streq(name, "UMask"))
1843 return bus_set_transient_mode_t(u, name, &c->umask, message, flags, error);
1844
1845 if (streq(name, "RuntimeDirectoryMode"))
1846 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_RUNTIME].mode, message, flags, error);
1847
1848 if (streq(name, "StateDirectoryMode"))
1849 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_STATE].mode, message, flags, error);
1850
1851 if (streq(name, "CacheDirectoryMode"))
1852 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_CACHE].mode, message, flags, error);
1853
1854 if (streq(name, "LogsDirectoryMode"))
1855 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_LOGS].mode, message, flags, error);
1856
1857 if (streq(name, "ConfigurationDirectoryMode"))
1858 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_CONFIGURATION].mode, message, flags, error);
1859
1860 if (streq(name, "SELinuxContext"))
1861 return bus_set_transient_string(u, name, &c->selinux_context, message, flags, error);
1862
1863 if (streq(name, "SecureBits"))
1864 return bus_set_transient_secure_bits(u, name, &c->secure_bits, message, flags, error);
1865
1866 if (streq(name, "CapabilityBoundingSet"))
1867 return bus_set_transient_capability(u, name, &c->capability_bounding_set, message, flags, error);
1868
1869 if (streq(name, "AmbientCapabilities"))
1870 return bus_set_transient_capability(u, name, &c->capability_ambient_set, message, flags, error);
1871
1872 if (streq(name, "RestrictNamespaces"))
1873 return bus_set_transient_namespace_flag(u, name, &c->restrict_namespaces, message, flags, error);
1874
1875 if (streq(name, "MountFlags"))
1876 return bus_set_transient_mount_flags(u, name, &c->mount_flags, message, flags, error);
1877
1878 if (streq(name, "NetworkNamespacePath"))
1879 return bus_set_transient_path(u, name, &c->network_namespace_path, message, flags, error);
1880
1881 if (streq(name, "IPCNamespacePath"))
1882 return bus_set_transient_path(u, name, &c->ipc_namespace_path, message, flags, error);
1883
1884 if (streq(name, "SupplementaryGroups")) {
1885 _cleanup_strv_free_ char **l = NULL;
1886 char **p;
1887
1888 r = sd_bus_message_read_strv(message, &l);
1889 if (r < 0)
1890 return r;
1891
1892 STRV_FOREACH(p, l)
1893 if (!isempty(*p) && !valid_user_group_name(*p, VALID_USER_ALLOW_NUMERIC|VALID_USER_RELAX|VALID_USER_WARN))
1894 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1895 "Invalid supplementary group names");
1896
1897 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1898 if (strv_isempty(l)) {
1899 c->supplementary_groups = strv_free(c->supplementary_groups);
1900 unit_write_settingf(u, flags, name, "%s=", name);
1901 } else {
1902 _cleanup_free_ char *joined = NULL;
1903
1904 r = strv_extend_strv(&c->supplementary_groups, l, true);
1905 if (r < 0)
1906 return -ENOMEM;
1907
1908 joined = strv_join(c->supplementary_groups, " ");
1909 if (!joined)
1910 return -ENOMEM;
1911
1912 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", name, joined);
1913 }
1914 }
1915
1916 return 1;
1917
1918 } else if (streq(name, "SetCredential")) {
1919 bool isempty = true;
1920
1921 r = sd_bus_message_enter_container(message, 'a', "(say)");
1922 if (r < 0)
1923 return r;
1924
1925 for (;;) {
1926 const char *id;
1927 const void *p;
1928 size_t sz;
1929
1930 r = sd_bus_message_enter_container(message, 'r', "say");
1931 if (r < 0)
1932 return r;
1933 if (r == 0)
1934 break;
1935
1936 r = sd_bus_message_read(message, "s", &id);
1937 if (r < 0)
1938 return r;
1939
1940 r = sd_bus_message_read_array(message, 'y', &p, &sz);
1941 if (r < 0)
1942 return r;
1943
1944 r = sd_bus_message_exit_container(message);
1945 if (r < 0)
1946 return r;
1947
1948 if (!credential_name_valid(id))
1949 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Credential ID is invalid: %s", id);
1950
1951 isempty = false;
1952
1953 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1954 _cleanup_free_ char *a = NULL, *b = NULL;
1955 _cleanup_free_ void *copy = NULL;
1956 ExecSetCredential *old;
1957
1958 copy = memdup(p, sz);
1959 if (!copy)
1960 return -ENOMEM;
1961
1962 old = hashmap_get(c->set_credentials, id);
1963 if (old) {
1964 free_and_replace(old->data, copy);
1965 old->size = sz;
1966 } else {
1967 _cleanup_(exec_set_credential_freep) ExecSetCredential *sc = NULL;
1968
1969 sc = new0(ExecSetCredential, 1);
1970 if (!sc)
1971 return -ENOMEM;
1972
1973 sc->id = strdup(id);
1974 if (!sc->id)
1975 return -ENOMEM;
1976
1977 sc->data = TAKE_PTR(copy);
1978 sc->size = sz;
1979
1980 r = hashmap_ensure_put(&c->set_credentials, &exec_set_credential_hash_ops, sc->id, sc);
1981 if (r < 0)
1982 return r;
1983
1984 TAKE_PTR(sc);
1985 }
1986
1987 a = specifier_escape(id);
1988 if (!a)
1989 return -ENOMEM;
1990
1991 b = cescape_length(p, sz);
1992 if (!b)
1993 return -ENOMEM;
1994
1995 (void) unit_write_settingf(u, flags, name, "%s=%s:%s", name, a, b);
1996 }
1997 }
1998
1999 r = sd_bus_message_exit_container(message);
2000 if (r < 0)
2001 return r;
2002
2003 if (!UNIT_WRITE_FLAGS_NOOP(flags) && isempty) {
2004 c->set_credentials = hashmap_free(c->set_credentials);
2005 (void) unit_write_settingf(u, flags, name, "%s=", name);
2006 }
2007
2008 return 1;
2009
2010 } else if (streq(name, "LoadCredential")) {
2011 bool isempty = true;
2012
2013 r = sd_bus_message_enter_container(message, 'a', "(ss)");
2014 if (r < 0)
2015 return r;
2016
2017 for (;;) {
2018 const char *id, *source;
2019
2020 r = sd_bus_message_read(message, "(ss)", &id, &source);
2021 if (r < 0)
2022 return r;
2023 if (r == 0)
2024 break;
2025
2026 if (!credential_name_valid(id))
2027 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Credential ID is invalid: %s", id);
2028
2029 if (!(path_is_absolute(source) ? path_is_normalized(source) : credential_name_valid(source)))
2030 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Credential source is invalid: %s", source);
2031
2032 isempty = false;
2033
2034 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2035 r = strv_extend_strv(&c->load_credentials, STRV_MAKE(id, source), /* filter_duplicates = */ false);
2036 if (r < 0)
2037 return r;
2038
2039 (void) unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s:%s", name, id, source);
2040 }
2041 }
2042
2043 r = sd_bus_message_exit_container(message);
2044 if (r < 0)
2045 return r;
2046
2047 if (!UNIT_WRITE_FLAGS_NOOP(flags) && isempty) {
2048 c->load_credentials = strv_free(c->load_credentials);
2049 (void) unit_write_settingf(u, flags, name, "%s=", name);
2050 }
2051
2052 return 1;
2053
2054 } else if (streq(name, "SyslogLevel")) {
2055 int32_t level;
2056
2057 r = sd_bus_message_read(message, "i", &level);
2058 if (r < 0)
2059 return r;
2060
2061 if (!log_level_is_valid(level))
2062 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log level value out of range");
2063
2064 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2065 c->syslog_priority = (c->syslog_priority & LOG_FACMASK) | level;
2066 unit_write_settingf(u, flags, name, "SyslogLevel=%i", level);
2067 }
2068
2069 return 1;
2070
2071 } else if (streq(name, "SyslogFacility")) {
2072 int32_t facility;
2073
2074 r = sd_bus_message_read(message, "i", &facility);
2075 if (r < 0)
2076 return r;
2077
2078 if (!log_facility_unshifted_is_valid(facility))
2079 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log facility value out of range");
2080
2081 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2082 c->syslog_priority = (facility << 3) | LOG_PRI(c->syslog_priority);
2083 unit_write_settingf(u, flags, name, "SyslogFacility=%i", facility);
2084 }
2085
2086 return 1;
2087
2088 } else if (streq(name, "LogNamespace")) {
2089 const char *n;
2090
2091 r = sd_bus_message_read(message, "s", &n);
2092 if (r < 0)
2093 return r;
2094
2095 if (!isempty(n) && !log_namespace_name_valid(n))
2096 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log namespace name not valid");
2097
2098 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2099
2100 if (isempty(n)) {
2101 c->log_namespace = mfree(c->log_namespace);
2102 unit_write_settingf(u, flags, name, "%s=", name);
2103 } else {
2104 r = free_and_strdup(&c->log_namespace, n);
2105 if (r < 0)
2106 return r;
2107
2108 unit_write_settingf(u, flags, name, "%s=%s", name, n);
2109 }
2110 }
2111
2112 return 1;
2113
2114 } else if (streq(name, "LogExtraFields")) {
2115 size_t n = 0;
2116
2117 r = sd_bus_message_enter_container(message, 'a', "ay");
2118 if (r < 0)
2119 return r;
2120
2121 for (;;) {
2122 _cleanup_free_ void *copy = NULL;
2123 struct iovec *t;
2124 const char *eq;
2125 const void *p;
2126 size_t sz;
2127
2128 /* Note that we expect a byte array for each field, instead of a string. That's because on the
2129 * lower-level journal fields can actually contain binary data and are not restricted to text,
2130 * and we should not "lose precision" in our types on the way. That said, I am pretty sure
2131 * actually encoding binary data as unit metadata is not a good idea. Hence we actually refuse
2132 * any actual binary data, and only accept UTF-8. This allows us to eventually lift this
2133 * limitation, should a good, valid usecase arise. */
2134
2135 r = sd_bus_message_read_array(message, 'y', &p, &sz);
2136 if (r < 0)
2137 return r;
2138 if (r == 0)
2139 break;
2140
2141 if (memchr(p, 0, sz))
2142 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field contains zero byte");
2143
2144 eq = memchr(p, '=', sz);
2145 if (!eq)
2146 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field contains no '=' character");
2147 if (!journal_field_valid(p, eq - (const char*) p, false))
2148 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field invalid");
2149
2150 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2151 t = reallocarray(c->log_extra_fields, c->n_log_extra_fields+1, sizeof(struct iovec));
2152 if (!t)
2153 return -ENOMEM;
2154 c->log_extra_fields = t;
2155 }
2156
2157 copy = malloc(sz + 1);
2158 if (!copy)
2159 return -ENOMEM;
2160
2161 memcpy(copy, p, sz);
2162 ((uint8_t*) copy)[sz] = 0;
2163
2164 if (!utf8_is_valid(copy))
2165 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field is not valid UTF-8");
2166
2167 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2168 c->log_extra_fields[c->n_log_extra_fields++] = IOVEC_MAKE(copy, sz);
2169 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C, name, "LogExtraFields=%s", (char*) copy);
2170
2171 copy = NULL;
2172 }
2173
2174 n++;
2175 }
2176
2177 r = sd_bus_message_exit_container(message);
2178 if (r < 0)
2179 return r;
2180
2181 if (!UNIT_WRITE_FLAGS_NOOP(flags) && n == 0) {
2182 exec_context_free_log_extra_fields(c);
2183 unit_write_setting(u, flags, name, "LogExtraFields=");
2184 }
2185
2186 return 1;
2187 }
2188
2189 #if HAVE_SECCOMP
2190
2191 if (streq(name, "SystemCallErrorNumber"))
2192 return bus_set_transient_errno(u, name, &c->syscall_errno, message, flags, error);
2193
2194 if (streq(name, "SystemCallFilter")) {
2195 int allow_list;
2196 _cleanup_strv_free_ char **l = NULL;
2197
2198 r = sd_bus_message_enter_container(message, 'r', "bas");
2199 if (r < 0)
2200 return r;
2201
2202 r = sd_bus_message_read(message, "b", &allow_list);
2203 if (r < 0)
2204 return r;
2205
2206 r = sd_bus_message_read_strv(message, &l);
2207 if (r < 0)
2208 return r;
2209
2210 r = sd_bus_message_exit_container(message);
2211 if (r < 0)
2212 return r;
2213
2214 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2215 _cleanup_free_ char *joined = NULL;
2216 SeccompParseFlags invert_flag = allow_list ? 0 : SECCOMP_PARSE_INVERT;
2217 char **s;
2218
2219 if (strv_isempty(l)) {
2220 c->syscall_allow_list = false;
2221 c->syscall_filter = hashmap_free(c->syscall_filter);
2222
2223 unit_write_settingf(u, flags, name, "SystemCallFilter=");
2224 return 1;
2225 }
2226
2227 if (!c->syscall_filter) {
2228 c->syscall_filter = hashmap_new(NULL);
2229 if (!c->syscall_filter)
2230 return log_oom();
2231
2232 c->syscall_allow_list = allow_list;
2233
2234 if (c->syscall_allow_list) {
2235 r = seccomp_parse_syscall_filter("@default",
2236 -1,
2237 c->syscall_filter,
2238 SECCOMP_PARSE_PERMISSIVE |
2239 SECCOMP_PARSE_ALLOW_LIST | invert_flag,
2240 u->id,
2241 NULL, 0);
2242 if (r < 0)
2243 return r;
2244 }
2245 }
2246
2247 STRV_FOREACH(s, l) {
2248 _cleanup_free_ char *n = NULL;
2249 int e;
2250
2251 r = parse_syscall_and_errno(*s, &n, &e);
2252 if (r < 0)
2253 return r;
2254
2255 if (allow_list && e >= 0)
2256 return -EINVAL;
2257
2258 r = seccomp_parse_syscall_filter(n,
2259 e,
2260 c->syscall_filter,
2261 SECCOMP_PARSE_LOG | SECCOMP_PARSE_PERMISSIVE |
2262 invert_flag |
2263 (c->syscall_allow_list ? SECCOMP_PARSE_ALLOW_LIST : 0),
2264 u->id,
2265 NULL, 0);
2266 if (r < 0)
2267 return r;
2268 }
2269
2270 joined = strv_join(l, " ");
2271 if (!joined)
2272 return -ENOMEM;
2273
2274 unit_write_settingf(u, flags, name, "SystemCallFilter=%s%s", allow_list ? "" : "~", joined);
2275 }
2276
2277 return 1;
2278
2279 } else if (streq(name, "SystemCallLog")) {
2280 int allow_list;
2281 _cleanup_strv_free_ char **l = NULL;
2282
2283 r = sd_bus_message_enter_container(message, 'r', "bas");
2284 if (r < 0)
2285 return r;
2286
2287 r = sd_bus_message_read(message, "b", &allow_list);
2288 if (r < 0)
2289 return r;
2290
2291 r = sd_bus_message_read_strv(message, &l);
2292 if (r < 0)
2293 return r;
2294
2295 r = sd_bus_message_exit_container(message);
2296 if (r < 0)
2297 return r;
2298
2299 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2300 _cleanup_free_ char *joined = NULL;
2301 SeccompParseFlags invert_flag = allow_list ? 0 : SECCOMP_PARSE_INVERT;
2302 char **s;
2303
2304 if (strv_isempty(l)) {
2305 c->syscall_log_allow_list = false;
2306 c->syscall_log = hashmap_free(c->syscall_log);
2307
2308 unit_write_settingf(u, flags, name, "SystemCallLog=");
2309 return 1;
2310 }
2311
2312 if (!c->syscall_log) {
2313 c->syscall_log = hashmap_new(NULL);
2314 if (!c->syscall_log)
2315 return log_oom();
2316
2317 c->syscall_log_allow_list = allow_list;
2318 }
2319
2320 STRV_FOREACH(s, l) {
2321 r = seccomp_parse_syscall_filter(*s,
2322 -1, /* errno not used */
2323 c->syscall_log,
2324 SECCOMP_PARSE_LOG | SECCOMP_PARSE_PERMISSIVE |
2325 invert_flag |
2326 (c->syscall_log_allow_list ? SECCOMP_PARSE_ALLOW_LIST : 0),
2327 u->id,
2328 NULL, 0);
2329 if (r < 0)
2330 return r;
2331 }
2332
2333 joined = strv_join(l, " ");
2334 if (!joined)
2335 return -ENOMEM;
2336
2337 unit_write_settingf(u, flags, name, "SystemCallLog=%s%s", allow_list ? "" : "~", joined);
2338 }
2339
2340 return 1;
2341
2342 } else if (streq(name, "SystemCallArchitectures")) {
2343 _cleanup_strv_free_ char **l = NULL;
2344
2345 r = sd_bus_message_read_strv(message, &l);
2346 if (r < 0)
2347 return r;
2348
2349 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2350 _cleanup_free_ char *joined = NULL;
2351
2352 if (strv_isempty(l))
2353 c->syscall_archs = set_free(c->syscall_archs);
2354 else {
2355 char **s;
2356
2357 STRV_FOREACH(s, l) {
2358 uint32_t a;
2359
2360 r = seccomp_arch_from_string(*s, &a);
2361 if (r < 0)
2362 return r;
2363
2364 r = set_ensure_put(&c->syscall_archs, NULL, UINT32_TO_PTR(a + 1));
2365 if (r < 0)
2366 return r;
2367 }
2368
2369 }
2370
2371 joined = strv_join(l, " ");
2372 if (!joined)
2373 return -ENOMEM;
2374
2375 unit_write_settingf(u, flags, name, "%s=%s", name, joined);
2376 }
2377
2378 return 1;
2379
2380 } else if (streq(name, "RestrictAddressFamilies")) {
2381 int allow_list;
2382 _cleanup_strv_free_ char **l = NULL;
2383
2384 r = sd_bus_message_enter_container(message, 'r', "bas");
2385 if (r < 0)
2386 return r;
2387
2388 r = sd_bus_message_read(message, "b", &allow_list);
2389 if (r < 0)
2390 return r;
2391
2392 r = sd_bus_message_read_strv(message, &l);
2393 if (r < 0)
2394 return r;
2395
2396 r = sd_bus_message_exit_container(message);
2397 if (r < 0)
2398 return r;
2399
2400 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2401 _cleanup_free_ char *joined = NULL;
2402 char **s;
2403
2404 if (strv_isempty(l)) {
2405 c->address_families_allow_list = false;
2406 c->address_families = set_free(c->address_families);
2407
2408 unit_write_settingf(u, flags, name, "RestrictAddressFamilies=");
2409 return 1;
2410 }
2411
2412 if (!c->address_families) {
2413 c->address_families = set_new(NULL);
2414 if (!c->address_families)
2415 return log_oom();
2416
2417 c->address_families_allow_list = allow_list;
2418 }
2419
2420 STRV_FOREACH(s, l) {
2421 int af;
2422
2423 af = af_from_name(*s);
2424 if (af < 0)
2425 return af;
2426
2427 if (allow_list == c->address_families_allow_list) {
2428 r = set_put(c->address_families, INT_TO_PTR(af));
2429 if (r < 0)
2430 return r;
2431 } else
2432 (void) set_remove(c->address_families, INT_TO_PTR(af));
2433 }
2434
2435 joined = strv_join(l, " ");
2436 if (!joined)
2437 return -ENOMEM;
2438
2439 unit_write_settingf(u, flags, name, "RestrictAddressFamilies=%s%s", allow_list ? "" : "~", joined);
2440 }
2441
2442 return 1;
2443 }
2444 #endif
2445 if (STR_IN_SET(name, "CPUAffinity", "NUMAMask")) {
2446 const void *a;
2447 size_t n;
2448 bool affinity = streq(name, "CPUAffinity");
2449 _cleanup_(cpu_set_reset) CPUSet set = {};
2450
2451 r = sd_bus_message_read_array(message, 'y', &a, &n);
2452 if (r < 0)
2453 return r;
2454
2455 r = cpu_set_from_dbus(a, n, &set);
2456 if (r < 0)
2457 return r;
2458
2459 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2460 if (n == 0) {
2461 cpu_set_reset(affinity ? &c->cpu_set : &c->numa_policy.nodes);
2462 unit_write_settingf(u, flags, name, "%s=", name);
2463 } else {
2464 _cleanup_free_ char *str = NULL;
2465
2466 str = cpu_set_to_string(&set);
2467 if (!str)
2468 return -ENOMEM;
2469
2470 /* We forego any optimizations here, and always create the structure using
2471 * cpu_set_add_all(), because we don't want to care if the existing size we
2472 * got over dbus is appropriate. */
2473 r = cpu_set_add_all(affinity ? &c->cpu_set : &c->numa_policy.nodes, &set);
2474 if (r < 0)
2475 return r;
2476
2477 unit_write_settingf(u, flags, name, "%s=%s", name, str);
2478 }
2479 }
2480
2481 return 1;
2482
2483 } else if (streq(name, "CPUAffinityFromNUMA")) {
2484 int q;
2485
2486 r = sd_bus_message_read_basic(message, 'b', &q);
2487 if (r < 0)
2488 return r;
2489
2490 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2491 c->cpu_affinity_from_numa = q;
2492 unit_write_settingf(u, flags, name, "%s=%s", "CPUAffinity", "numa");
2493 }
2494
2495 return 1;
2496
2497 } else if (streq(name, "NUMAPolicy")) {
2498 int32_t type;
2499
2500 r = sd_bus_message_read(message, "i", &type);
2501 if (r < 0)
2502 return r;
2503
2504 if (!mpol_is_valid(type))
2505 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid NUMAPolicy value: %i", type);
2506
2507 if (!UNIT_WRITE_FLAGS_NOOP(flags))
2508 c->numa_policy.type = type;
2509
2510 return 1;
2511
2512 } else if (streq(name, "Nice")) {
2513 int32_t q;
2514
2515 r = sd_bus_message_read(message, "i", &q);
2516 if (r < 0)
2517 return r;
2518
2519 if (!nice_is_valid(q))
2520 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid Nice value: %i", q);
2521
2522 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2523 c->nice = q;
2524 c->nice_set = true;
2525
2526 unit_write_settingf(u, flags, name, "Nice=%i", q);
2527 }
2528
2529 return 1;
2530
2531 } else if (streq(name, "CPUSchedulingPolicy")) {
2532 int32_t q;
2533
2534 r = sd_bus_message_read(message, "i", &q);
2535 if (r < 0)
2536 return r;
2537
2538 if (!sched_policy_is_valid(q))
2539 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid CPU scheduling policy: %i", q);
2540
2541 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2542 _cleanup_free_ char *s = NULL;
2543
2544 r = sched_policy_to_string_alloc(q, &s);
2545 if (r < 0)
2546 return r;
2547
2548 c->cpu_sched_policy = q;
2549 c->cpu_sched_priority = CLAMP(c->cpu_sched_priority, sched_get_priority_min(q), sched_get_priority_max(q));
2550 c->cpu_sched_set = true;
2551
2552 unit_write_settingf(u, flags, name, "CPUSchedulingPolicy=%s", s);
2553 }
2554
2555 return 1;
2556
2557 } else if (streq(name, "CPUSchedulingPriority")) {
2558 int32_t p, min, max;
2559
2560 r = sd_bus_message_read(message, "i", &p);
2561 if (r < 0)
2562 return r;
2563
2564 min = sched_get_priority_min(c->cpu_sched_policy);
2565 max = sched_get_priority_max(c->cpu_sched_policy);
2566 if (p < min || p > max)
2567 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid CPU scheduling priority: %i", p);
2568
2569 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2570 c->cpu_sched_priority = p;
2571 c->cpu_sched_set = true;
2572
2573 unit_write_settingf(u, flags, name, "CPUSchedulingPriority=%i", p);
2574 }
2575
2576 return 1;
2577
2578 } else if (streq(name, "IOSchedulingClass")) {
2579 int32_t q;
2580
2581 r = sd_bus_message_read(message, "i", &q);
2582 if (r < 0)
2583 return r;
2584
2585 if (!ioprio_class_is_valid(q))
2586 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid IO scheduling class: %i", q);
2587
2588 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2589 _cleanup_free_ char *s = NULL;
2590
2591 r = ioprio_class_to_string_alloc(q, &s);
2592 if (r < 0)
2593 return r;
2594
2595 c->ioprio = IOPRIO_PRIO_VALUE(q, IOPRIO_PRIO_DATA(c->ioprio));
2596 c->ioprio_set = true;
2597
2598 unit_write_settingf(u, flags, name, "IOSchedulingClass=%s", s);
2599 }
2600
2601 return 1;
2602
2603 } else if (streq(name, "IOSchedulingPriority")) {
2604 int32_t p;
2605
2606 r = sd_bus_message_read(message, "i", &p);
2607 if (r < 0)
2608 return r;
2609
2610 if (!ioprio_priority_is_valid(p))
2611 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid IO scheduling priority: %i", p);
2612
2613 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2614 c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_PRIO_CLASS(c->ioprio), p);
2615 c->ioprio_set = true;
2616
2617 unit_write_settingf(u, flags, name, "IOSchedulingPriority=%i", p);
2618 }
2619
2620 return 1;
2621
2622 } else if (streq(name, "MountAPIVFS")) {
2623 bool b;
2624
2625 r = bus_set_transient_bool(u, name, &b, message, flags, error);
2626 if (r < 0)
2627 return r;
2628
2629 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2630 c->mount_apivfs = b;
2631 c->mount_apivfs_set = true;
2632 }
2633
2634 return 1;
2635
2636 } else if (streq(name, "WorkingDirectory")) {
2637 const char *s;
2638 bool missing_ok;
2639
2640 r = sd_bus_message_read(message, "s", &s);
2641 if (r < 0)
2642 return r;
2643
2644 if (s[0] == '-') {
2645 missing_ok = true;
2646 s++;
2647 } else
2648 missing_ok = false;
2649
2650 if (!isempty(s) && !streq(s, "~") && !path_is_absolute(s))
2651 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "WorkingDirectory= expects an absolute path or '~'");
2652
2653 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2654 if (streq(s, "~")) {
2655 c->working_directory = mfree(c->working_directory);
2656 c->working_directory_home = true;
2657 } else {
2658 r = free_and_strdup(&c->working_directory, empty_to_null(s));
2659 if (r < 0)
2660 return r;
2661
2662 c->working_directory_home = false;
2663 }
2664
2665 c->working_directory_missing_ok = missing_ok;
2666 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "WorkingDirectory=%s%s", missing_ok ? "-" : "", s);
2667 }
2668
2669 return 1;
2670
2671 } else if (STR_IN_SET(name,
2672 "StandardInputFileDescriptorName", "StandardOutputFileDescriptorName", "StandardErrorFileDescriptorName")) {
2673 const char *s;
2674
2675 r = sd_bus_message_read(message, "s", &s);
2676 if (r < 0)
2677 return r;
2678
2679 if (!isempty(s) && !fdname_is_valid(s))
2680 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid file descriptor name");
2681
2682 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2683
2684 if (streq(name, "StandardInputFileDescriptorName")) {
2685 r = free_and_strdup(c->stdio_fdname + STDIN_FILENO, empty_to_null(s));
2686 if (r < 0)
2687 return r;
2688
2689 c->std_input = EXEC_INPUT_NAMED_FD;
2690 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardInput=fd:%s", exec_context_fdname(c, STDIN_FILENO));
2691
2692 } else if (streq(name, "StandardOutputFileDescriptorName")) {
2693 r = free_and_strdup(c->stdio_fdname + STDOUT_FILENO, empty_to_null(s));
2694 if (r < 0)
2695 return r;
2696
2697 c->std_output = EXEC_OUTPUT_NAMED_FD;
2698 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=fd:%s", exec_context_fdname(c, STDOUT_FILENO));
2699
2700 } else {
2701 assert(streq(name, "StandardErrorFileDescriptorName"));
2702
2703 r = free_and_strdup(&c->stdio_fdname[STDERR_FILENO], empty_to_null(s));
2704 if (r < 0)
2705 return r;
2706
2707 c->std_error = EXEC_OUTPUT_NAMED_FD;
2708 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardError=fd:%s", exec_context_fdname(c, STDERR_FILENO));
2709 }
2710 }
2711
2712 return 1;
2713
2714 } else if (STR_IN_SET(name,
2715 "StandardInputFile",
2716 "StandardOutputFile", "StandardOutputFileToAppend", "StandardOutputFileToTruncate",
2717 "StandardErrorFile", "StandardErrorFileToAppend", "StandardErrorFileToTruncate")) {
2718 const char *s;
2719
2720 r = sd_bus_message_read(message, "s", &s);
2721 if (r < 0)
2722 return r;
2723
2724 if (!isempty(s)) {
2725 if (!path_is_absolute(s))
2726 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute", s);
2727 if (!path_is_normalized(s))
2728 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not normalized", s);
2729 }
2730
2731 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2732
2733 if (streq(name, "StandardInputFile")) {
2734 r = free_and_strdup(&c->stdio_file[STDIN_FILENO], empty_to_null(s));
2735 if (r < 0)
2736 return r;
2737
2738 c->std_input = EXEC_INPUT_FILE;
2739 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardInput=file:%s", s);
2740
2741 } else if (STR_IN_SET(name, "StandardOutputFile", "StandardOutputFileToAppend", "StandardOutputFileToTruncate")) {
2742 r = free_and_strdup(&c->stdio_file[STDOUT_FILENO], empty_to_null(s));
2743 if (r < 0)
2744 return r;
2745
2746 if (streq(name, "StandardOutputFile")) {
2747 c->std_output = EXEC_OUTPUT_FILE;
2748 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=file:%s", s);
2749 } else if (streq(name, "StandardOutputFileToAppend")) {
2750 c->std_output = EXEC_OUTPUT_FILE_APPEND;
2751 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=append:%s", s);
2752 } else {
2753 assert(streq(name, "StandardOutputFileToTruncate"));
2754 c->std_output = EXEC_OUTPUT_FILE_TRUNCATE;
2755 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=truncate:%s", s);
2756 }
2757 } else {
2758 assert(STR_IN_SET(name, "StandardErrorFile", "StandardErrorFileToAppend", "StandardErrorFileToTruncate"));
2759
2760 r = free_and_strdup(&c->stdio_file[STDERR_FILENO], empty_to_null(s));
2761 if (r < 0)
2762 return r;
2763
2764 if (streq(name, "StandardErrorFile")) {
2765 c->std_error = EXEC_OUTPUT_FILE;
2766 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardError=file:%s", s);
2767 } else if (streq(name, "StandardErrorFileToAppend")) {
2768 c->std_error = EXEC_OUTPUT_FILE_APPEND;
2769 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardError=append:%s", s);
2770 } else {
2771 assert(streq(name, "StandardErrorFileToTruncate"));
2772 c->std_error = EXEC_OUTPUT_FILE_TRUNCATE;
2773 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardError=truncate:%s", s);
2774 }
2775 }
2776 }
2777
2778 return 1;
2779
2780 } else if (streq(name, "StandardInputData")) {
2781 const void *p;
2782 size_t sz;
2783
2784 r = sd_bus_message_read_array(message, 'y', &p, &sz);
2785 if (r < 0)
2786 return r;
2787
2788 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2789 _cleanup_free_ char *encoded = NULL;
2790
2791 if (sz == 0) {
2792 c->stdin_data = mfree(c->stdin_data);
2793 c->stdin_data_size = 0;
2794
2795 unit_write_settingf(u, flags, name, "StandardInputData=");
2796 } else {
2797 void *q;
2798 ssize_t n;
2799
2800 if (c->stdin_data_size + sz < c->stdin_data_size || /* check for overflow */
2801 c->stdin_data_size + sz > EXEC_STDIN_DATA_MAX)
2802 return -E2BIG;
2803
2804 n = base64mem(p, sz, &encoded);
2805 if (n < 0)
2806 return (int) n;
2807
2808 q = realloc(c->stdin_data, c->stdin_data_size + sz);
2809 if (!q)
2810 return -ENOMEM;
2811
2812 memcpy((uint8_t*) q + c->stdin_data_size, p, sz);
2813
2814 c->stdin_data = q;
2815 c->stdin_data_size += sz;
2816
2817 unit_write_settingf(u, flags, name, "StandardInputData=%s", encoded);
2818 }
2819 }
2820
2821 return 1;
2822
2823 } else if (streq(name, "Environment")) {
2824
2825 _cleanup_strv_free_ char **l = NULL;
2826
2827 r = sd_bus_message_read_strv(message, &l);
2828 if (r < 0)
2829 return r;
2830
2831 if (!strv_env_is_valid(l))
2832 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment block.");
2833
2834 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2835 if (strv_isempty(l)) {
2836 c->environment = strv_free(c->environment);
2837 unit_write_setting(u, flags, name, "Environment=");
2838 } else {
2839 _cleanup_free_ char *joined = NULL;
2840 char **e;
2841
2842 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C);
2843 if (!joined)
2844 return -ENOMEM;
2845
2846 e = strv_env_merge(2, c->environment, l);
2847 if (!e)
2848 return -ENOMEM;
2849
2850 strv_free_and_replace(c->environment, e);
2851 unit_write_settingf(u, flags, name, "Environment=%s", joined);
2852 }
2853 }
2854
2855 return 1;
2856
2857 } else if (streq(name, "UnsetEnvironment")) {
2858
2859 _cleanup_strv_free_ char **l = NULL;
2860
2861 r = sd_bus_message_read_strv(message, &l);
2862 if (r < 0)
2863 return r;
2864
2865 if (!strv_env_name_or_assignment_is_valid(l))
2866 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid UnsetEnvironment= list.");
2867
2868 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2869 if (strv_isempty(l)) {
2870 c->unset_environment = strv_free(c->unset_environment);
2871 unit_write_setting(u, flags, name, "UnsetEnvironment=");
2872 } else {
2873 _cleanup_free_ char *joined = NULL;
2874 char **e;
2875
2876 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C);
2877 if (!joined)
2878 return -ENOMEM;
2879
2880 e = strv_env_merge(2, c->unset_environment, l);
2881 if (!e)
2882 return -ENOMEM;
2883
2884 strv_free_and_replace(c->unset_environment, e);
2885 unit_write_settingf(u, flags, name, "UnsetEnvironment=%s", joined);
2886 }
2887 }
2888
2889 return 1;
2890
2891 } else if (streq(name, "OOMScoreAdjust")) {
2892 int oa;
2893
2894 r = sd_bus_message_read(message, "i", &oa);
2895 if (r < 0)
2896 return r;
2897
2898 if (!oom_score_adjust_is_valid(oa))
2899 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "OOM score adjust value out of range");
2900
2901 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2902 c->oom_score_adjust = oa;
2903 c->oom_score_adjust_set = true;
2904 unit_write_settingf(u, flags, name, "OOMScoreAdjust=%i", oa);
2905 }
2906
2907 return 1;
2908
2909 } else if (streq(name, "CoredumpFilter")) {
2910 uint64_t f;
2911
2912 r = sd_bus_message_read(message, "t", &f);
2913 if (r < 0)
2914 return r;
2915
2916 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2917 c->coredump_filter = f;
2918 c->coredump_filter_set = true;
2919 unit_write_settingf(u, flags, name, "CoredumpFilter=0x%"PRIx64, f);
2920 }
2921
2922 return 1;
2923
2924 } else if (streq(name, "EnvironmentFiles")) {
2925
2926 _cleanup_free_ char *joined = NULL;
2927 _cleanup_fclose_ FILE *f = NULL;
2928 _cleanup_strv_free_ char **l = NULL;
2929 size_t size = 0;
2930 char **i;
2931
2932 r = sd_bus_message_enter_container(message, 'a', "(sb)");
2933 if (r < 0)
2934 return r;
2935
2936 f = open_memstream_unlocked(&joined, &size);
2937 if (!f)
2938 return -ENOMEM;
2939
2940 fputs("EnvironmentFile=\n", f);
2941
2942 STRV_FOREACH(i, c->environment_files) {
2943 _cleanup_free_ char *q = NULL;
2944
2945 q = specifier_escape(*i);
2946 if (!q)
2947 return -ENOMEM;
2948
2949 fprintf(f, "EnvironmentFile=%s\n", q);
2950 }
2951
2952 while ((r = sd_bus_message_enter_container(message, 'r', "sb")) > 0) {
2953 const char *path;
2954 int b;
2955
2956 r = sd_bus_message_read(message, "sb", &path, &b);
2957 if (r < 0)
2958 return r;
2959
2960 r = sd_bus_message_exit_container(message);
2961 if (r < 0)
2962 return r;
2963
2964 if (!path_is_absolute(path))
2965 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
2966
2967 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2968 _cleanup_free_ char *q = NULL, *buf = NULL;
2969
2970 buf = strjoin(b ? "-" : "", path);
2971 if (!buf)
2972 return -ENOMEM;
2973
2974 q = specifier_escape(buf);
2975 if (!q)
2976 return -ENOMEM;
2977
2978 fprintf(f, "EnvironmentFile=%s\n", q);
2979
2980 r = strv_consume(&l, TAKE_PTR(buf));
2981 if (r < 0)
2982 return r;
2983 }
2984 }
2985 if (r < 0)
2986 return r;
2987
2988 r = sd_bus_message_exit_container(message);
2989 if (r < 0)
2990 return r;
2991
2992 r = fflush_and_check(f);
2993 if (r < 0)
2994 return r;
2995
2996 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2997 if (strv_isempty(l)) {
2998 c->environment_files = strv_free(c->environment_files);
2999 unit_write_setting(u, flags, name, "EnvironmentFile=");
3000 } else {
3001 r = strv_extend_strv(&c->environment_files, l, true);
3002 if (r < 0)
3003 return r;
3004
3005 unit_write_setting(u, flags, name, joined);
3006 }
3007 }
3008
3009 return 1;
3010
3011 } else if (streq(name, "PassEnvironment")) {
3012
3013 _cleanup_strv_free_ char **l = NULL;
3014
3015 r = sd_bus_message_read_strv(message, &l);
3016 if (r < 0)
3017 return r;
3018
3019 if (!strv_env_name_is_valid(l))
3020 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PassEnvironment= block.");
3021
3022 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3023 if (strv_isempty(l)) {
3024 c->pass_environment = strv_free(c->pass_environment);
3025 unit_write_setting(u, flags, name, "PassEnvironment=");
3026 } else {
3027 _cleanup_free_ char *joined = NULL;
3028
3029 r = strv_extend_strv(&c->pass_environment, l, true);
3030 if (r < 0)
3031 return r;
3032
3033 /* We write just the new settings out to file, with unresolved specifiers. */
3034 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS);
3035 if (!joined)
3036 return -ENOMEM;
3037
3038 unit_write_settingf(u, flags, name, "PassEnvironment=%s", joined);
3039 }
3040 }
3041
3042 return 1;
3043
3044 } else if (STR_IN_SET(name, "ReadWriteDirectories", "ReadOnlyDirectories", "InaccessibleDirectories",
3045 "ReadWritePaths", "ReadOnlyPaths", "InaccessiblePaths", "ExecPaths", "NoExecPaths")) {
3046 _cleanup_strv_free_ char **l = NULL;
3047 char ***dirs;
3048 char **p;
3049
3050 r = sd_bus_message_read_strv(message, &l);
3051 if (r < 0)
3052 return r;
3053
3054 STRV_FOREACH(p, l) {
3055 char *i = *p;
3056 size_t offset;
3057
3058 offset = i[0] == '-';
3059 offset += i[offset] == '+';
3060 if (!path_is_absolute(i + offset))
3061 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s", name);
3062
3063 path_simplify(i + offset, false);
3064 }
3065
3066 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3067 if (STR_IN_SET(name, "ReadWriteDirectories", "ReadWritePaths"))
3068 dirs = &c->read_write_paths;
3069 else if (STR_IN_SET(name, "ReadOnlyDirectories", "ReadOnlyPaths"))
3070 dirs = &c->read_only_paths;
3071 else if (streq(name, "ExecPaths"))
3072 dirs = &c->exec_paths;
3073 else if (streq(name, "NoExecPaths"))
3074 dirs = &c->no_exec_paths;
3075 else /* "InaccessiblePaths" */
3076 dirs = &c->inaccessible_paths;
3077
3078 if (strv_isempty(l)) {
3079 *dirs = strv_free(*dirs);
3080 unit_write_settingf(u, flags, name, "%s=", name);
3081 } else {
3082 _cleanup_free_ char *joined = NULL;
3083
3084 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS);
3085 if (!joined)
3086 return -ENOMEM;
3087
3088 r = strv_extend_strv(dirs, l, true);
3089 if (r < 0)
3090 return -ENOMEM;
3091
3092 unit_write_settingf(u, flags, name, "%s=%s", name, joined);
3093 }
3094 }
3095
3096 return 1;
3097
3098 } else if (STR_IN_SET(name, "RuntimeDirectory", "StateDirectory", "CacheDirectory", "LogsDirectory", "ConfigurationDirectory")) {
3099 _cleanup_strv_free_ char **l = NULL;
3100 char **p;
3101
3102 r = sd_bus_message_read_strv(message, &l);
3103 if (r < 0)
3104 return r;
3105
3106 STRV_FOREACH(p, l) {
3107 if (!path_is_normalized(*p))
3108 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s= path is not normalized: %s", name, *p);
3109
3110 if (path_is_absolute(*p))
3111 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s= path is absolute: %s", name, *p);
3112
3113 if (path_startswith(*p, "private"))
3114 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s= path can't be 'private': %s", name, *p);
3115 }
3116
3117 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3118 ExecDirectoryType i;
3119 ExecDirectory *d;
3120
3121 assert_se((i = exec_directory_type_from_string(name)) >= 0);
3122 d = c->directories + i;
3123
3124 if (strv_isempty(l)) {
3125 d->paths = strv_free(d->paths);
3126 unit_write_settingf(u, flags, name, "%s=", name);
3127 } else {
3128 _cleanup_free_ char *joined = NULL;
3129
3130 r = strv_extend_strv(&d->paths, l, true);
3131 if (r < 0)
3132 return r;
3133
3134 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS);
3135 if (!joined)
3136 return -ENOMEM;
3137
3138 unit_write_settingf(u, flags, name, "%s=%s", name, joined);
3139 }
3140 }
3141
3142 return 1;
3143
3144 } else if (STR_IN_SET(name, "AppArmorProfile", "SmackProcessLabel")) {
3145 int ignore;
3146 const char *s;
3147
3148 r = sd_bus_message_read(message, "(bs)", &ignore, &s);
3149 if (r < 0)
3150 return r;
3151
3152 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3153 char **p;
3154 bool *b;
3155
3156 if (streq(name, "AppArmorProfile")) {
3157 p = &c->apparmor_profile;
3158 b = &c->apparmor_profile_ignore;
3159 } else { /* "SmackProcessLabel" */
3160 p = &c->smack_process_label;
3161 b = &c->smack_process_label_ignore;
3162 }
3163
3164 if (isempty(s)) {
3165 *p = mfree(*p);
3166 *b = false;
3167 } else {
3168 if (free_and_strdup(p, s) < 0)
3169 return -ENOMEM;
3170 *b = ignore;
3171 }
3172
3173 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s%s", name, ignore ? "-" : "", strempty(s));
3174 }
3175
3176 return 1;
3177
3178 } else if (STR_IN_SET(name, "BindPaths", "BindReadOnlyPaths")) {
3179 char *source, *destination;
3180 int ignore_enoent;
3181 uint64_t mount_flags;
3182 bool empty = true;
3183
3184 r = sd_bus_message_enter_container(message, 'a', "(ssbt)");
3185 if (r < 0)
3186 return r;
3187
3188 while ((r = sd_bus_message_read(message, "(ssbt)", &source, &destination, &ignore_enoent, &mount_flags)) > 0) {
3189
3190 if (!path_is_absolute(source))
3191 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path %s is not absolute.", source);
3192 if (!path_is_absolute(destination))
3193 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Destination path %s is not absolute.", destination);
3194 if (!IN_SET(mount_flags, 0, MS_REC))
3195 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown mount flags.");
3196
3197 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3198 r = bind_mount_add(&c->bind_mounts, &c->n_bind_mounts,
3199 &(BindMount) {
3200 .source = source,
3201 .destination = destination,
3202 .read_only = !!strstr(name, "ReadOnly"),
3203 .recursive = !!(mount_flags & MS_REC),
3204 .ignore_enoent = ignore_enoent,
3205 });
3206 if (r < 0)
3207 return r;
3208
3209 unit_write_settingf(
3210 u, flags|UNIT_ESCAPE_SPECIFIERS, name,
3211 "%s=%s%s:%s:%s",
3212 name,
3213 ignore_enoent ? "-" : "",
3214 source,
3215 destination,
3216 (mount_flags & MS_REC) ? "rbind" : "norbind");
3217 }
3218
3219 empty = false;
3220 }
3221 if (r < 0)
3222 return r;
3223
3224 r = sd_bus_message_exit_container(message);
3225 if (r < 0)
3226 return r;
3227
3228 if (empty) {
3229 bind_mount_free_many(c->bind_mounts, c->n_bind_mounts);
3230 c->bind_mounts = NULL;
3231 c->n_bind_mounts = 0;
3232
3233 unit_write_settingf(u, flags, name, "%s=", name);
3234 }
3235
3236 return 1;
3237
3238 } else if (streq(name, "TemporaryFileSystem")) {
3239 const char *path, *options;
3240 bool empty = true;
3241
3242 r = sd_bus_message_enter_container(message, 'a', "(ss)");
3243 if (r < 0)
3244 return r;
3245
3246 while ((r = sd_bus_message_read(message, "(ss)", &path, &options)) > 0) {
3247
3248 if (!path_is_absolute(path))
3249 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Mount point %s is not absolute.", path);
3250
3251 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3252 r = temporary_filesystem_add(&c->temporary_filesystems, &c->n_temporary_filesystems, path, options);
3253 if (r < 0)
3254 return r;
3255
3256 unit_write_settingf(
3257 u, flags|UNIT_ESCAPE_SPECIFIERS, name,
3258 "%s=%s:%s",
3259 name,
3260 path,
3261 options);
3262 }
3263
3264 empty = false;
3265 }
3266 if (r < 0)
3267 return r;
3268
3269 r = sd_bus_message_exit_container(message);
3270 if (r < 0)
3271 return r;
3272
3273 if (empty) {
3274 temporary_filesystem_free_many(c->temporary_filesystems, c->n_temporary_filesystems);
3275 c->temporary_filesystems = NULL;
3276 c->n_temporary_filesystems = 0;
3277
3278 unit_write_settingf(u, flags, name, "%s=", name);
3279 }
3280
3281 return 1;
3282
3283 } else if ((suffix = startswith(name, "Limit"))) {
3284 const char *soft = NULL;
3285 int ri;
3286
3287 ri = rlimit_from_string(suffix);
3288 if (ri < 0) {
3289 soft = endswith(suffix, "Soft");
3290 if (soft) {
3291 const char *n;
3292
3293 n = strndupa(suffix, soft - suffix);
3294 ri = rlimit_from_string(n);
3295 if (ri >= 0)
3296 name = strjoina("Limit", n);
3297 }
3298 }
3299
3300 if (ri >= 0) {
3301 uint64_t rl;
3302 rlim_t x;
3303
3304 r = sd_bus_message_read(message, "t", &rl);
3305 if (r < 0)
3306 return r;
3307
3308 if (rl == UINT64_MAX)
3309 x = RLIM_INFINITY;
3310 else {
3311 x = (rlim_t) rl;
3312
3313 if ((uint64_t) x != rl)
3314 return -ERANGE;
3315 }
3316
3317 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3318 _cleanup_free_ char *f = NULL;
3319 struct rlimit nl;
3320
3321 if (c->rlimit[ri]) {
3322 nl = *c->rlimit[ri];
3323
3324 if (soft)
3325 nl.rlim_cur = x;
3326 else
3327 nl.rlim_max = x;
3328 } else
3329 /* When the resource limit is not initialized yet, then assign the value to both fields */
3330 nl = (struct rlimit) {
3331 .rlim_cur = x,
3332 .rlim_max = x,
3333 };
3334
3335 r = rlimit_format(&nl, &f);
3336 if (r < 0)
3337 return r;
3338
3339 if (c->rlimit[ri])
3340 *c->rlimit[ri] = nl;
3341 else {
3342 c->rlimit[ri] = newdup(struct rlimit, &nl, 1);
3343 if (!c->rlimit[ri])
3344 return -ENOMEM;
3345 }
3346
3347 unit_write_settingf(u, flags, name, "%s=%s", name, f);
3348 }
3349
3350 return 1;
3351 }
3352
3353 } else if (streq(name, "MountImages")) {
3354 _cleanup_free_ char *format_str = NULL;
3355 MountImage *mount_images = NULL;
3356 size_t n_mount_images = 0;
3357 char *source, *destination;
3358 int permissive;
3359
3360 r = sd_bus_message_enter_container(message, 'a', "(ssba(ss))");
3361 if (r < 0)
3362 return r;
3363
3364 for (;;) {
3365 _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
3366 _cleanup_free_ char *source_escaped = NULL, *destination_escaped = NULL;
3367 char *tuple;
3368
3369 r = sd_bus_message_enter_container(message, 'r', "ssba(ss)");
3370 if (r < 0)
3371 return r;
3372
3373 r = sd_bus_message_read(message, "ssb", &source, &destination, &permissive);
3374 if (r <= 0)
3375 break;
3376
3377 if (!path_is_absolute(source))
3378 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path %s is not absolute.", source);
3379 if (!path_is_normalized(source))
3380 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path %s is not normalized.", source);
3381 if (!path_is_absolute(destination))
3382 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Destination path %s is not absolute.", destination);
3383 if (!path_is_normalized(destination))
3384 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Destination path %s is not normalized.", destination);
3385
3386 /* Need to store them in the unit with the escapes, so that they can be parsed again */
3387 source_escaped = shell_escape(source, ":");
3388 if (!source_escaped)
3389 return -ENOMEM;
3390 destination_escaped = shell_escape(destination, ":");
3391 if (!destination_escaped)
3392 return -ENOMEM;
3393
3394 tuple = strjoin(format_str,
3395 format_str ? " " : "",
3396 permissive ? "-" : "",
3397 source_escaped,
3398 ":",
3399 destination_escaped);
3400 if (!tuple)
3401 return -ENOMEM;
3402 free_and_replace(format_str, tuple);
3403
3404 r = bus_read_mount_options(message, error, &options, &format_str, ":");
3405 if (r < 0)
3406 return r;
3407
3408 r = sd_bus_message_exit_container(message);
3409 if (r < 0)
3410 return r;
3411
3412 r = mount_image_add(&mount_images, &n_mount_images,
3413 &(MountImage) {
3414 .source = source,
3415 .destination = destination,
3416 .mount_options = options,
3417 .ignore_enoent = permissive,
3418 .type = MOUNT_IMAGE_DISCRETE,
3419 });
3420 if (r < 0)
3421 return r;
3422 }
3423 if (r < 0)
3424 return r;
3425
3426 r = sd_bus_message_exit_container(message);
3427 if (r < 0)
3428 return r;
3429
3430 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3431 if (n_mount_images == 0) {
3432 c->mount_images = mount_image_free_many(c->mount_images, &c->n_mount_images);
3433
3434 unit_write_settingf(u, flags, name, "%s=", name);
3435 } else {
3436 for (size_t i = 0; i < n_mount_images; ++i) {
3437 r = mount_image_add(&c->mount_images, &c->n_mount_images, &mount_images[i]);
3438 if (r < 0)
3439 return r;
3440 }
3441
3442 unit_write_settingf(u, flags|UNIT_ESCAPE_C|UNIT_ESCAPE_SPECIFIERS,
3443 name,
3444 "%s=%s",
3445 name,
3446 format_str);
3447 }
3448 }
3449
3450 mount_images = mount_image_free_many(mount_images, &n_mount_images);
3451
3452 return 1;
3453 } else if (streq(name, "ExtensionImages")) {
3454 _cleanup_free_ char *format_str = NULL;
3455 MountImage *extension_images = NULL;
3456 size_t n_extension_images = 0;
3457
3458 r = sd_bus_message_enter_container(message, 'a', "(sba(ss))");
3459 if (r < 0)
3460 return r;
3461
3462 for (;;) {
3463 _cleanup_(mount_options_free_allp) MountOptions *options = NULL;
3464 _cleanup_free_ char *source_escaped = NULL;
3465 char *source, *tuple;
3466 int permissive;
3467
3468 r = sd_bus_message_enter_container(message, 'r', "sba(ss)");
3469 if (r < 0)
3470 return r;
3471
3472 r = sd_bus_message_read(message, "sb", &source, &permissive);
3473 if (r <= 0)
3474 break;
3475
3476 if (!path_is_absolute(source))
3477 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path %s is not absolute.", source);
3478 if (!path_is_normalized(source))
3479 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path %s is not normalized.", source);
3480
3481 /* Need to store them in the unit with the escapes, so that they can be parsed again */
3482 source_escaped = shell_escape(source, ":");
3483 if (!source_escaped)
3484 return -ENOMEM;
3485
3486 tuple = strjoin(format_str,
3487 format_str ? " " : "",
3488 permissive ? "-" : "",
3489 source_escaped);
3490 if (!tuple)
3491 return -ENOMEM;
3492 free_and_replace(format_str, tuple);
3493
3494 r = bus_read_mount_options(message, error, &options, &format_str, ":");
3495 if (r < 0)
3496 return r;
3497
3498 r = sd_bus_message_exit_container(message);
3499 if (r < 0)
3500 return r;
3501
3502 r = mount_image_add(&extension_images, &n_extension_images,
3503 &(MountImage) {
3504 .source = source,
3505 .mount_options = options,
3506 .ignore_enoent = permissive,
3507 .type = MOUNT_IMAGE_EXTENSION,
3508 });
3509 if (r < 0)
3510 return r;
3511 }
3512 if (r < 0)
3513 return r;
3514
3515 r = sd_bus_message_exit_container(message);
3516 if (r < 0)
3517 return r;
3518
3519 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3520 if (n_extension_images == 0) {
3521 c->extension_images = mount_image_free_many(c->extension_images, &c->n_extension_images);
3522
3523 unit_write_settingf(u, flags, name, "%s=", name);
3524 } else {
3525 for (size_t i = 0; i < n_extension_images; ++i) {
3526 r = mount_image_add(&c->extension_images, &c->n_extension_images, &extension_images[i]);
3527 if (r < 0)
3528 return r;
3529 }
3530
3531 unit_write_settingf(u, flags|UNIT_ESCAPE_C|UNIT_ESCAPE_SPECIFIERS,
3532 name,
3533 "%s=%s",
3534 name,
3535 format_str);
3536 }
3537 }
3538
3539 extension_images = mount_image_free_many(extension_images, &n_extension_images);
3540
3541 return 1;
3542 }
3543
3544 return 0;
3545 }