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