]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/dbus-execute.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
resolve: set IP_RECVERR
[thirdparty/systemd.git] / src / core / dbus-execute.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
4139c1b2 2
227b8a76 3#include <sys/mount.h>
82c121a4 4#include <sys/prctl.h>
0d536673 5#include <stdio_ext.h>
4139c1b2 6
349cc4a5 7#if HAVE_SECCOMP
57183d11
LP		 8#include <seccomp.h>
9#endif
10
3ffd4af2 11#include "af-list.h"
b5efdb8a 12#include "alloc-util.h"
718db961 13#include "bus-util.h"
cffaed83 14#include "cap-list.h"
d3070fbd 15#include "capability-util.h"
501941aa 16#include "cpu-set-util.h"
3ffd4af2 17#include "dbus-execute.h"
7e2a3fcc 18#include "dbus-util.h"
c7040b5d 19#include "env-util.h"
cffaed83 20#include "errno-list.h"
2e59b241 21#include "escape.h"
3ffd4af2
LP		 22#include "execute.h"
23#include "fd-util.h"
24#include "fileio.h"
08f3be7a 25#include "hexdecoct.h"
d3070fbd 26#include "io-util.h"
3ffd4af2 27#include "ioprio.h"
d3070fbd 28#include "journal-util.h"
3ffd4af2 29#include "missing.h"
83555251 30#include "mount-util.h"
417116f2 31#include "namespace.h"
6bedfcbb 32#include "parse-util.h"
9b15b784 33#include "path-util.h"
7b3e062c 34#include "process-util.h"
78f22b97 35#include "rlimit-util.h"
349cc4a5 36#if HAVE_SECCOMP
57183d11
LP		 37#include "seccomp-util.h"
38#endif
cffaed83 39#include "securebits-util.h"
2e59b241 40#include "specifier.h"
6bedfcbb 41#include "strv.h"
7ccbd1ae 42#include "syslog-util.h"
f900f582 43#include "unit-printf.h"
6f3e7985 44#include "user-util.h"
6bedfcbb 45#include "utf8.h"
57183d11 46
718db961 47BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_output, exec_output, ExecOutput);
718db961 48static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_input, exec_input, ExecInput);
023a4f67 49static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode);
53f47dfc 50static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_preserve_mode, exec_preserve_mode, ExecPreserveMode);
b1edf445 51static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_keyring_mode, exec_keyring_mode, ExecKeyringMode);
73b84e92
YW		 52static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_home, protect_home, ProtectHome);
53static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_protect_system, protect_system, ProtectSystem);
491eecb3 54static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_personality, personality, unsigned long);
019b34ca
YW		 55static BUS_DEFINE_PROPERTY_GET(property_get_ioprio, "i", ExecContext, exec_context_get_effective_ioprio);
56static BUS_DEFINE_PROPERTY_GET2(property_get_ioprio_class, "i", ExecContext, exec_context_get_effective_ioprio, IOPRIO_PRIO_CLASS);
57static BUS_DEFINE_PROPERTY_GET2(property_get_ioprio_priority, "i", ExecContext, exec_context_get_effective_ioprio, IOPRIO_PRIO_DATA);
92c23c5a
YW		 58static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_empty_string, "s", NULL);
59static BUS_DEFINE_PROPERTY_GET_REF(property_get_syslog_level, "i", int, LOG_PRI);
60static BUS_DEFINE_PROPERTY_GET_REF(property_get_syslog_facility, "i", int, LOG_FAC);
417116f2 61
718db961
LP		 62static int property_get_environment_files(
63 sd_bus *bus,
64 const char *path,
65 const char *interface,
66 const char *property,
67 sd_bus_message *reply,
ebcf1f97
LP		 68 void *userdata,
69 sd_bus_error *error) {
8c7be95e 70
718db961
LP		 71 ExecContext *c = userdata;
72 char **j;
73 int r;
8c7be95e 74
718db961
LP		 75 assert(bus);
76 assert(reply);
77 assert(c);
78
79 r = sd_bus_message_open_container(reply, 'a', "(sb)");
80 if (r < 0)
81 return r;
8c7be95e 82
718db961
LP		 83 STRV_FOREACH(j, c->environment_files) {
84 const char *fn = *j;
8c7be95e 85
718db961
LP		 86 r = sd_bus_message_append(reply, "(sb)", fn[0] == '-' ? fn + 1 : fn, fn[0] == '-');
87 if (r < 0)
88 return r;
8c7be95e
LP		 89 }
90
718db961
LP		 91 return sd_bus_message_close_container(reply);
92}
93
718db961
LP		 94static int property_get_oom_score_adjust(
95 sd_bus *bus,
96 const char *path,
97 const char *interface,
98 const char *property,
99 sd_bus_message *reply,
ebcf1f97
LP		 100 void *userdata,
101 sd_bus_error *error) {
718db961 102
718db961 103 ExecContext *c = userdata;
82c121a4
LP		 104 int32_t n;
105
718db961
LP		 106 assert(bus);
107 assert(reply);
82c121a4
LP		 108 assert(c);
109
dd6c17b1
LP		 110 if (c->oom_score_adjust_set)
111 n = c->oom_score_adjust;
82c121a4 112 else {
68eda4bd 113 _cleanup_free_ char *t = NULL;
82c121a4
LP		 114
115 n = 0;
718db961 116 if (read_one_line_file("/proc/self/oom_score_adj", &t) >= 0)
e4e73a63 117 safe_atoi32(t, &n);
82c121a4
LP		 118 }
119
718db961 120 return sd_bus_message_append(reply, "i", n);
82c121a4
LP		 121}
122
718db961
LP		 123static int property_get_nice(
124 sd_bus *bus,
125 const char *path,
126 const char *interface,
127 const char *property,
128 sd_bus_message *reply,
ebcf1f97
LP		 129 void *userdata,
130 sd_bus_error *error) {
718db961 131
718db961 132 ExecContext *c = userdata;
82c121a4
LP		 133 int32_t n;
134
718db961
LP		 135 assert(bus);
136 assert(reply);
82c121a4
LP		 137 assert(c);
138
139 if (c->nice_set)
140 n = c->nice;
718db961
LP		 141 else {
142 errno = 0;
82c121a4 143 n = getpriority(PRIO_PROCESS, 0);
b3267152 144 if (errno > 0)
718db961
LP		 145 n = 0;
146 }
82c121a4 147
718db961 148 return sd_bus_message_append(reply, "i", n);
82c121a4
LP		 149}
150
718db961
LP		 151static int property_get_cpu_sched_policy(
152 sd_bus *bus,
153 const char *path,
154 const char *interface,
155 const char *property,
156 sd_bus_message *reply,
ebcf1f97
LP		 157 void *userdata,
158 sd_bus_error *error) {
718db961
LP		 159
160 ExecContext *c = userdata;
82c121a4
LP		 161 int32_t n;
162
718db961
LP		 163 assert(bus);
164 assert(reply);
82c121a4
LP		 165 assert(c);
166
167 if (c->cpu_sched_set)
168 n = c->cpu_sched_policy;
718db961 169 else {
82c121a4 170 n = sched_getscheduler(0);
718db961
LP		 171 if (n < 0)
172 n = SCHED_OTHER;
173 }
82c121a4 174
718db961 175 return sd_bus_message_append(reply, "i", n);
82c121a4
LP		 176}
177
718db961
LP		 178static int property_get_cpu_sched_priority(
179 sd_bus *bus,
180 const char *path,
181 const char *interface,
182 const char *property,
183 sd_bus_message *reply,
ebcf1f97
LP		 184 void *userdata,
185 sd_bus_error *error) {
718db961
LP		 186
187 ExecContext *c = userdata;
82c121a4
LP		 188 int32_t n;
189
718db961
LP		 190 assert(bus);
191 assert(reply);
82c121a4
LP		 192 assert(c);
193
194 if (c->cpu_sched_set)
195 n = c->cpu_sched_priority;
196 else {
b92bea5d 197 struct sched_param p = {};
82c121a4 198
82c121a4
LP		 199 if (sched_getparam(0, &p) >= 0)
200 n = p.sched_priority;
e62d8c39
ZJS		 201 else
202 n = 0;
82c121a4
LP		 203 }
204
718db961 205 return sd_bus_message_append(reply, "i", n);
82c121a4
LP		 206}
207
718db961
LP		 208static int property_get_cpu_affinity(
209 sd_bus *bus,
210 const char *path,
211 const char *interface,
212 const char *property,
213 sd_bus_message *reply,
ebcf1f97
LP		 214 void *userdata,
215 sd_bus_error *error) {
82c121a4 216
718db961 217 ExecContext *c = userdata;
82c121a4 218
718db961
LP		 219 assert(bus);
220 assert(reply);
221 assert(c);
82c121a4 222
b3bc33e6 223 return sd_bus_message_append_array(reply, 'y', c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
82c121a4
LP		 224}
225
718db961
LP		 226static int property_get_timer_slack_nsec(
227 sd_bus *bus,
228 const char *path,
229 const char *interface,
230 const char *property,
231 sd_bus_message *reply,
ebcf1f97
LP		 232 void *userdata,
233 sd_bus_error *error) {
718db961
LP		 234
235 ExecContext *c = userdata;
82c121a4
LP		 236 uint64_t u;
237
718db961
LP		 238 assert(bus);
239 assert(reply);
82c121a4
LP		 240 assert(c);
241
3a43da28 242 if (c->timer_slack_nsec != NSEC_INFINITY)
03fae018 243 u = (uint64_t) c->timer_slack_nsec;
82c121a4
LP		 244 else
245 u = (uint64_t) prctl(PR_GET_TIMERSLACK);
246
718db961 247 return sd_bus_message_append(reply, "t", u);
82c121a4
LP		 248}
249
718db961
LP		 250static int property_get_syscall_filter(
251 sd_bus *bus,
252 const char *path,
253 const char *interface,
254 const char *property,
255 sd_bus_message *reply,
ebcf1f97
LP		 256 void *userdata,
257 sd_bus_error *error) {
82c121a4 258
17df7223
LP		 259 ExecContext *c = userdata;
260 _cleanup_strv_free_ char **l = NULL;
57183d11
LP		 261 int r;
262
349cc4a5 263#if HAVE_SECCOMP
17df7223 264 Iterator i;
8cfa775f 265 void *id, *val;
351a19b1 266#endif
17df7223
LP		 267
268 assert(bus);
269 assert(reply);
270 assert(c);
271
57183d11
LP		 272 r = sd_bus_message_open_container(reply, 'r', "bas");
273 if (r < 0)
274 return r;
275
276 r = sd_bus_message_append(reply, "b", c->syscall_whitelist);
277 if (r < 0)
278 return r;
279
349cc4a5 280#if HAVE_SECCOMP
8cfa775f
YW		 281 HASHMAP_FOREACH_KEY(val, id, c->syscall_filter, i) {
282 _cleanup_free_ char *name = NULL;
283 const char *e = NULL;
284 char *s;
285 int num = PTR_TO_INT(val);
17df7223
LP		 286
287 name = seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1);
288 if (!name)
289 continue;
290
8cfa775f
YW		 291 if (num >= 0) {
292 e = errno_to_name(num);
293 if (e) {
294 s = strjoin(name, ":", e);
295 if (!s)
296 return -ENOMEM;
297 } else {
298 r = asprintf(&s, "%s:%d", name, num);
299 if (r < 0)
300 return -ENOMEM;
301 }
ae2a15bc
LP		 302 } else
303 s = TAKE_PTR(name);
8cfa775f
YW		 304
305 r = strv_consume(&l, s);
6e18964d
ZJS		 306 if (r < 0)
307 return r;
17df7223 308 }
351a19b1 309#endif
17df7223
LP		 310
311 strv_sort(l);
312
57183d11
LP		 313 r = sd_bus_message_append_strv(reply, l);
314 if (r < 0)
315 return r;
17df7223 316
57183d11
LP		 317 return sd_bus_message_close_container(reply);
318}
17df7223 319
57183d11
LP		 320static int property_get_syscall_archs(
321 sd_bus *bus,
322 const char *path,
323 const char *interface,
324 const char *property,
325 sd_bus_message *reply,
326 void *userdata,
327 sd_bus_error *error) {
328
329 ExecContext *c = userdata;
330 _cleanup_strv_free_ char **l = NULL;
331 int r;
332
349cc4a5 333#if HAVE_SECCOMP
57183d11
LP		 334 Iterator i;
335 void *id;
336#endif
337
338 assert(bus);
339 assert(reply);
340 assert(c);
17df7223 341
349cc4a5 342#if HAVE_SECCOMP
57183d11
LP		 343 SET_FOREACH(id, c->syscall_archs, i) {
344 const char *name;
345
346 name = seccomp_arch_to_string(PTR_TO_UINT32(id) - 1);
347 if (!name)
348 continue;
349
350 r = strv_extend(&l, name);
351 if (r < 0)
352 return -ENOMEM;
17df7223 353 }
57183d11
LP		 354#endif
355
356 strv_sort(l);
357
358 r = sd_bus_message_append_strv(reply, l);
359 if (r < 0)
360 return r;
17df7223 361
57183d11 362 return 0;
17df7223
LP		 363}
364
5f8640fb
LP		 365static int property_get_selinux_context(
366 sd_bus *bus,
367 const char *path,
368 const char *interface,
369 const char *property,
370 sd_bus_message *reply,
371 void *userdata,
372 sd_bus_error *error) {
373
374 ExecContext *c = userdata;
375
376 assert(bus);
377 assert(reply);
378 assert(c);
379
380 return sd_bus_message_append(reply, "(bs)", c->selinux_context_ignore, c->selinux_context);
381}
382
eef65bf3
MS		 383static int property_get_apparmor_profile(
384 sd_bus *bus,
385 const char *path,
386 const char *interface,
387 const char *property,
388 sd_bus_message *reply,
389 void *userdata,
390 sd_bus_error *error) {
391
392 ExecContext *c = userdata;
393
394 assert(bus);
395 assert(reply);
396 assert(c);
397
398 return sd_bus_message_append(reply, "(bs)", c->apparmor_profile_ignore, c->apparmor_profile);
399}
400
2ca620c4
WC		 401static int property_get_smack_process_label(
402 sd_bus *bus,
403 const char *path,
404 const char *interface,
405 const char *property,
406 sd_bus_message *reply,
407 void *userdata,
408 sd_bus_error *error) {
409
410 ExecContext *c = userdata;
411
412 assert(bus);
413 assert(reply);
414 assert(c);
415
416 return sd_bus_message_append(reply, "(bs)", c->smack_process_label_ignore, c->smack_process_label);
417}
418
4298d0b5
LP		 419static int property_get_address_families(
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 Iterator i;
431 void *af;
432 int r;
433
434 assert(bus);
435 assert(reply);
436 assert(c);
437
438 r = sd_bus_message_open_container(reply, 'r', "bas");
439 if (r < 0)
440 return r;
441
442 r = sd_bus_message_append(reply, "b", c->address_families_whitelist);
443 if (r < 0)
444 return r;
445
446 SET_FOREACH(af, c->address_families, i) {
447 const char *name;
448
449 name = af_to_name(PTR_TO_INT(af));
450 if (!name)
451 continue;
452
453 r = strv_extend(&l, name);
454 if (r < 0)
455 return -ENOMEM;
456 }
457
458 strv_sort(l);
459
460 r = sd_bus_message_append_strv(reply, l);
461 if (r < 0)
462 return r;
463
464 return sd_bus_message_close_container(reply);
465}
466
5f5d8eab
LP		 467static int property_get_working_directory(
468 sd_bus *bus,
469 const char *path,
470 const char *interface,
471 const char *property,
472 sd_bus_message *reply,
473 void *userdata,
474 sd_bus_error *error) {
475
476 ExecContext *c = userdata;
477 const char *wd;
478
479 assert(bus);
480 assert(reply);
481 assert(c);
482
483 if (c->working_directory_home)
484 wd = "~";
485 else
486 wd = c->working_directory;
487
488 if (c->working_directory_missing_ok)
489 wd = strjoina("!", wd);
490
491 return sd_bus_message_append(reply, "s", wd);
492}
493
5073ff6b 494static int property_get_stdio_fdname(
52c239d7
LB		 495 sd_bus *bus,
496 const char *path,
497 const char *interface,
498 const char *property,
499 sd_bus_message *reply,
500 void *userdata,
501 sd_bus_error *error) {
502
503 ExecContext *c = userdata;
5073ff6b 504 int fileno;
52c239d7
LB		 505
506 assert(bus);
507 assert(c);
508 assert(property);
509 assert(reply);
510
5073ff6b
LP		 511 if (streq(property, "StandardInputFileDescriptorName"))
512 fileno = STDIN_FILENO;
513 else if (streq(property, "StandardOutputFileDescriptorName"))
514 fileno = STDOUT_FILENO;
515 else {
516 assert(streq(property, "StandardErrorFileDescriptorName"));
517 fileno = STDERR_FILENO;
518 }
52c239d7 519
5073ff6b 520 return sd_bus_message_append(reply, "s", exec_context_fdname(c, fileno));
52c239d7
LB		 521}
522
08f3be7a 523static int property_get_input_data(
52c239d7
LB		 524 sd_bus *bus,
525 const char *path,
526 const char *interface,
527 const char *property,
528 sd_bus_message *reply,
529 void *userdata,
530 sd_bus_error *error) {
531
532 ExecContext *c = userdata;
52c239d7
LB		 533
534 assert(bus);
535 assert(c);
536 assert(property);
537 assert(reply);
538
08f3be7a 539 return sd_bus_message_append_array(reply, 'y', c->stdin_data, c->stdin_data_size);
52c239d7
LB		 540}
541
d2d6c096
LP		 542static int property_get_bind_paths(
543 sd_bus *bus,
544 const char *path,
545 const char *interface,
546 const char *property,
547 sd_bus_message *reply,
548 void *userdata,
549 sd_bus_error *error) {
550
551 ExecContext *c = userdata;
552 unsigned i;
553 bool ro;
554 int r;
555
556 assert(bus);
557 assert(c);
558 assert(property);
559 assert(reply);
560
5d904a6a 561 ro = strstr(property, "ReadOnly");
d2d6c096
LP		 562
563 r = sd_bus_message_open_container(reply, 'a', "(ssbt)");
564 if (r < 0)
565 return r;
566
567 for (i = 0; i < c->n_bind_mounts; i++) {
568
569 if (ro != c->bind_mounts[i].read_only)
570 continue;
571
572 r = sd_bus_message_append(
573 reply, "(ssbt)",
574 c->bind_mounts[i].source,
575 c->bind_mounts[i].destination,
576 c->bind_mounts[i].ignore_enoent,
c9b06108 577 c->bind_mounts[i].recursive ? (uint64_t) MS_REC : (uint64_t) 0);
d2d6c096
LP		 578 if (r < 0)
579 return r;
580 }
581
582 return sd_bus_message_close_container(reply);
583}
584
784ad252
YW		 585static int property_get_temporary_filesystems(
586 sd_bus *bus,
587 const char *path,
588 const char *interface,
589 const char *property,
590 sd_bus_message *reply,
591 void *userdata,
592 sd_bus_error *error) {
593
594 ExecContext *c = userdata;
595 unsigned i;
596 int r;
597
598 assert(bus);
599 assert(c);
600 assert(property);
601 assert(reply);
602
603 r = sd_bus_message_open_container(reply, 'a', "(ss)");
604 if (r < 0)
605 return r;
606
607 for (i = 0; i < c->n_temporary_filesystems; i++) {
608 TemporaryFileSystem *t = c->temporary_filesystems + i;
609
610 r = sd_bus_message_append(
611 reply, "(ss)",
612 t->path,
613 t->options);
614 if (r < 0)
615 return r;
616 }
617
618 return sd_bus_message_close_container(reply);
619}
620
d3070fbd
LP		 621static int property_get_log_extra_fields(
622 sd_bus *bus,
623 const char *path,
624 const char *interface,
625 const char *property,
626 sd_bus_message *reply,
627 void *userdata,
628 sd_bus_error *error) {
629
630 ExecContext *c = userdata;
631 size_t i;
632 int r;
633
634 assert(bus);
635 assert(c);
636 assert(property);
637 assert(reply);
638
639 r = sd_bus_message_open_container(reply, 'a', "ay");
640 if (r < 0)
641 return r;
642
643 for (i = 0; i < c->n_log_extra_fields; i++) {
644 r = sd_bus_message_append_array(reply, 'y', c->log_extra_fields[i].iov_base, c->log_extra_fields[i].iov_len);
645 if (r < 0)
646 return r;
647 }
648
649 return sd_bus_message_close_container(reply);
650}
651
718db961
LP		 652const sd_bus_vtable bus_exec_vtable[] = {
653 SD_BUS_VTABLE_START(0),
556089dc
LP		 654 SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(ExecContext, environment), SD_BUS_VTABLE_PROPERTY_CONST),
655 SD_BUS_PROPERTY("EnvironmentFiles", "a(sb)", property_get_environment_files, 0, SD_BUS_VTABLE_PROPERTY_CONST),
b4c14404 656 SD_BUS_PROPERTY("PassEnvironment", "as", NULL, offsetof(ExecContext, pass_environment), SD_BUS_VTABLE_PROPERTY_CONST),
00819cc1 657 SD_BUS_PROPERTY("UnsetEnvironment", "as", NULL, offsetof(ExecContext, unset_environment), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 658 SD_BUS_PROPERTY("UMask", "u", bus_property_get_mode, offsetof(ExecContext, umask), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 659 SD_BUS_PROPERTY("LimitCPU", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 660 SD_BUS_PROPERTY("LimitCPUSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 661 SD_BUS_PROPERTY("LimitFSIZE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 662 SD_BUS_PROPERTY("LimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 663 SD_BUS_PROPERTY("LimitDATA", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 664 SD_BUS_PROPERTY("LimitDATASoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 665 SD_BUS_PROPERTY("LimitSTACK", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 666 SD_BUS_PROPERTY("LimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 667 SD_BUS_PROPERTY("LimitCORE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 668 SD_BUS_PROPERTY("LimitCORESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 669 SD_BUS_PROPERTY("LimitRSS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 670 SD_BUS_PROPERTY("LimitRSSSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 671 SD_BUS_PROPERTY("LimitNOFILE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 672 SD_BUS_PROPERTY("LimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 673 SD_BUS_PROPERTY("LimitAS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 674 SD_BUS_PROPERTY("LimitASSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 675 SD_BUS_PROPERTY("LimitNPROC", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 676 SD_BUS_PROPERTY("LimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 677 SD_BUS_PROPERTY("LimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 678 SD_BUS_PROPERTY("LimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 679 SD_BUS_PROPERTY("LimitLOCKS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 680 SD_BUS_PROPERTY("LimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 681 SD_BUS_PROPERTY("LimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 682 SD_BUS_PROPERTY("LimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 683 SD_BUS_PROPERTY("LimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 684 SD_BUS_PROPERTY("LimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 685 SD_BUS_PROPERTY("LimitNICE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 686 SD_BUS_PROPERTY("LimitNICESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 687 SD_BUS_PROPERTY("LimitRTPRIO", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 688 SD_BUS_PROPERTY("LimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
c9d031c3 689 SD_BUS_PROPERTY("LimitRTTIME", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 690 SD_BUS_PROPERTY("LimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
5f5d8eab 691 SD_BUS_PROPERTY("WorkingDirectory", "s", property_get_working_directory, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 692 SD_BUS_PROPERTY("RootDirectory", "s", NULL, offsetof(ExecContext, root_directory), SD_BUS_VTABLE_PROPERTY_CONST),
915e6d16 693 SD_BUS_PROPERTY("RootImage", "s", NULL, offsetof(ExecContext, root_image), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 694 SD_BUS_PROPERTY("OOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
695 SD_BUS_PROPERTY("Nice", "i", property_get_nice, 0, SD_BUS_VTABLE_PROPERTY_CONST),
7f452159
LP		 696 SD_BUS_PROPERTY("IOSchedulingClass", "i", property_get_ioprio_class, 0, SD_BUS_VTABLE_PROPERTY_CONST),
697 SD_BUS_PROPERTY("IOSchedulingPriority", "i", property_get_ioprio_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 698 SD_BUS_PROPERTY("CPUSchedulingPolicy", "i", property_get_cpu_sched_policy, 0, SD_BUS_VTABLE_PROPERTY_CONST),
699 SD_BUS_PROPERTY("CPUSchedulingPriority", "i", property_get_cpu_sched_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
700 SD_BUS_PROPERTY("CPUAffinity", "ay", property_get_cpu_affinity, 0, SD_BUS_VTABLE_PROPERTY_CONST),
701 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
702 SD_BUS_PROPERTY("CPUSchedulingResetOnFork", "b", bus_property_get_bool, offsetof(ExecContext, cpu_sched_reset_on_fork), SD_BUS_VTABLE_PROPERTY_CONST),
703 SD_BUS_PROPERTY("NonBlocking", "b", bus_property_get_bool, offsetof(ExecContext, non_blocking), SD_BUS_VTABLE_PROPERTY_CONST),
704 SD_BUS_PROPERTY("StandardInput", "s", property_get_exec_input, offsetof(ExecContext, std_input), SD_BUS_VTABLE_PROPERTY_CONST),
5073ff6b 705 SD_BUS_PROPERTY("StandardInputFileDescriptorName", "s", property_get_stdio_fdname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
08f3be7a 706 SD_BUS_PROPERTY("StandardInputData", "ay", property_get_input_data, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 707 SD_BUS_PROPERTY("StandardOutput", "s", bus_property_get_exec_output, offsetof(ExecContext, std_output), SD_BUS_VTABLE_PROPERTY_CONST),
5073ff6b 708 SD_BUS_PROPERTY("StandardOutputFileDescriptorName", "s", property_get_stdio_fdname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 709 SD_BUS_PROPERTY("StandardError", "s", bus_property_get_exec_output, offsetof(ExecContext, std_error), SD_BUS_VTABLE_PROPERTY_CONST),
5073ff6b 710 SD_BUS_PROPERTY("StandardErrorFileDescriptorName", "s", property_get_stdio_fdname, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 711 SD_BUS_PROPERTY("TTYPath", "s", NULL, offsetof(ExecContext, tty_path), SD_BUS_VTABLE_PROPERTY_CONST),
712 SD_BUS_PROPERTY("TTYReset", "b", bus_property_get_bool, offsetof(ExecContext, tty_reset), SD_BUS_VTABLE_PROPERTY_CONST),
713 SD_BUS_PROPERTY("TTYVHangup", "b", bus_property_get_bool, offsetof(ExecContext, tty_vhangup), SD_BUS_VTABLE_PROPERTY_CONST),
714 SD_BUS_PROPERTY("TTYVTDisallocate", "b", bus_property_get_bool, offsetof(ExecContext, tty_vt_disallocate), SD_BUS_VTABLE_PROPERTY_CONST),
715 SD_BUS_PROPERTY("SyslogPriority", "i", bus_property_get_int, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
716 SD_BUS_PROPERTY("SyslogIdentifier", "s", NULL, offsetof(ExecContext, syslog_identifier), SD_BUS_VTABLE_PROPERTY_CONST),
717 SD_BUS_PROPERTY("SyslogLevelPrefix", "b", bus_property_get_bool, offsetof(ExecContext, syslog_level_prefix), SD_BUS_VTABLE_PROPERTY_CONST),
9d5527f2
YW		 718 SD_BUS_PROPERTY("SyslogLevel", "i", property_get_syslog_level, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
719 SD_BUS_PROPERTY("SyslogFacility", "i", property_get_syslog_facility, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
d3070fbd
LP		 720 SD_BUS_PROPERTY("LogLevelMax", "i", bus_property_get_int, offsetof(ExecContext, log_level_max), SD_BUS_VTABLE_PROPERTY_CONST),
721 SD_BUS_PROPERTY("LogExtraFields", "aay", property_get_log_extra_fields, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 722 SD_BUS_PROPERTY("SecureBits", "i", bus_property_get_int, offsetof(ExecContext, secure_bits), SD_BUS_VTABLE_PROPERTY_CONST),
c0159e20
YW		 723 SD_BUS_PROPERTY("CapabilityBoundingSet", "t", NULL, offsetof(ExecContext, capability_bounding_set), SD_BUS_VTABLE_PROPERTY_CONST),
724 SD_BUS_PROPERTY("AmbientCapabilities", "t", NULL, offsetof(ExecContext, capability_ambient_set), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 725 SD_BUS_PROPERTY("User", "s", NULL, offsetof(ExecContext, user), SD_BUS_VTABLE_PROPERTY_CONST),
726 SD_BUS_PROPERTY("Group", "s", NULL, offsetof(ExecContext, group), SD_BUS_VTABLE_PROPERTY_CONST),
29206d46 727 SD_BUS_PROPERTY("DynamicUser", "b", bus_property_get_bool, offsetof(ExecContext, dynamic_user), SD_BUS_VTABLE_PROPERTY_CONST),
00d9ef85 728 SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool, offsetof(ExecContext, remove_ipc), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 729 SD_BUS_PROPERTY("SupplementaryGroups", "as", NULL, offsetof(ExecContext, supplementary_groups), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 730 SD_BUS_PROPERTY("PAMName", "s", NULL, offsetof(ExecContext, pam_name), SD_BUS_VTABLE_PROPERTY_CONST),
2a624c36
AP		 731 SD_BUS_PROPERTY("ReadWritePaths", "as", NULL, offsetof(ExecContext, read_write_paths), SD_BUS_VTABLE_PROPERTY_CONST),
732 SD_BUS_PROPERTY("ReadOnlyPaths", "as", NULL, offsetof(ExecContext, read_only_paths), SD_BUS_VTABLE_PROPERTY_CONST),
733 SD_BUS_PROPERTY("InaccessiblePaths", "as", NULL, offsetof(ExecContext, inaccessible_paths), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 734 SD_BUS_PROPERTY("MountFlags", "t", bus_property_get_ulong, offsetof(ExecContext, mount_flags), SD_BUS_VTABLE_PROPERTY_CONST),
735 SD_BUS_PROPERTY("PrivateTmp", "b", bus_property_get_bool, offsetof(ExecContext, private_tmp), SD_BUS_VTABLE_PROPERTY_CONST),
7f112f50 736 SD_BUS_PROPERTY("PrivateDevices", "b", bus_property_get_bool, offsetof(ExecContext, private_devices), SD_BUS_VTABLE_PROPERTY_CONST),
59eeb84b 737 SD_BUS_PROPERTY("ProtectKernelTunables", "b", bus_property_get_bool, offsetof(ExecContext, protect_kernel_tunables), SD_BUS_VTABLE_PROPERTY_CONST),
502d704e 738 SD_BUS_PROPERTY("ProtectKernelModules", "b", bus_property_get_bool, offsetof(ExecContext, protect_kernel_modules), SD_BUS_VTABLE_PROPERTY_CONST),
59eeb84b 739 SD_BUS_PROPERTY("ProtectControlGroups", "b", bus_property_get_bool, offsetof(ExecContext, protect_control_groups), SD_BUS_VTABLE_PROPERTY_CONST),
d251207d
LP		 740 SD_BUS_PROPERTY("PrivateNetwork", "b", bus_property_get_bool, offsetof(ExecContext, private_network), SD_BUS_VTABLE_PROPERTY_CONST),
741 SD_BUS_PROPERTY("PrivateUsers", "b", bus_property_get_bool, offsetof(ExecContext, private_users), SD_BUS_VTABLE_PROPERTY_CONST),
228af36f 742 SD_BUS_PROPERTY("PrivateMounts", "b", bus_property_get_bool, offsetof(ExecContext, private_mounts), SD_BUS_VTABLE_PROPERTY_CONST),
73b84e92
YW		 743 SD_BUS_PROPERTY("ProtectHome", "s", property_get_protect_home, offsetof(ExecContext, protect_home), SD_BUS_VTABLE_PROPERTY_CONST),
744 SD_BUS_PROPERTY("ProtectSystem", "s", property_get_protect_system, offsetof(ExecContext, protect_system), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 745 SD_BUS_PROPERTY("SameProcessGroup", "b", bus_property_get_bool, offsetof(ExecContext, same_pgrp), SD_BUS_VTABLE_PROPERTY_CONST),
746 SD_BUS_PROPERTY("UtmpIdentifier", "s", NULL, offsetof(ExecContext, utmp_id), SD_BUS_VTABLE_PROPERTY_CONST),
023a4f67 747 SD_BUS_PROPERTY("UtmpMode", "s", property_get_exec_utmp_mode, offsetof(ExecContext, utmp_mode), SD_BUS_VTABLE_PROPERTY_CONST),
5f8640fb 748 SD_BUS_PROPERTY("SELinuxContext", "(bs)", property_get_selinux_context, 0, SD_BUS_VTABLE_PROPERTY_CONST),
eef65bf3 749 SD_BUS_PROPERTY("AppArmorProfile", "(bs)", property_get_apparmor_profile, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2ca620c4 750 SD_BUS_PROPERTY("SmackProcessLabel", "(bs)", property_get_smack_process_label, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc
LP		 751 SD_BUS_PROPERTY("IgnoreSIGPIPE", "b", bus_property_get_bool, offsetof(ExecContext, ignore_sigpipe), SD_BUS_VTABLE_PROPERTY_CONST),
752 SD_BUS_PROPERTY("NoNewPrivileges", "b", bus_property_get_bool, offsetof(ExecContext, no_new_privileges), SD_BUS_VTABLE_PROPERTY_CONST),
57183d11
LP		 753 SD_BUS_PROPERTY("SystemCallFilter", "(bas)", property_get_syscall_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
754 SD_BUS_PROPERTY("SystemCallArchitectures", "as", property_get_syscall_archs, 0, SD_BUS_VTABLE_PROPERTY_CONST),
cf9d43a8 755 SD_BUS_PROPERTY("SystemCallErrorNumber", "i", bus_property_get_int, offsetof(ExecContext, syscall_errno), SD_BUS_VTABLE_PROPERTY_CONST),
491eecb3 756 SD_BUS_PROPERTY("Personality", "s", property_get_personality, offsetof(ExecContext, personality), SD_BUS_VTABLE_PROPERTY_CONST),
78e864e5 757 SD_BUS_PROPERTY("LockPersonality", "b", bus_property_get_bool, offsetof(ExecContext, lock_personality), SD_BUS_VTABLE_PROPERTY_CONST),
4298d0b5 758 SD_BUS_PROPERTY("RestrictAddressFamilies", "(bas)", property_get_address_families, 0, SD_BUS_VTABLE_PROPERTY_CONST),
53f47dfc 759 SD_BUS_PROPERTY("RuntimeDirectoryPreserve", "s", property_get_exec_preserve_mode, offsetof(ExecContext, runtime_directory_preserve_mode), SD_BUS_VTABLE_PROPERTY_CONST),
3536f49e
YW		 760 SD_BUS_PROPERTY("RuntimeDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_RUNTIME].mode), SD_BUS_VTABLE_PROPERTY_CONST),
761 SD_BUS_PROPERTY("RuntimeDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_RUNTIME].paths), SD_BUS_VTABLE_PROPERTY_CONST),
e940c1ef
YW		 762 SD_BUS_PROPERTY("StateDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_STATE].mode), SD_BUS_VTABLE_PROPERTY_CONST),
763 SD_BUS_PROPERTY("StateDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_STATE].paths), SD_BUS_VTABLE_PROPERTY_CONST),
3536f49e
YW		 764 SD_BUS_PROPERTY("CacheDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_CACHE].mode), SD_BUS_VTABLE_PROPERTY_CONST),
765 SD_BUS_PROPERTY("CacheDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_CACHE].paths), SD_BUS_VTABLE_PROPERTY_CONST),
766 SD_BUS_PROPERTY("LogsDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_LOGS].mode), SD_BUS_VTABLE_PROPERTY_CONST),
767 SD_BUS_PROPERTY("LogsDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_LOGS].paths), SD_BUS_VTABLE_PROPERTY_CONST),
768 SD_BUS_PROPERTY("ConfigurationDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, directories[EXEC_DIRECTORY_CONFIGURATION].mode), SD_BUS_VTABLE_PROPERTY_CONST),
769 SD_BUS_PROPERTY("ConfigurationDirectory", "as", NULL, offsetof(ExecContext, directories[EXEC_DIRECTORY_CONFIGURATION].paths), SD_BUS_VTABLE_PROPERTY_CONST),
f3e43635 770 SD_BUS_PROPERTY("MemoryDenyWriteExecute", "b", bus_property_get_bool, offsetof(ExecContext, memory_deny_write_execute), SD_BUS_VTABLE_PROPERTY_CONST),
f4170c67 771 SD_BUS_PROPERTY("RestrictRealtime", "b", bus_property_get_bool, offsetof(ExecContext, restrict_realtime), SD_BUS_VTABLE_PROPERTY_CONST),
6a8c2d59 772 SD_BUS_PROPERTY("RestrictNamespaces", "t", bus_property_get_ulong, offsetof(ExecContext, restrict_namespaces), SD_BUS_VTABLE_PROPERTY_CONST),
d2d6c096
LP		 773 SD_BUS_PROPERTY("BindPaths", "a(ssbt)", property_get_bind_paths, 0, SD_BUS_VTABLE_PROPERTY_CONST),
774 SD_BUS_PROPERTY("BindReadOnlyPaths", "a(ssbt)", property_get_bind_paths, 0, SD_BUS_VTABLE_PROPERTY_CONST),
784ad252 775 SD_BUS_PROPERTY("TemporaryFileSystem", "a(ss)", property_get_temporary_filesystems, 0, SD_BUS_VTABLE_PROPERTY_CONST),
5d997827 776 SD_BUS_PROPERTY("MountAPIVFS", "b", bus_property_get_bool, offsetof(ExecContext, mount_apivfs), SD_BUS_VTABLE_PROPERTY_CONST),
b1edf445 777 SD_BUS_PROPERTY("KeyringMode", "s", property_get_exec_keyring_mode, offsetof(ExecContext, keyring_mode), SD_BUS_VTABLE_PROPERTY_CONST),
7f452159
LP		 778
779 /* Obsolete/redundant properties: */
780 SD_BUS_PROPERTY("Capabilities", "s", property_get_empty_string, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
781 SD_BUS_PROPERTY("ReadWriteDirectories", "as", NULL, offsetof(ExecContext, read_write_paths), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
782 SD_BUS_PROPERTY("ReadOnlyDirectories", "as", NULL, offsetof(ExecContext, read_only_paths), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
783 SD_BUS_PROPERTY("InaccessibleDirectories", "as", NULL, offsetof(ExecContext, inaccessible_paths), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
784 SD_BUS_PROPERTY("IOScheduling", "i", property_get_ioprio, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
785
718db961
LP		 786 SD_BUS_VTABLE_END
787};
82c121a4 788
4d4c80d0
LP		 789static int append_exec_command(sd_bus_message *reply, ExecCommand *c) {
790 int r;
791
792 assert(reply);
793 assert(c);
794
795 if (!c->path)
796 return 0;
797
798 r = sd_bus_message_open_container(reply, 'r', "sasbttttuii");
799 if (r < 0)
800 return r;
801
802 r = sd_bus_message_append(reply, "s", c->path);
803 if (r < 0)
804 return r;
805
806 r = sd_bus_message_append_strv(reply, c->argv);
807 if (r < 0)
808 return r;
809
810 r = sd_bus_message_append(reply, "bttttuii",
3ed0cd26 811 !!(c->flags & EXEC_COMMAND_IGNORE_FAILURE),
4d4c80d0
LP		 812 c->exec_status.start_timestamp.realtime,
813 c->exec_status.start_timestamp.monotonic,
814 c->exec_status.exit_timestamp.realtime,
815 c->exec_status.exit_timestamp.monotonic,
816 (uint32_t) c->exec_status.pid,
817 (int32_t) c->exec_status.code,
818 (int32_t) c->exec_status.status);
819 if (r < 0)
820 return r;
821
822 return sd_bus_message_close_container(reply);
823}
824
718db961
LP		 825int bus_property_get_exec_command(
826 sd_bus *bus,
827 const char *path,
828 const char *interface,
829 const char *property,
830 sd_bus_message *reply,
ebcf1f97
LP		 831 void *userdata,
832 sd_bus_error *ret_error) {
fe68089d 833
4d4c80d0 834 ExecCommand *c = (ExecCommand*) userdata;
718db961 835 int r;
fe68089d 836
718db961
LP		 837 assert(bus);
838 assert(reply);
fe68089d 839
718db961
LP		 840 r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
841 if (r < 0)
842 return r;
fe68089d 843
4d4c80d0
LP		 844 r = append_exec_command(reply, c);
845 if (r < 0)
846 return r;
fe68089d 847
4d4c80d0
LP		 848 return sd_bus_message_close_container(reply);
849}
718db961 850
4d4c80d0
LP		 851int bus_property_get_exec_command_list(
852 sd_bus *bus,
853 const char *path,
854 const char *interface,
855 const char *property,
856 sd_bus_message *reply,
857 void *userdata,
858 sd_bus_error *ret_error) {
718db961 859
4d4c80d0
LP		 860 ExecCommand *c = *(ExecCommand**) userdata;
861 int r;
718db961 862
4d4c80d0
LP		 863 assert(bus);
864 assert(reply);
865
866 r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
867 if (r < 0)
868 return r;
718db961 869
4d4c80d0
LP		 870 LIST_FOREACH(command, c, c) {
871 r = append_exec_command(reply, c);
718db961
LP		 872 if (r < 0)
873 return r;
fe68089d
LP		 874 }
875
718db961 876 return sd_bus_message_close_container(reply);
8351ceae 877}
c7040b5d 878
237f7bcb 879int bus_set_transient_exec_command(
9c0320e7
YW		 880 Unit *u,
881 const char *name,
882 ExecCommand **exec_command,
883 sd_bus_message *message,
884 UnitWriteFlags flags,
885 sd_bus_error *error) {
886 unsigned n = 0;
887 int r;
888
889 r = sd_bus_message_enter_container(message, 'a', "(sasb)");
890 if (r < 0)
891 return r;
892
893 while ((r = sd_bus_message_enter_container(message, 'r', "sasb")) > 0) {
894 _cleanup_strv_free_ char **argv = NULL;
895 const char *path;
896 int b;
897
898 r = sd_bus_message_read(message, "s", &path);
899 if (r < 0)
900 return r;
901
902 if (!path_is_absolute(path))
903 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
904
905 r = sd_bus_message_read_strv(message, &argv);
906 if (r < 0)
907 return r;
908
909 r = sd_bus_message_read(message, "b", &b);
910 if (r < 0)
911 return r;
912
913 r = sd_bus_message_exit_container(message);
914 if (r < 0)
915 return r;
916
917 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
918 ExecCommand *c;
919
920 c = new0(ExecCommand, 1);
921 if (!c)
922 return -ENOMEM;
923
924 c->path = strdup(path);
925 if (!c->path) {
926 free(c);
927 return -ENOMEM;
928 }
929
ae2a15bc 930 c->argv = TAKE_PTR(argv);
9c0320e7
YW		 931
932 c->flags = b ? EXEC_COMMAND_IGNORE_FAILURE : 0;
933
858d36c1 934 path_simplify(c->path, false);
9c0320e7
YW		 935 exec_command_append_list(exec_command, c);
936 }
937
938 n++;
939 }
940 if (r < 0)
941 return r;
942
943 r = sd_bus_message_exit_container(message);
944 if (r < 0)
945 return r;
946
947 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
948 _cleanup_free_ char *buf = NULL;
949 _cleanup_fclose_ FILE *f = NULL;
950 ExecCommand *c;
951 size_t size = 0;
952
953 if (n == 0)
954 *exec_command = exec_command_free_list(*exec_command);
955
956 f = open_memstream(&buf, &size);
957 if (!f)
958 return -ENOMEM;
959
960 (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
961
962 fputs("ExecStart=\n", f);
963
964 LIST_FOREACH(command, c, *exec_command) {
965 _cleanup_free_ char *a = NULL, *t = NULL;
966 const char *p;
967
968 p = unit_escape_setting(c->path, UNIT_ESCAPE_C|UNIT_ESCAPE_SPECIFIERS, &t);
969 if (!p)
970 return -ENOMEM;
971
972 a = unit_concat_strv(c->argv, UNIT_ESCAPE_C|UNIT_ESCAPE_SPECIFIERS);
973 if (!a)
974 return -ENOMEM;
975
976 fprintf(f, "%s=%s@%s %s\n",
977 name,
978 c->flags & EXEC_COMMAND_IGNORE_FAILURE ? "-" : "",
979 p,
980 a);
981 }
982
983 r = fflush_and_check(f);
984 if (r < 0)
985 return r;
986
987 unit_write_setting(u, flags, name, buf);
988 }
989
990 return 1;
991}
992
7e2a3fcc
YW		 993static int parse_personality(const char *s, unsigned long *p) {
994 unsigned long v;
995
996 assert(p);
997
998 v = personality_from_string(s);
999 if (v == PERSONALITY_INVALID)
1000 return -EINVAL;
1001
1002 *p = v;
1003 return 0;
1004}
1005
1006static const char* mount_propagation_flags_to_string_with_check(unsigned long n) {
1007 if (!IN_SET(n, 0, MS_SHARED, MS_PRIVATE, MS_SLAVE))
1008 return NULL;
1009
1010 return mount_propagation_flags_to_string(n);
1011}
1012
1013static BUS_DEFINE_SET_TRANSIENT(nsec, "t", uint64_t, nsec_t, NSEC_FMT);
1014static BUS_DEFINE_SET_TRANSIENT_IS_VALID(log_level, "i", int32_t, int, "%" PRIi32, log_level_is_valid);
aad67b80 1015#if HAVE_SECCOMP
7e2a3fcc 1016static BUS_DEFINE_SET_TRANSIENT_IS_VALID(errno, "i", int32_t, int, "%" PRIi32, errno_is_valid);
aad67b80 1017#endif
7e2a3fcc
YW		 1018static BUS_DEFINE_SET_TRANSIENT_PARSE(std_input, ExecInput, exec_input_from_string);
1019static BUS_DEFINE_SET_TRANSIENT_PARSE(std_output, ExecOutput, exec_output_from_string);
1020static BUS_DEFINE_SET_TRANSIENT_PARSE(utmp_mode, ExecUtmpMode, exec_utmp_mode_from_string);
1e8c7bd5
YW		 1021static BUS_DEFINE_SET_TRANSIENT_PARSE(protect_system, ProtectSystem, protect_system_from_string);
1022static BUS_DEFINE_SET_TRANSIENT_PARSE(protect_home, ProtectHome, protect_home_from_string);
7e2a3fcc
YW		 1023static BUS_DEFINE_SET_TRANSIENT_PARSE(keyring_mode, ExecKeyringMode, exec_keyring_mode_from_string);
1024static BUS_DEFINE_SET_TRANSIENT_PARSE(preserve_mode, ExecPreserveMode, exec_preserve_mode_from_string);
1025static BUS_DEFINE_SET_TRANSIENT_PARSE_PTR(personality, unsigned long, parse_personality);
1026static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(secure_bits, "i", int32_t, int, "%" PRIi32, secure_bits_to_string_alloc_with_check);
1027static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(capability, "t", uint64_t, uint64_t, "%" PRIu64, capability_set_to_string_alloc);
86c2a9f1 1028static BUS_DEFINE_SET_TRANSIENT_TO_STRING_ALLOC(namespace_flag, "t", uint64_t, unsigned long, "%" PRIu64, namespace_flags_to_string);
7e2a3fcc
YW		 1029static BUS_DEFINE_SET_TRANSIENT_TO_STRING(mount_flags, "t", uint64_t, unsigned long, "%" PRIu64, mount_propagation_flags_to_string_with_check);
1030
c7040b5d
LP		 1031int bus_exec_context_set_transient_property(
1032 Unit *u,
1033 ExecContext *c,
1034 const char *name,
1035 sd_bus_message *message,
2e59b241 1036 UnitWriteFlags flags,
c7040b5d
LP		 1037 sd_bus_error *error) {
1038
6550c24c
LP		 1039 const char *suffix;
1040 int r;
c7040b5d
LP		 1041
1042 assert(u);
1043 assert(c);
1044 assert(name);
1045 assert(message);
1046
2e59b241
LP		 1047 flags |= UNIT_PRIVATE;
1048
7e2a3fcc
YW		 1049 if (streq(name, "User"))
1050 return bus_set_transient_user(u, name, &c->user, message, flags, error);
c7040b5d 1051
7e2a3fcc
YW		 1052 if (streq(name, "Group"))
1053 return bus_set_transient_user(u, name, &c->group, message, flags, error);
c7040b5d 1054
7e2a3fcc
YW		 1055 if (streq(name, "TTYPath"))
1056 return bus_set_transient_path(u, name, &c->tty_path, message, flags, error);
6f3e7985 1057
7e2a3fcc
YW		 1058 if (streq(name, "RootImage"))
1059 return bus_set_transient_path(u, name, &c->root_image, message, flags, error);
76736280 1060
7e2a3fcc
YW		 1061 if (streq(name, "RootDirectory"))
1062 return bus_set_transient_path(u, name, &c->root_directory, message, flags, error);
c7040b5d 1063
7e2a3fcc
YW		 1064 if (streq(name, "SyslogIdentifier"))
1065 return bus_set_transient_string(u, name, &c->syslog_identifier, message, flags, error);
c7040b5d 1066
7e2a3fcc
YW		 1067 if (streq(name, "LogLevelMax"))
1068 return bus_set_transient_log_level(u, name, &c->log_level_max, message, flags, error);
1069
7e2a3fcc
YW		 1070 if (streq(name, "Personality"))
1071 return bus_set_transient_personality(u, name, &c->personality, message, flags, error);
1072
7e2a3fcc
YW		 1073 if (streq(name, "StandardInput"))
1074 return bus_set_transient_std_input(u, name, &c->std_input, message, flags, error);
1075
1076 if (streq(name, "StandardOutput"))
1077 return bus_set_transient_std_output(u, name, &c->std_output, message, flags, error);
1078
1079 if (streq(name, "StandardError"))
1080 return bus_set_transient_std_output(u, name, &c->std_error, message, flags, error);
1081
1082 if (streq(name, "IgnoreSIGPIPE"))
1083 return bus_set_transient_bool(u, name, &c->ignore_sigpipe, message, flags, error);
1084
1085 if (streq(name, "TTYVHangup"))
1086 return bus_set_transient_bool(u, name, &c->tty_vhangup, message, flags, error);
1087
1088 if (streq(name, "TTYReset"))
1089 return bus_set_transient_bool(u, name, &c->tty_reset, message, flags, error);
1090
1091 if (streq(name, "TTYVTDisallocate"))
1092 return bus_set_transient_bool(u, name, &c->tty_vt_disallocate, message, flags, error);
1093
1094 if (streq(name, "PrivateTmp"))
1095 return bus_set_transient_bool(u, name, &c->private_tmp, message, flags, error);
1096
1097 if (streq(name, "PrivateDevices"))
1098 return bus_set_transient_bool(u, name, &c->private_devices, message, flags, error);
1099
228af36f
LP		 1100 if (streq(name, "PrivateMounts"))
1101 return bus_set_transient_bool(u, name, &c->private_mounts, message, flags, error);
1102
7e2a3fcc
YW		 1103 if (streq(name, "PrivateNetwork"))
1104 return bus_set_transient_bool(u, name, &c->private_network, message, flags, error);
1105
1106 if (streq(name, "PrivateUsers"))
1107 return bus_set_transient_bool(u, name, &c->private_users, message, flags, error);
1108
1109 if (streq(name, "NoNewPrivileges"))
1110 return bus_set_transient_bool(u, name, &c->no_new_privileges, message, flags, error);
1111
1112 if (streq(name, "SyslogLevelPrefix"))
1113 return bus_set_transient_bool(u, name, &c->syslog_level_prefix, message, flags, error);
1114
1115 if (streq(name, "MemoryDenyWriteExecute"))
1116 return bus_set_transient_bool(u, name, &c->memory_deny_write_execute, message, flags, error);
1117
1118 if (streq(name, "RestrictRealtime"))
1119 return bus_set_transient_bool(u, name, &c->restrict_realtime, message, flags, error);
1120
1121 if (streq(name, "DynamicUser"))
1122 return bus_set_transient_bool(u, name, &c->dynamic_user, message, flags, error);
1123
1124 if (streq(name, "RemoveIPC"))
1125 return bus_set_transient_bool(u, name, &c->remove_ipc, message, flags, error);
1126
1127 if (streq(name, "ProtectKernelTunables"))
1128 return bus_set_transient_bool(u, name, &c->protect_kernel_tunables, message, flags, error);
1129
1130 if (streq(name, "ProtectKernelModules"))
1131 return bus_set_transient_bool(u, name, &c->protect_kernel_modules, message, flags, error);
1132
1133 if (streq(name, "ProtectControlGroups"))
1134 return bus_set_transient_bool(u, name, &c->protect_control_groups, message, flags, error);
1135
1136 if (streq(name, "MountAPIVFS"))
1137 return bus_set_transient_bool(u, name, &c->mount_apivfs, message, flags, error);
1138
1139 if (streq(name, "CPUSchedulingResetOnFork"))
1140 return bus_set_transient_bool(u, name, &c->cpu_sched_reset_on_fork, message, flags, error);
1141
1142 if (streq(name, "NonBlocking"))
1143 return bus_set_transient_bool(u, name, &c->non_blocking, message, flags, error);
1144
1145 if (streq(name, "LockPersonality"))
1146 return bus_set_transient_bool(u, name, &c->lock_personality, message, flags, error);
1147
1148 if (streq(name, "UtmpIdentifier"))
1149 return bus_set_transient_string(u, name, &c->utmp_id, message, flags, error);
1150
1151 if (streq(name, "UtmpMode"))
1152 return bus_set_transient_utmp_mode(u, name, &c->utmp_mode, message, flags, error);
1153
1154 if (streq(name, "PAMName"))
1155 return bus_set_transient_string(u, name, &c->pam_name, message, flags, error);
1156
1157 if (streq(name, "TimerSlackNSec"))
1158 return bus_set_transient_nsec(u, name, &c->timer_slack_nsec, message, flags, error);
1159
1160 if (streq(name, "ProtectSystem"))
1161 return bus_set_transient_protect_system(u, name, &c->protect_system, message, flags, error);
1162
1163 if (streq(name, "ProtectHome"))
1164 return bus_set_transient_protect_home(u, name, &c->protect_home, message, flags, error);
cffaed83 1165
7e2a3fcc
YW		 1166 if (streq(name, "KeyringMode"))
1167 return bus_set_transient_keyring_mode(u, name, &c->keyring_mode, message, flags, error);
1168
1169 if (streq(name, "RuntimeDirectoryPreserve"))
1170 return bus_set_transient_preserve_mode(u, name, &c->runtime_directory_preserve_mode, message, flags, error);
1171
1172 if (streq(name, "UMask"))
1173 return bus_set_transient_mode_t(u, name, &c->umask, message, flags, error);
1174
1175 if (streq(name, "RuntimeDirectoryMode"))
1176 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_RUNTIME].mode, message, flags, error);
1177
1178 if (streq(name, "StateDirectoryMode"))
1179 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_STATE].mode, message, flags, error);
1180
1181 if (streq(name, "CacheDirectoryMode"))
1182 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_CACHE].mode, message, flags, error);
1183
1184 if (streq(name, "LogsDirectoryMode"))
1185 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_LOGS].mode, message, flags, error);
1186
1187 if (streq(name, "ConfigurationDirectoryMode"))
1188 return bus_set_transient_mode_t(u, name, &c->directories[EXEC_DIRECTORY_CONFIGURATION].mode, message, flags, error);
1189
1190 if (streq(name, "SELinuxContext"))
1191 return bus_set_transient_string(u, name, &c->selinux_context, message, flags, error);
1192
1193 if (streq(name, "SecureBits"))
1194 return bus_set_transient_secure_bits(u, name, &c->secure_bits, message, flags, error);
1195
1196 if (streq(name, "CapabilityBoundingSet"))
1197 return bus_set_transient_capability(u, name, &c->capability_bounding_set, message, flags, error);
1198
1199 if (streq(name, "AmbientCapabilities"))
1200 return bus_set_transient_capability(u, name, &c->capability_ambient_set, message, flags, error);
1201
7e2a3fcc
YW		 1202 if (streq(name, "RestrictNamespaces"))
1203 return bus_set_transient_namespace_flag(u, name, &c->restrict_namespaces, message, flags, error);
1204
1205 if (streq(name, "MountFlags"))
1206 return bus_set_transient_mount_flags(u, name, &c->mount_flags, message, flags, error);
1207
1208 if (streq(name, "SupplementaryGroups")) {
cffaed83
YW		 1209 _cleanup_strv_free_ char **l = NULL;
1210 char **p;
1211
1212 r = sd_bus_message_read_strv(message, &l);
1213 if (r < 0)
1214 return r;
1215
1216 STRV_FOREACH(p, l) {
1217 if (!isempty(*p) && !valid_user_group_name_or_id(*p))
1218 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid supplementary group names");
1219 }
1220
2e59b241 1221 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
7b943bb7 1222 if (strv_isempty(l)) {
cffaed83 1223 c->supplementary_groups = strv_free(c->supplementary_groups);
2e59b241 1224 unit_write_settingf(u, flags, name, "%s=", name);
cffaed83
YW		 1225 } else {
1226 _cleanup_free_ char *joined = NULL;
1227
1228 r = strv_extend_strv(&c->supplementary_groups, l, true);
1229 if (r < 0)
1230 return -ENOMEM;
1231
1232 joined = strv_join(c->supplementary_groups, " ");
1233 if (!joined)
1234 return -ENOMEM;
1235
2e59b241 1236 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", name, joined);
cffaed83
YW		 1237 }
1238 }
1239
1240 return 1;
1241
a8a13575 1242 } else if (streq(name, "SyslogLevel")) {
8d1dd6ab 1243 int32_t level;
a8a13575
EV		 1244
1245 r = sd_bus_message_read(message, "i", &level);
1246 if (r < 0)
1247 return r;
1248
e0d6e0fa
EV		 1249 if (!log_level_is_valid(level))
1250 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log level value out of range");
1251
2e59b241 1252 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
a8a13575 1253 c->syslog_priority = (c->syslog_priority & LOG_FACMASK) | level;
2e59b241 1254 unit_write_settingf(u, flags, name, "SyslogLevel=%i", level);
a8a13575
EV		 1255 }
1256
460ed929 1257 return 1;
7e2a3fcc 1258
460ed929 1259 } else if (streq(name, "SyslogFacility")) {
8d1dd6ab 1260 int32_t facility;
460ed929
EV		 1261
1262 r = sd_bus_message_read(message, "i", &facility);
1263 if (r < 0)
1264 return r;
1265
e0d6e0fa
EV		 1266 if (!log_facility_unshifted_is_valid(facility))
1267 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log facility value out of range");
1268
2e59b241 1269 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
460ed929 1270 c->syslog_priority = (facility << 3) | LOG_PRI(c->syslog_priority);
2e59b241 1271 unit_write_settingf(u, flags, name, "SyslogFacility=%i", facility);
460ed929
EV		 1272 }
1273
cffaed83 1274 return 1;
d3070fbd 1275
d3070fbd
LP		 1276 } else if (streq(name, "LogExtraFields")) {
1277 size_t n = 0;
1278
1279 r = sd_bus_message_enter_container(message, 'a', "ay");
1280 if (r < 0)
1281 return r;
1282
1283 for (;;) {
1284 _cleanup_free_ void *copy = NULL;
1285 struct iovec *t;
1286 const char *eq;
1287 const void *p;
1288 size_t sz;
1289
1290 /* Note that we expect a byte array for each field, instead of a string. That's because on the
1291 * lower-level journal fields can actually contain binary data and are not restricted to text,
1292 * and we should not "lose precision" in our types on the way. That said, I am pretty sure
1293 * actually encoding binary data as unit metadata is not a good idea. Hence we actually refuse
1294 * any actual binary data, and only accept UTF-8. This allows us to eventually lift this
1295 * limitation, should a good, valid usecase arise. */
1296
1297 r = sd_bus_message_read_array(message, 'y', &p, &sz);
1298 if (r < 0)
1299 return r;
1300 if (r == 0)
1301 break;
1302
1303 if (memchr(p, 0, sz))
1304 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field contains zero byte");
1305
1306 eq = memchr(p, '=', sz);
1307 if (!eq)
1308 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field contains no '=' character");
1309 if (!journal_field_valid(p, eq - (const char*) p, false))
1310 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field invalid");
1311
2e59b241 1312 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
aa484f35 1313 t = reallocarray(c->log_extra_fields, c->n_log_extra_fields+1, sizeof(struct iovec));
d3070fbd
LP		 1314 if (!t)
1315 return -ENOMEM;
1316 c->log_extra_fields = t;
1317 }
1318
1319 copy = malloc(sz + 1);
1320 if (!copy)
1321 return -ENOMEM;
1322
1323 memcpy(copy, p, sz);
1324 ((uint8_t*) copy)[sz] = 0;
1325
1326 if (!utf8_is_valid(copy))
1327 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Journal field is not valid UTF-8");
1328
2e59b241 1329 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
d3070fbd 1330 c->log_extra_fields[c->n_log_extra_fields++] = IOVEC_MAKE(copy, sz);
2e59b241 1331 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C, name, "LogExtraFields=%s", (char*) copy);
d3070fbd
LP		 1332
1333 copy = NULL;
1334 }
1335
1336 n++;
1337 }
1338
1339 r = sd_bus_message_exit_container(message);
1340 if (r < 0)
1341 return r;
1342
2e59b241 1343 if (!UNIT_WRITE_FLAGS_NOOP(flags) && n == 0) {
d3070fbd 1344 exec_context_free_log_extra_fields(c);
2e59b241 1345 unit_write_setting(u, flags, name, "LogExtraFields=");
d3070fbd
LP		 1346 }
1347
1348 return 1;
7e2a3fcc 1349 }
cffaed83 1350
349cc4a5 1351#if HAVE_SECCOMP
cffaed83 1352
7e2a3fcc
YW		 1353 if (streq(name, "SystemCallErrorNumber"))
1354 return bus_set_transient_errno(u, name, &c->syscall_errno, message, flags, error);
1355
1356 if (streq(name, "SystemCallFilter")) {
cffaed83 1357 int whitelist;
3f856a28 1358 _cleanup_strv_free_ char **l = NULL;
cffaed83
YW		 1359
1360 r = sd_bus_message_enter_container(message, 'r', "bas");
1361 if (r < 0)
1362 return r;
1363
1364 r = sd_bus_message_read(message, "b", &whitelist);
1365 if (r < 0)
1366 return r;
1367
1368 r = sd_bus_message_read_strv(message, &l);
1369 if (r < 0)
1370 return r;
1371
1372 r = sd_bus_message_exit_container(message);
1373 if (r < 0)
1374 return r;
1375
2e59b241 1376 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
cffaed83 1377 _cleanup_free_ char *joined = NULL;
898748d8
YW		 1378 bool invert = !whitelist;
1379 char **s;
cffaed83 1380
7b943bb7 1381 if (strv_isempty(l)) {
cffaed83 1382 c->syscall_whitelist = false;
8cfa775f 1383 c->syscall_filter = hashmap_free(c->syscall_filter);
cffaed83 1384
898748d8
YW		 1385 unit_write_settingf(u, flags, name, "SystemCallFilter=");
1386 return 1;
1387 }
cffaed83 1388
898748d8
YW		 1389 if (!c->syscall_filter) {
1390 c->syscall_filter = hashmap_new(NULL);
1391 if (!c->syscall_filter)
1392 return log_oom();
cffaed83 1393
898748d8 1394 c->syscall_whitelist = whitelist;
8cfa775f 1395
898748d8 1396 if (c->syscall_whitelist) {
13d92c63 1397 r = seccomp_parse_syscall_filter("@default", -1, c->syscall_filter, SECCOMP_PARSE_WHITELIST | (invert ? SECCOMP_PARSE_INVERT : 0));
8cfa775f
YW		 1398 if (r < 0)
1399 return r;
898748d8
YW		 1400 }
1401 }
8cfa775f 1402
898748d8
YW		 1403 STRV_FOREACH(s, l) {
1404 _cleanup_free_ char *n = NULL;
1405 int e;
cffaed83 1406
898748d8
YW		 1407 r = parse_syscall_and_errno(*s, &n, &e);
1408 if (r < 0)
1409 return r;
cffaed83 1410
13d92c63 1411 r = seccomp_parse_syscall_filter(n, e, c->syscall_filter, (invert ? SECCOMP_PARSE_INVERT : 0) | (c->syscall_whitelist ? SECCOMP_PARSE_WHITELIST : 0));
898748d8
YW		 1412 if (r < 0)
1413 return r;
cffaed83
YW		 1414 }
1415
1416 joined = strv_join(l, " ");
1417 if (!joined)
1418 return -ENOMEM;
1419
2e59b241 1420 unit_write_settingf(u, flags, name, "SystemCallFilter=%s%s", whitelist ? "" : "~", joined);
cffaed83
YW		 1421 }
1422
1423 return 1;
1424
1425 } else if (streq(name, "SystemCallArchitectures")) {
1426 _cleanup_strv_free_ char **l = NULL;
1427
1428 r = sd_bus_message_read_strv(message, &l);
1429 if (r < 0)
1430 return r;
1431
2e59b241 1432 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
cffaed83
YW		 1433 _cleanup_free_ char *joined = NULL;
1434
7b943bb7 1435 if (strv_isempty(l))
cffaed83
YW		 1436 c->syscall_archs = set_free(c->syscall_archs);
1437 else {
1438 char **s;
1439
1440 r = set_ensure_allocated(&c->syscall_archs, NULL);
1441 if (r < 0)
1442 return r;
1443
1444 STRV_FOREACH(s, l) {
1445 uint32_t a;
1446
1447 r = seccomp_arch_from_string(*s, &a);
1448 if (r < 0)
1449 return r;
1450
1451 r = set_put(c->syscall_archs, UINT32_TO_PTR(a + 1));
1452 if (r < 0)
1453 return r;
1454 }
1455
1456 }
1457
1458 joined = strv_join(l, " ");
1459 if (!joined)
1460 return -ENOMEM;
1461
2e59b241 1462 unit_write_settingf(u, flags, name, "%s=%s", name, joined);
cffaed83
YW		 1463 }
1464
1465 return 1;
1466
cffaed83
YW		 1467 } else if (streq(name, "RestrictAddressFamilies")) {
1468 int whitelist;
3f856a28 1469 _cleanup_strv_free_ char **l = NULL;
cffaed83
YW		 1470
1471 r = sd_bus_message_enter_container(message, 'r', "bas");
1472 if (r < 0)
1473 return r;
1474
1475 r = sd_bus_message_read(message, "b", &whitelist);
1476 if (r < 0)
1477 return r;
1478
1479 r = sd_bus_message_read_strv(message, &l);
1480 if (r < 0)
1481 return r;
1482
1483 r = sd_bus_message_exit_container(message);
1484 if (r < 0)
1485 return r;
1486
2e59b241 1487 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
cffaed83 1488 _cleanup_free_ char *joined = NULL;
9ee896d5
YW		 1489 bool invert = !whitelist;
1490 char **s;
cffaed83 1491
7b943bb7 1492 if (strv_isempty(l)) {
cffaed83
YW		 1493 c->address_families_whitelist = false;
1494 c->address_families = set_free(c->address_families);
cffaed83 1495
9ee896d5
YW		 1496 unit_write_settingf(u, flags, name, "RestrictAddressFamilies=");
1497 return 1;
1498 }
cffaed83 1499
9ee896d5
YW		 1500 if (!c->address_families) {
1501 c->address_families = set_new(NULL);
1502 if (!c->address_families)
1503 return log_oom();
cffaed83 1504
9ee896d5
YW		 1505 c->address_families_whitelist = whitelist;
1506 }
1507
1508 STRV_FOREACH(s, l) {
1509 int af;
cffaed83 1510
9ee896d5
YW		 1511 af = af_from_name(*s);
1512 if (af <= 0)
1513 return -EINVAL;
cffaed83 1514
9ee896d5 1515 if (!invert == c->address_families_whitelist) {
cffaed83
YW		 1516 r = set_put(c->address_families, INT_TO_PTR(af));
1517 if (r < 0)
1518 return r;
9ee896d5
YW		 1519 } else
1520 (void) set_remove(c->address_families, INT_TO_PTR(af));
cffaed83
YW		 1521 }
1522
1523 joined = strv_join(l, " ");
1524 if (!joined)
1525 return -ENOMEM;
1526
2e59b241 1527 unit_write_settingf(u, flags, name, "RestrictAddressFamilies=%s%s", whitelist ? "" : "~", joined);
cffaed83
YW		 1528 }
1529
1530 return 1;
7e2a3fcc 1531 }
cffaed83 1532#endif
7e2a3fcc 1533 if (streq(name, "CPUAffinity")) {
cffaed83
YW		 1534 const void *a;
1535 size_t n = 0;
1536
1537 r = sd_bus_message_read_array(message, 'y', &a, &n);
1538 if (r < 0)
1539 return r;
1540
2e59b241 1541 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
cffaed83 1542 if (n == 0) {
501941aa
YW		 1543 c->cpuset = cpu_set_mfree(c->cpuset);
1544 c->cpuset_ncpus = 0;
2e59b241 1545 unit_write_settingf(u, flags, name, "%s=", name);
cffaed83
YW		 1546 } else {
1547 _cleanup_free_ char *str = NULL;
501941aa 1548 size_t allocated = 0, len = 0, i, ncpus;
cffaed83 1549
501941aa 1550 ncpus = CPU_SIZE_TO_NUM(n);
cffaed83 1551
501941aa 1552 for (i = 0; i < ncpus; i++) {
cffaed83
YW		 1553 _cleanup_free_ char *p = NULL;
1554 size_t add;
1555
501941aa
YW		 1556 if (!CPU_ISSET_S(i, n, (cpu_set_t*) a))
1557 continue;
1558
1559 r = asprintf(&p, "%zu", i);
cffaed83
YW		 1560 if (r < 0)
1561 return -ENOMEM;
1562
1563 add = strlen(p);
1564
501941aa 1565 if (!GREEDY_REALLOC(str, allocated, len + add + 2))
cffaed83
YW		 1566 return -ENOMEM;
1567
1568 strcpy(mempcpy(str + len, p, add), " ");
1569 len += add + 1;
1570 }
1571
1572 if (len != 0)
1573 str[len - 1] = '\0';
1574
501941aa
YW		 1575 if (!c->cpuset || c->cpuset_ncpus < ncpus) {
1576 cpu_set_t *cpuset;
1577
1578 cpuset = CPU_ALLOC(ncpus);
1579 if (!cpuset)
1580 return -ENOMEM;
1581
1582 CPU_ZERO_S(n, cpuset);
1583 if (c->cpuset) {
1584 CPU_OR_S(CPU_ALLOC_SIZE(c->cpuset_ncpus), cpuset, c->cpuset, (cpu_set_t*) a);
1585 CPU_FREE(c->cpuset);
1586 } else
1587 CPU_OR_S(n, cpuset, cpuset, (cpu_set_t*) a);
1588
1589 c->cpuset = cpuset;
1590 c->cpuset_ncpus = ncpus;
1591 } else
1592 CPU_OR_S(n, c->cpuset, c->cpuset, (cpu_set_t*) a);
1593
2e59b241 1594 unit_write_settingf(u, flags, name, "%s=%s", name, str);
cffaed83
YW		 1595 }
1596 }
1597
c7040b5d
LP		 1598 return 1;
1599
c250bf67
YW		 1600 } else if (streq(name, "Nice")) {
1601 int32_t q;
1602
1603 r = sd_bus_message_read(message, "i", &q);
1604 if (r < 0)
1605 return r;
1606
1607 if (!nice_is_valid(q))
1608 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid Nice value: %i", q);
1609
1610 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1611 c->nice = q;
1612 c->nice_set = true;
1613
1614 unit_write_settingf(u, flags, name, "Nice=%i", q);
1615 }
1616
1617 return 1;
1618
1619 } else if (streq(name, "CPUSchedulingPolicy")) {
1620 int32_t q;
1621
1622 r = sd_bus_message_read(message, "i", &q);
1623 if (r < 0)
1624 return r;
1625
1626 if (!sched_policy_is_valid(q))
1627 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid CPU scheduling policy: %i", q);
1628
1629 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1630 _cleanup_free_ char *s = NULL;
1631
1632 r = sched_policy_to_string_alloc(q, &s);
1633 if (r < 0)
1634 return r;
1635
1636 c->cpu_sched_policy = q;
1637 c->cpu_sched_priority = CLAMP(c->cpu_sched_priority, sched_get_priority_min(q), sched_get_priority_max(q));
1638 c->cpu_sched_set = true;
1639
1640 unit_write_settingf(u, flags, name, "CPUSchedulingPolicy=%s", s);
1641 }
1642
1643 return 1;
1644
1645 } else if (streq(name, "CPUSchedulingPriority")) {
1646 int32_t p, min, max;
1647
1648 r = sd_bus_message_read(message, "i", &p);
1649 if (r < 0)
1650 return r;
1651
1652 min = sched_get_priority_min(c->cpu_sched_policy);
1653 max = sched_get_priority_max(c->cpu_sched_policy);
1654 if (p < min || p > max)
1655 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid CPU scheduling priority: %i", p);
1656
1657 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
1658 c->cpu_sched_priority = p;
1659 c->cpu_sched_set = true;
1660
1661 unit_write_settingf(u, flags, name, "CPUSchedulingPriority=%i", p);
1662 }
1663
1664 return 1;
1665
7f452159
LP		 1666 } else if (streq(name, "IOSchedulingClass")) {
1667 int32_t q;
1668
1669 r = sd_bus_message_read(message, "i", &q);
1670 if (r < 0)
1671 return r;
1672
1673 if (!ioprio_class_is_valid(q))
1674 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid IO scheduling class: %i", q);
1675
2e59b241 1676 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
7f452159
LP		 1677 _cleanup_free_ char *s = NULL;
1678
1679 r = ioprio_class_to_string_alloc(q, &s);
1680 if (r < 0)
1681 return r;
1682
1683 c->ioprio = IOPRIO_PRIO_VALUE(q, IOPRIO_PRIO_DATA(c->ioprio));
1684 c->ioprio_set = true;
1685
2e59b241 1686 unit_write_settingf(u, flags, name, "IOSchedulingClass=%s", s);
7f452159
LP		 1687 }
1688
1689 return 1;
1690
1691 } else if (streq(name, "IOSchedulingPriority")) {
1692 int32_t p;
1693
1694 r = sd_bus_message_read(message, "i", &p);
1695 if (r < 0)
1696 return r;
1697
1698 if (!ioprio_priority_is_valid(p))
1699 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid IO scheduling priority: %i", p);
1700
2e59b241 1701 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
7f452159
LP		 1702 c->ioprio = IOPRIO_PRIO_VALUE(IOPRIO_PRIO_CLASS(c->ioprio), p);
1703 c->ioprio_set = true;
1704
2e59b241 1705 unit_write_settingf(u, flags, name, "IOSchedulingPriority=%i", p);
7f452159
LP		 1706 }
1707
1708 return 1;
1709
5f5d8eab
LP		 1710 } else if (streq(name, "WorkingDirectory")) {
1711 const char *s;
1712 bool missing_ok;
1713
1714 r = sd_bus_message_read(message, "s", &s);
1715 if (r < 0)
1716 return r;
1717
1718 if (s[0] == '-') {
1719 missing_ok = true;
1720 s++;
1721 } else
1722 missing_ok = false;
1723
d6ff82d3 1724 if (!isempty(s) && !streq(s, "~") && !path_is_absolute(s))
5f5d8eab
LP		 1725 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "WorkingDirectory= expects an absolute path or '~'");
1726
2e59b241 1727 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
5f5d8eab
LP		 1728 if (streq(s, "~")) {
1729 c->working_directory = mfree(c->working_directory);
1730 c->working_directory_home = true;
1731 } else {
d6ff82d3 1732 r = free_and_strdup(&c->working_directory, empty_to_null(s));
5f5d8eab
LP		 1733 if (r < 0)
1734 return r;
1735
1736 c->working_directory_home = false;
1737 }
1738
1739 c->working_directory_missing_ok = missing_ok;
2e59b241 1740 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "WorkingDirectory=%s%s", missing_ok ? "-" : "", s);
5f5d8eab
LP		 1741 }
1742
1743 return 1;
1744
52c239d7
LB		 1745 } else if (STR_IN_SET(name,
1746 "StandardInputFileDescriptorName", "StandardOutputFileDescriptorName", "StandardErrorFileDescriptorName")) {
1747 const char *s;
1748
1749 r = sd_bus_message_read(message, "s", &s);
1750 if (r < 0)
1751 return r;
1752
d6ff82d3 1753 if (!isempty(s) && !fdname_is_valid(s))
52c239d7
LB		 1754 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid file descriptor name");
1755
2e59b241 1756 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
5073ff6b 1757
52c239d7 1758 if (streq(name, "StandardInputFileDescriptorName")) {
d6ff82d3 1759 r = free_and_strdup(c->stdio_fdname + STDIN_FILENO, empty_to_null(s));
52c239d7
LB		 1760 if (r < 0)
1761 return r;
5073ff6b 1762
0664775c 1763 c->std_input = EXEC_INPUT_NAMED_FD;
2e59b241 1764 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardInput=fd:%s", exec_context_fdname(c, STDIN_FILENO));
5073ff6b 1765
52c239d7 1766 } else if (streq(name, "StandardOutputFileDescriptorName")) {
d6ff82d3 1767 r = free_and_strdup(c->stdio_fdname + STDOUT_FILENO, empty_to_null(s));
52c239d7
LB		 1768 if (r < 0)
1769 return r;
5073ff6b 1770
52c239d7 1771 c->std_output = EXEC_OUTPUT_NAMED_FD;
2e59b241 1772 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=fd:%s", exec_context_fdname(c, STDOUT_FILENO));
0664775c
LP		 1773
1774 } else {
1775 assert(streq(name, "StandardErrorFileDescriptorName"));
5073ff6b 1776
d6ff82d3 1777 r = free_and_strdup(&c->stdio_fdname[STDERR_FILENO], empty_to_null(s));
52c239d7
LB		 1778 if (r < 0)
1779 return r;
5073ff6b 1780
52c239d7 1781 c->std_error = EXEC_OUTPUT_NAMED_FD;
2e59b241 1782 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardError=fd:%s", exec_context_fdname(c, STDERR_FILENO));
52c239d7
LB		 1783 }
1784 }
1785
1786 return 1;
1787
566b7d23
ZD		 1788 } else if (STR_IN_SET(name,
1789 "StandardInputFile",
1790 "StandardOutputFile", "StandardOutputFileToCreate", "StandardOutputFileToAppend",
1791 "StandardErrorFile", "StandardErrorFileToCreate", "StandardErrorFileToAppend")) {
2038c3f5
LP		 1792 const char *s;
1793
1794 r = sd_bus_message_read(message, "s", &s);
1795 if (r < 0)
1796 return r;
1797
d6ff82d3
YW		 1798 if (!isempty(s)) {
1799 if (!path_is_absolute(s))
1800 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute", s);
1801 if (!path_is_normalized(s))
1802 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not normalized", s);
1803 }
2038c3f5 1804
2e59b241 1805 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2038c3f5
LP		 1806
1807 if (streq(name, "StandardInputFile")) {
d6ff82d3 1808 r = free_and_strdup(&c->stdio_file[STDIN_FILENO], empty_to_null(s));
52c239d7
LB		 1809 if (r < 0)
1810 return r;
2038c3f5
LP		 1811
1812 c->std_input = EXEC_INPUT_FILE;
2e59b241 1813 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardInput=file:%s", s);
2038c3f5 1814
566b7d23 1815 } else if (STR_IN_SET(name, "StandardOutputFile", "StandardOutputFileToAppend")) {
d6ff82d3 1816 r = free_and_strdup(&c->stdio_file[STDOUT_FILENO], empty_to_null(s));
2038c3f5
LP		 1817 if (r < 0)
1818 return r;
1819
566b7d23
ZD		 1820 if (streq(name, "StandardOutputFile")) {
1821 c->std_output = EXEC_OUTPUT_FILE;
1822 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=file:%s", s);
1823 } else {
1824 assert(streq(name, "StandardOutputFileToAppend"));
1825 c->std_output = EXEC_OUTPUT_FILE_APPEND;
1826 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=append:%s", s);
1827 }
2038c3f5 1828 } else {
566b7d23 1829 assert(STR_IN_SET(name, "StandardErrorFile", "StandardErrorFileToAppend"));
2038c3f5 1830
d6ff82d3 1831 r = free_and_strdup(&c->stdio_file[STDERR_FILENO], empty_to_null(s));
2038c3f5
LP		 1832 if (r < 0)
1833 return r;
1834
566b7d23
ZD		 1835 if (streq(name, "StandardErrorFile")) {
1836 c->std_error = EXEC_OUTPUT_FILE;
1837 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=file:%s", s);
1838 } else {
1839 assert(streq(name, "StandardErrorFileToAppend"));
1840 c->std_error = EXEC_OUTPUT_FILE_APPEND;
1841 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "StandardOutput=append:%s", s);
1842 }
2038c3f5
LP		 1843 }
1844 }
1845
1846 return 1;
1847
08f3be7a
LP		 1848 } else if (streq(name, "StandardInputData")) {
1849 const void *p;
1850 size_t sz;
1851
1852 r = sd_bus_message_read_array(message, 'y', &p, &sz);
1853 if (r < 0)
1854 return r;
1855
2e59b241 1856 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
08f3be7a
LP		 1857 _cleanup_free_ char *encoded = NULL;
1858
1859 if (sz == 0) {
1860 c->stdin_data = mfree(c->stdin_data);
1861 c->stdin_data_size = 0;
1862
2e59b241 1863 unit_write_settingf(u, flags, name, "StandardInputData=");
08f3be7a
LP		 1864 } else {
1865 void *q;
1866 ssize_t n;
1867
1868 if (c->stdin_data_size + sz < c->stdin_data_size || /* check for overflow */
1869 c->stdin_data_size + sz > EXEC_STDIN_DATA_MAX)
1870 return -E2BIG;
1871
1872 n = base64mem(p, sz, &encoded);
1873 if (n < 0)
1874 return (int) n;
1875
1876 q = realloc(c->stdin_data, c->stdin_data_size + sz);
1877 if (!q)
1878 return -ENOMEM;
1879
1880 memcpy((uint8_t*) q + c->stdin_data_size, p, sz);
1881
1882 c->stdin_data = q;
1883 c->stdin_data_size += sz;
1884
2e59b241 1885 unit_write_settingf(u, flags, name, "StandardInputData=%s", encoded);
52c239d7
LB		 1886 }
1887 }
1888
1889 return 1;
1890
c7040b5d
LP		 1891 } else if (streq(name, "Environment")) {
1892
6171b822 1893 _cleanup_strv_free_ char **l = NULL;
c7040b5d
LP		 1894
1895 r = sd_bus_message_read_strv(message, &l);
1896 if (r < 0)
1897 return r;
1898
6171b822 1899 if (!strv_env_is_valid(l))
1c68232e
LP		 1900 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment block.");
1901
2e59b241 1902 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
7b943bb7 1903 if (strv_isempty(l)) {
e9876fc9 1904 c->environment = strv_free(c->environment);
2e59b241 1905 unit_write_setting(u, flags, name, "Environment=");
e9876fc9 1906 } else {
f900f582
ZJS		 1907 _cleanup_free_ char *joined = NULL;
1908 char **e;
1909
2e59b241
LP		 1910 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C);
1911 if (!joined)
1912 return -ENOMEM;
1913
6171b822 1914 e = strv_env_merge(2, c->environment, l);
e9876fc9
EV		 1915 if (!e)
1916 return -ENOMEM;
c7040b5d 1917
130d3d22 1918 strv_free_and_replace(c->environment, e);
2e59b241 1919 unit_write_settingf(u, flags, name, "Environment=%s", joined);
e9876fc9 1920 }
c7040b5d
LP		 1921 }
1922
d584f638
LP		 1923 return 1;
1924
00819cc1
LP		 1925 } else if (streq(name, "UnsetEnvironment")) {
1926
6171b822 1927 _cleanup_strv_free_ char **l = NULL;
00819cc1
LP		 1928
1929 r = sd_bus_message_read_strv(message, &l);
1930 if (r < 0)
1931 return r;
1932
6171b822 1933 if (!strv_env_name_or_assignment_is_valid(l))
00819cc1
LP		 1934 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid UnsetEnvironment= list.");
1935
2e59b241 1936 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
7b943bb7 1937 if (strv_isempty(l)) {
00819cc1 1938 c->unset_environment = strv_free(c->unset_environment);
2e59b241 1939 unit_write_setting(u, flags, name, "UnsetEnvironment=");
00819cc1
LP		 1940 } else {
1941 _cleanup_free_ char *joined = NULL;
1942 char **e;
1943
2e59b241
LP		 1944 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS|UNIT_ESCAPE_C);
1945 if (!joined)
1946 return -ENOMEM;
1947
6171b822 1948 e = strv_env_merge(2, c->unset_environment, l);
00819cc1
LP		 1949 if (!e)
1950 return -ENOMEM;
1951
130d3d22 1952 strv_free_and_replace(c->unset_environment, e);
2e59b241 1953 unit_write_settingf(u, flags, name, "UnsetEnvironment=%s", joined);
00819cc1
LP		 1954 }
1955 }
1956
1957 return 1;
1958
6b862936
EV		 1959 } else if (streq(name, "OOMScoreAdjust")) {
1960 int oa;
1961
1962 r = sd_bus_message_read(message, "i", &oa);
1963 if (r < 0)
1964 return r;
1965
1966 if (!oom_score_adjust_is_valid(oa))
1967 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "OOM score adjust value out of range");
1968
2e59b241 1969 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
6b862936
EV		 1970 c->oom_score_adjust = oa;
1971 c->oom_score_adjust_set = true;
2e59b241 1972 unit_write_settingf(u, flags, name, "OOMScoreAdjust=%i", oa);
6b862936
EV		 1973 }
1974
1975 return 1;
1976
ceb728cf
NC		 1977 } else if (streq(name, "EnvironmentFiles")) {
1978
1979 _cleanup_free_ char *joined = NULL;
1980 _cleanup_fclose_ FILE *f = NULL;
9b531f04 1981 _cleanup_strv_free_ char **l = NULL;
ceb728cf 1982 size_t size = 0;
2229f656 1983 char **i;
ceb728cf
NC		 1984
1985 r = sd_bus_message_enter_container(message, 'a', "(sb)");
1986 if (r < 0)
1987 return r;
1988
1989 f = open_memstream(&joined, &size);
1990 if (!f)
1991 return -ENOMEM;
1992
0d536673
LP		 1993 (void) __fsetlocking(f, FSETLOCKING_BYCALLER);
1994
2e59b241
LP		 1995 fputs("EnvironmentFile=\n", f);
1996
1997 STRV_FOREACH(i, c->environment_files) {
1998 _cleanup_free_ char *q = NULL;
1999
2000 q = specifier_escape(*i);
2001 if (!q)
2002 return -ENOMEM;
2003
2004 fprintf(f, "EnvironmentFile=%s\n", q);
2005 }
ceb728cf
NC		 2006
2007 while ((r = sd_bus_message_enter_container(message, 'r', "sb")) > 0) {
2008 const char *path;
2009 int b;
2010
ceb728cf
NC		 2011 r = sd_bus_message_read(message, "sb", &path, &b);
2012 if (r < 0)
2013 return r;
2014
2015 r = sd_bus_message_exit_container(message);
2016 if (r < 0)
2017 return r;
2018
d2d6c096
LP		 2019 if (!path_is_absolute(path))
2020 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not absolute.", path);
ceb728cf 2021
2e59b241
LP		 2022 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2023 _cleanup_free_ char *q = NULL;
ae978b9f 2024 char *buf;
ceb728cf 2025
605405c6 2026 buf = strjoin(b ? "-" : "", path);
2229f656 2027 if (!buf)
ceb728cf
NC		 2028 return -ENOMEM;
2029
2e59b241
LP		 2030 q = specifier_escape(buf);
2031 if (!q) {
2032 free(buf);
2033 return -ENOMEM;
2034 }
2035
2036 fprintf(f, "EnvironmentFile=%s\n", q);
ceb728cf 2037
2229f656 2038 r = strv_consume(&l, buf);
ceb728cf
NC		 2039 if (r < 0)
2040 return r;
2041 }
2042 }
2043 if (r < 0)
2044 return r;
2045
b0830e21
LP		 2046 r = sd_bus_message_exit_container(message);
2047 if (r < 0)
2048 return r;
2049
2229f656
LP		 2050 r = fflush_and_check(f);
2051 if (r < 0)
2052 return r;
ceb728cf 2053
2e59b241 2054 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2229f656
LP		 2055 if (strv_isempty(l)) {
2056 c->environment_files = strv_free(c->environment_files);
2e59b241 2057 unit_write_setting(u, flags, name, "EnvironmentFile=");
2229f656
LP		 2058 } else {
2059 r = strv_extend_strv(&c->environment_files, l, true);
2060 if (r < 0)
2061 return r;
2062
2e59b241 2063 unit_write_setting(u, flags, name, joined);
2229f656
LP		 2064 }
2065 }
ceb728cf 2066
ceb728cf
NC		 2067 return 1;
2068
b4c14404
FB		 2069 } else if (streq(name, "PassEnvironment")) {
2070
6171b822 2071 _cleanup_strv_free_ char **l = NULL;
b4c14404
FB		 2072
2073 r = sd_bus_message_read_strv(message, &l);
2074 if (r < 0)
2075 return r;
2076
6171b822 2077 if (!strv_env_name_is_valid(l))
00819cc1 2078 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PassEnvironment= block.");
b4c14404 2079
2e59b241 2080 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
b4c14404
FB		 2081 if (strv_isempty(l)) {
2082 c->pass_environment = strv_free(c->pass_environment);
2e59b241 2083 unit_write_setting(u, flags, name, "PassEnvironment=");
b4c14404
FB		 2084 } else {
2085 _cleanup_free_ char *joined = NULL;
2086
9d4f242a
YW		 2087 r = strv_extend_strv(&c->pass_environment, l, true);
2088 if (r < 0)
2089 return r;
2090
41de9cc2 2091 /* We write just the new settings out to file, with unresolved specifiers. */
2e59b241 2092 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS);
b4c14404
FB		 2093 if (!joined)
2094 return -ENOMEM;
2095
2e59b241 2096 unit_write_settingf(u, flags, name, "PassEnvironment=%s", joined);
b4c14404
FB		 2097 }
2098 }
2099
2100 return 1;
2101
2a624c36
AP		 2102 } else if (STR_IN_SET(name, "ReadWriteDirectories", "ReadOnlyDirectories", "InaccessibleDirectories",
2103 "ReadWritePaths", "ReadOnlyPaths", "InaccessiblePaths")) {
08596068
EV		 2104 _cleanup_strv_free_ char **l = NULL;
2105 char ***dirs;
2106 char **p;
2107
2108 r = sd_bus_message_read_strv(message, &l);
2109 if (r < 0)
2110 return r;
2111
2112 STRV_FOREACH(p, l) {
e7bcff4e 2113 char *i = *p;
20b7a007
LP		 2114 size_t offset;
2115
20b7a007
LP		 2116 offset = i[0] == '-';
2117 offset += i[offset] == '+';
2118 if (!path_is_absolute(i + offset))
08596068 2119 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s", name);
e7bcff4e 2120
858d36c1 2121 path_simplify(i + offset, false);
08596068
EV		 2122 }
2123
2e59b241 2124 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
c4b41707
AP		 2125 if (STR_IN_SET(name, "ReadWriteDirectories", "ReadWritePaths"))
2126 dirs = &c->read_write_paths;
2127 else if (STR_IN_SET(name, "ReadOnlyDirectories", "ReadOnlyPaths"))
2128 dirs = &c->read_only_paths;
2129 else /* "InaccessiblePaths" */
2130 dirs = &c->inaccessible_paths;
08596068 2131
7b943bb7 2132 if (strv_isempty(l)) {
08596068 2133 *dirs = strv_free(*dirs);
2e59b241 2134 unit_write_settingf(u, flags, name, "%s=", name);
08596068 2135 } else {
2e59b241 2136 _cleanup_free_ char *joined = NULL;
08596068 2137
2e59b241 2138 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS);
08596068
EV		 2139 if (!joined)
2140 return -ENOMEM;
2141
2e59b241
LP		 2142 r = strv_extend_strv(dirs, l, true);
2143 if (r < 0)
2144 return -ENOMEM;
08596068 2145
2e59b241
LP		 2146 unit_write_settingf(u, flags, name, "%s=%s", name, joined);
2147 }
08596068
EV		 2148 }
2149
2150 return 1;
2151
3536f49e 2152 } else if (STR_IN_SET(name, "RuntimeDirectory", "StateDirectory", "CacheDirectory", "LogsDirectory", "ConfigurationDirectory")) {
fa21b5e3
EV		 2153 _cleanup_strv_free_ char **l = NULL;
2154 char **p;
2155
2156 r = sd_bus_message_read_strv(message, &l);
2157 if (r < 0)
2158 return r;
2159
2160 STRV_FOREACH(p, l) {
8994a117
YW		 2161 if (!path_is_normalized(*p))
2162 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s= path is not normalized: %s", name, *p);
2163
2164 if (path_is_absolute(*p))
2165 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s= path is absolute: %s", name, *p);
2166
2167 if (path_startswith(*p, "private"))
2168 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s= path can't be 'private': %s", name, *p);
fa21b5e3
EV		 2169 }
2170
2e59b241 2171 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
3536f49e
YW		 2172 char ***dirs = NULL;
2173 ExecDirectoryType i;
2174
72fd1768 2175 for (i = 0; i < _EXEC_DIRECTORY_TYPE_MAX; i++)
3536f49e
YW		 2176 if (streq(name, exec_directory_type_to_string(i))) {
2177 dirs = &c->directories[i].paths;
2178 break;
2179 }
2180
2181 assert(dirs);
fa21b5e3
EV		 2182
2183 if (strv_isempty(l)) {
3536f49e 2184 *dirs = strv_free(*dirs);
2e59b241 2185 unit_write_settingf(u, flags, name, "%s=", name);
fa21b5e3 2186 } else {
2e59b241
LP		 2187 _cleanup_free_ char *joined = NULL;
2188
3536f49e 2189 r = strv_extend_strv(dirs, l, true);
fa21b5e3
EV		 2190 if (r < 0)
2191 return -ENOMEM;
2192
2e59b241 2193 joined = unit_concat_strv(l, UNIT_ESCAPE_SPECIFIERS);
fa21b5e3
EV		 2194 if (!joined)
2195 return -ENOMEM;
2196
2e59b241 2197 unit_write_settingf(u, flags, name, "%s=%s", name, joined);
fa21b5e3
EV		 2198 }
2199 }
2200
2201 return 1;
2202
cffaed83
YW		 2203 } else if (STR_IN_SET(name, "AppArmorProfile", "SmackProcessLabel")) {
2204 int ignore;
2205 const char *s;
2206
280921f2 2207 r = sd_bus_message_read(message, "(bs)", &ignore, &s);
cffaed83
YW		 2208 if (r < 0)
2209 return r;
2210
2e59b241 2211 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
cffaed83
YW		 2212 char **p;
2213 bool *b;
2214
2215 if (streq(name, "AppArmorProfile")) {
2216 p = &c->apparmor_profile;
2217 b = &c->apparmor_profile_ignore;
2218 } else { /* "SmackProcessLabel" */
2219 p = &c->smack_process_label;
2220 b = &c->smack_process_label_ignore;
2221 }
2222
2223 if (isempty(s)) {
2224 *p = mfree(*p);
2225 *b = false;
2226 } else {
2227 if (free_and_strdup(p, s) < 0)
2228 return -ENOMEM;
2229 *b = ignore;
2230 }
2231
2e59b241 2232 unit_write_settingf(u, flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s%s", name, ignore ? "-" : "", strempty(s));
cffaed83
YW		 2233 }
2234
2235 return 1;
2236
d2d6c096 2237 } else if (STR_IN_SET(name, "BindPaths", "BindReadOnlyPaths")) {
4ff4c98a
YW		 2238 const char *source, *destination;
2239 int ignore_enoent;
2240 uint64_t mount_flags;
2241 bool empty = true;
d2d6c096
LP		 2242
2243 r = sd_bus_message_enter_container(message, 'a', "(ssbt)");
2244 if (r < 0)
2245 return r;
2246
4ff4c98a 2247 while ((r = sd_bus_message_read(message, "(ssbt)", &source, &destination, &ignore_enoent, &mount_flags)) > 0) {
d2d6c096
LP		 2248
2249 if (!path_is_absolute(source))
2250 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path %s is not absolute.", source);
2251 if (!path_is_absolute(destination))
91d910e3 2252 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Destination path %s is not absolute.", destination);
d2d6c096
LP		 2253 if (!IN_SET(mount_flags, 0, MS_REC))
2254 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unknown mount flags.");
2255
2e59b241 2256 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
d2d6c096
LP		 2257 r = bind_mount_add(&c->bind_mounts, &c->n_bind_mounts,
2258 &(BindMount) {
2259 .source = strdup(source),
2260 .destination = strdup(destination),
2261 .read_only = !!strstr(name, "ReadOnly"),
2262 .recursive = !!(mount_flags & MS_REC),
2263 .ignore_enoent = ignore_enoent,
2264 });
2265 if (r < 0)
2266 return r;
2267
2e59b241
LP		 2268 unit_write_settingf(
2269 u, flags|UNIT_ESCAPE_SPECIFIERS, name,
d2d6c096
LP		 2270 "%s=%s%s:%s:%s",
2271 name,
2272 ignore_enoent ? "-" : "",
2273 source,
2274 destination,
2275 (mount_flags & MS_REC) ? "rbind" : "norbind");
2276 }
2277
2278 empty = false;
2279 }
2280 if (r < 0)
2281 return r;
2282
2283 r = sd_bus_message_exit_container(message);
2284 if (r < 0)
2285 return r;
2286
2287 if (empty) {
2288 bind_mount_free_many(c->bind_mounts, c->n_bind_mounts);
2289 c->bind_mounts = NULL;
2290 c->n_bind_mounts = 0;
2e59b241
LP		 2291
2292 unit_write_settingf(u, flags, name, "%s=", name);
d2d6c096
LP		 2293 }
2294
784ad252
YW		 2295 return 1;
2296
2297 } else if (streq(name, "TemporaryFileSystem")) {
2298 const char *path, *options;
2299 bool empty = true;
2300
2301 r = sd_bus_message_enter_container(message, 'a', "(ss)");
2302 if (r < 0)
2303 return r;
2304
2305 while ((r = sd_bus_message_read(message, "(ss)", &path, &options)) > 0) {
2306
2307 if (!path_is_absolute(path))
2308 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Mount point %s is not absolute.", path);
2309
2310 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2311 r = temporary_filesystem_add(&c->temporary_filesystems, &c->n_temporary_filesystems, path, options);
2312 if (r < 0)
2313 return r;
2314
2315 unit_write_settingf(
2316 u, flags|UNIT_ESCAPE_SPECIFIERS, name,
2317 "%s=%s:%s",
2318 name,
2319 path,
2320 options);
2321 }
2322
2323 empty = false;
2324 }
2325 if (r < 0)
2326 return r;
2327
2328 r = sd_bus_message_exit_container(message);
2329 if (r < 0)
2330 return r;
2331
2332 if (empty) {
2333 temporary_filesystem_free_many(c->temporary_filesystems, c->n_temporary_filesystems);
2334 c->temporary_filesystems = NULL;
2335 c->n_temporary_filesystems = 0;
2336
2337 unit_write_settingf(u, flags, name, "%s=", name);
2338 }
2339
83555251 2340 return 1;
d2d6c096 2341
6550c24c
LP		 2342 } else if ((suffix = startswith(name, "Limit"))) {
2343 const char *soft = NULL;
2344 int ri;
cab2aca3 2345
6550c24c
LP		 2346 ri = rlimit_from_string(suffix);
2347 if (ri < 0) {
2348 soft = endswith(suffix, "Soft");
2349 if (soft) {
2350 const char *n;
cab2aca3 2351
6550c24c
LP		 2352 n = strndupa(suffix, soft - suffix);
2353 ri = rlimit_from_string(n);
2354 if (ri >= 0)
2355 name = strjoina("Limit", n);
2356 }
cab2aca3 2357 }
d584f638 2358
6550c24c
LP		 2359 if (ri >= 0) {
2360 uint64_t rl;
2361 rlim_t x;
d584f638 2362
6550c24c 2363 r = sd_bus_message_read(message, "t", &rl);
cab2aca3
LP		 2364 if (r < 0)
2365 return r;
d584f638 2366
6550c24c
LP		 2367 if (rl == (uint64_t) -1)
2368 x = RLIM_INFINITY;
cab2aca3 2369 else {
6550c24c
LP		 2370 x = (rlim_t) rl;
2371
2372 if ((uint64_t) x != rl)
2373 return -ERANGE;
d584f638
LP		 2374 }
2375
6550c24c
LP		 2376 if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
2377 _cleanup_free_ char *f = NULL;
2378 struct rlimit nl;
2379
2380 if (c->rlimit[ri]) {
2381 nl = *c->rlimit[ri];
2382
2383 if (soft)
2384 nl.rlim_cur = x;
2385 else
2386 nl.rlim_max = x;
2387 } else
2388 /* When the resource limit is not initialized yet, then assign the value to both fields */
2389 nl = (struct rlimit) {
2390 .rlim_cur = x,
2391 .rlim_max = x,
2392 };
2393
2394 r = rlimit_format(&nl, &f);
2395 if (r < 0)
2396 return r;
2397
2398 if (c->rlimit[ri])
2399 *c->rlimit[ri] = nl;
2400 else {
2401 c->rlimit[ri] = newdup(struct rlimit, &nl, 1);
2402 if (!c->rlimit[ri])
2403 return -ENOMEM;
2404 }
2405
2406 unit_write_settingf(u, flags, name, "%s=%s", name, f);
2407 }
2408
2409 return 1;
d584f638
LP		 2410 }
2411
c7040b5d
LP		 2412 }
2413
2414 return 0;
2415}
Unnamed repository; edit this file 'description' to name the repository.