]> git.proxmox.com Git - systemd.git/blame - src/core/dbus-execute.c
projects / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Upstream version 228
[systemd.git] / src / core / dbus-execute.c
CommitLineData
663996b3
MS		 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
663996b3
MS		 22#include <sys/prctl.h>
23
60f067b4
JS		 24#ifdef HAVE_SECCOMP
25#include <seccomp.h>
26#endif
27
db2df898
MP		 28#include "af-list.h"
29#include "alloc-util.h"
60f067b4 30#include "bus-util.h"
db2df898
MP		 31#include "capability-util.h"
32#include "dbus-execute.h"
60f067b4 33#include "env-util.h"
db2df898
MP		 34#include "execute.h"
35#include "fd-util.h"
36#include "fileio.h"
37#include "ioprio.h"
38#include "missing.h"
60f067b4 39#include "namespace.h"
db2df898 40#include "parse-util.h"
e735f4d4 41#include "path-util.h"
db2df898
MP		 42#include "process-util.h"
43#include "rlimit-util.h"
60f067b4
JS		 44#ifdef HAVE_SECCOMP
45#include "seccomp-util.h"
46#endif
db2df898
MP		 47#include "strv.h"
48#include "syslog-util.h"
49#include "utf8.h"
663996b3 50
60f067b4 51BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_exec_output, exec_output, ExecOutput);
663996b3 52
60f067b4 53static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_input, exec_input, ExecInput);
663996b3 54
13d276d0
MP		 55static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_exec_utmp_mode, exec_utmp_mode, ExecUtmpMode);
56
60f067b4
JS		 57static BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_protect_home, protect_home, ProtectHome);
58static BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_protect_system, protect_system, ProtectSystem);
663996b3 59
60f067b4
JS		 60static int property_get_environment_files(
61 sd_bus *bus,
62 const char *path,
63 const char *interface,
64 const char *property,
65 sd_bus_message *reply,
66 void *userdata,
67 sd_bus_error *error) {
663996b3 68
60f067b4
JS		 69 ExecContext *c = userdata;
70 char **j;
71 int r;
663996b3 72
60f067b4
JS		 73 assert(bus);
74 assert(reply);
75 assert(c);
76
77 r = sd_bus_message_open_container(reply, 'a', "(sb)");
78 if (r < 0)
79 return r;
80
81 STRV_FOREACH(j, c->environment_files) {
82 const char *fn = *j;
83
84 r = sd_bus_message_append(reply, "(sb)", fn[0] == '-' ? fn + 1 : fn, fn[0] == '-');
85 if (r < 0)
86 return r;
663996b3
MS		 87 }
88
60f067b4
JS		 89 return sd_bus_message_close_container(reply);
90}
663996b3 91
60f067b4
JS		 92static int property_get_oom_score_adjust(
93 sd_bus *bus,
94 const char *path,
95 const char *interface,
96 const char *property,
97 sd_bus_message *reply,
98 void *userdata,
99 sd_bus_error *error) {
100
101
102 ExecContext *c = userdata;
663996b3
MS		 103 int32_t n;
104
60f067b4
JS		 105 assert(bus);
106 assert(reply);
663996b3
MS		 107 assert(c);
108
109 if (c->oom_score_adjust_set)
110 n = c->oom_score_adjust;
111 else {
14228c0d 112 _cleanup_free_ char *t = NULL;
663996b3
MS		 113
114 n = 0;
60f067b4 115 if (read_one_line_file("/proc/self/oom_score_adj", &t) >= 0)
db2df898 116 safe_atoi32(t, &n);
663996b3
MS		 117 }
118
60f067b4 119 return sd_bus_message_append(reply, "i", n);
663996b3
MS		 120}
121
60f067b4
JS		 122static int property_get_nice(
123 sd_bus *bus,
124 const char *path,
125 const char *interface,
126 const char *property,
127 sd_bus_message *reply,
128 void *userdata,
129 sd_bus_error *error) {
130
131
132 ExecContext *c = userdata;
663996b3
MS		 133 int32_t n;
134
60f067b4
JS		 135 assert(bus);
136 assert(reply);
663996b3
MS		 137 assert(c);
138
139 if (c->nice_set)
140 n = c->nice;
60f067b4
JS		 141 else {
142 errno = 0;
663996b3 143 n = getpriority(PRIO_PROCESS, 0);
60f067b4
JS		 144 if (errno != 0)
145 n = 0;
146 }
663996b3 147
60f067b4 148 return sd_bus_message_append(reply, "i", n);
663996b3
MS		 149}
150
60f067b4
JS		 151static int property_get_ioprio(
152 sd_bus *bus,
153 const char *path,
154 const char *interface,
155 const char *property,
156 sd_bus_message *reply,
157 void *userdata,
158 sd_bus_error *error) {
159
160
161 ExecContext *c = userdata;
663996b3
MS		 162 int32_t n;
163
60f067b4
JS		 164 assert(bus);
165 assert(reply);
663996b3
MS		 166 assert(c);
167
168 if (c->ioprio_set)
169 n = c->ioprio;
60f067b4 170 else {
663996b3 171 n = ioprio_get(IOPRIO_WHO_PROCESS, 0);
60f067b4
JS		 172 if (n < 0)
173 n = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 4);
174 }
663996b3 175
60f067b4 176 return sd_bus_message_append(reply, "i", n);
663996b3
MS		 177}
178
60f067b4
JS		 179static int property_get_cpu_sched_policy(
180 sd_bus *bus,
181 const char *path,
182 const char *interface,
183 const char *property,
184 sd_bus_message *reply,
185 void *userdata,
186 sd_bus_error *error) {
187
188 ExecContext *c = userdata;
663996b3
MS		 189 int32_t n;
190
60f067b4
JS		 191 assert(bus);
192 assert(reply);
663996b3
MS		 193 assert(c);
194
195 if (c->cpu_sched_set)
196 n = c->cpu_sched_policy;
60f067b4 197 else {
663996b3 198 n = sched_getscheduler(0);
60f067b4
JS		 199 if (n < 0)
200 n = SCHED_OTHER;
201 }
663996b3 202
60f067b4 203 return sd_bus_message_append(reply, "i", n);
663996b3
MS		 204}
205
60f067b4
JS		 206static int property_get_cpu_sched_priority(
207 sd_bus *bus,
208 const char *path,
209 const char *interface,
210 const char *property,
211 sd_bus_message *reply,
212 void *userdata,
213 sd_bus_error *error) {
214
215 ExecContext *c = userdata;
663996b3
MS		 216 int32_t n;
217
60f067b4
JS		 218 assert(bus);
219 assert(reply);
663996b3
MS		 220 assert(c);
221
222 if (c->cpu_sched_set)
223 n = c->cpu_sched_priority;
224 else {
225 struct sched_param p = {};
226
227 if (sched_getparam(0, &p) >= 0)
228 n = p.sched_priority;
229 else
230 n = 0;
231 }
232
60f067b4 233 return sd_bus_message_append(reply, "i", n);
663996b3
MS		 234}
235
60f067b4
JS		 236static int property_get_cpu_affinity(
237 sd_bus *bus,
238 const char *path,
239 const char *interface,
240 const char *property,
241 sd_bus_message *reply,
242 void *userdata,
243 sd_bus_error *error) {
663996b3 244
60f067b4 245 ExecContext *c = userdata;
663996b3 246
60f067b4
JS		 247 assert(bus);
248 assert(reply);
249 assert(c);
663996b3
MS		 250
251 if (c->cpuset)
60f067b4 252 return sd_bus_message_append_array(reply, 'y', c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
663996b3 253 else
60f067b4 254 return sd_bus_message_append_array(reply, 'y', NULL, 0);
663996b3
MS		 255}
256
60f067b4
JS		 257static int property_get_timer_slack_nsec(
258 sd_bus *bus,
259 const char *path,
260 const char *interface,
261 const char *property,
262 sd_bus_message *reply,
263 void *userdata,
264 sd_bus_error *error) {
265
266 ExecContext *c = userdata;
663996b3
MS		 267 uint64_t u;
268
60f067b4
JS		 269 assert(bus);
270 assert(reply);
663996b3
MS		 271 assert(c);
272
5eef597e 273 if (c->timer_slack_nsec != NSEC_INFINITY)
663996b3
MS		 274 u = (uint64_t) c->timer_slack_nsec;
275 else
276 u = (uint64_t) prctl(PR_GET_TIMERSLACK);
277
60f067b4 278 return sd_bus_message_append(reply, "t", u);
663996b3
MS		 279}
280
60f067b4
JS		 281static int property_get_capability_bounding_set(
282 sd_bus *bus,
283 const char *path,
284 const char *interface,
285 const char *property,
286 sd_bus_message *reply,
287 void *userdata,
288 sd_bus_error *error) {
663996b3 289
60f067b4
JS		 290 ExecContext *c = userdata;
291
292 assert(bus);
293 assert(reply);
663996b3
MS		 294 assert(c);
295
296 /* We store this negated internally, to match the kernel, but
297 * we expose it normalized. */
60f067b4 298 return sd_bus_message_append(reply, "t", ~c->capability_bounding_set_drop);
663996b3
MS		 299}
300
60f067b4
JS		 301static int property_get_capabilities(
302 sd_bus *bus,
303 const char *path,
304 const char *interface,
305 const char *property,
306 sd_bus_message *reply,
307 void *userdata,
308 sd_bus_error *error) {
309
310 ExecContext *c = userdata;
311 _cleanup_cap_free_charp_ char *t = NULL;
663996b3 312 const char *s;
663996b3 313
60f067b4
JS		 314 assert(bus);
315 assert(reply);
663996b3
MS		 316 assert(c);
317
318 if (c->capabilities)
319 s = t = cap_to_text(c->capabilities, NULL);
320 else
321 s = "";
322
323 if (!s)
324 return -ENOMEM;
325
60f067b4
JS		 326 return sd_bus_message_append(reply, "s", s);
327}
663996b3 328
60f067b4
JS		 329static int property_get_syscall_filter(
330 sd_bus *bus,
331 const char *path,
332 const char *interface,
333 const char *property,
334 sd_bus_message *reply,
335 void *userdata,
336 sd_bus_error *error) {
337
338 ExecContext *c = userdata;
339 _cleanup_strv_free_ char **l = NULL;
340 int r;
663996b3 341
60f067b4
JS		 342#ifdef HAVE_SECCOMP
343 Iterator i;
344 void *id;
345#endif
663996b3 346
60f067b4
JS		 347 assert(bus);
348 assert(reply);
349 assert(c);
350
351 r = sd_bus_message_open_container(reply, 'r', "bas");
352 if (r < 0)
353 return r;
354
355 r = sd_bus_message_append(reply, "b", c->syscall_whitelist);
356 if (r < 0)
357 return r;
358
359#ifdef HAVE_SECCOMP
360 SET_FOREACH(id, c->syscall_filter, i) {
361 char *name;
362
363 name = seccomp_syscall_resolve_num_arch(SCMP_ARCH_NATIVE, PTR_TO_INT(id) - 1);
364 if (!name)
365 continue;
366
367 r = strv_consume(&l, name);
368 if (r < 0)
369 return r;
370 }
371#endif
372
373 strv_sort(l);
374
375 r = sd_bus_message_append_strv(reply, l);
376 if (r < 0)
377 return r;
378
379 return sd_bus_message_close_container(reply);
663996b3
MS		 380}
381
60f067b4
JS		 382static int property_get_syscall_archs(
383 sd_bus *bus,
384 const char *path,
385 const char *interface,
386 const char *property,
387 sd_bus_message *reply,
388 void *userdata,
389 sd_bus_error *error) {
390
391 ExecContext *c = userdata;
392 _cleanup_strv_free_ char **l = NULL;
663996b3 393 int r;
663996b3 394
60f067b4
JS		 395#ifdef HAVE_SECCOMP
396 Iterator i;
397 void *id;
398#endif
663996b3 399
60f067b4
JS		 400 assert(bus);
401 assert(reply);
402 assert(c);
663996b3 403
60f067b4
JS		 404#ifdef HAVE_SECCOMP
405 SET_FOREACH(id, c->syscall_archs, i) {
406 const char *name;
663996b3 407
60f067b4
JS		 408 name = seccomp_arch_to_string(PTR_TO_UINT32(id) - 1);
409 if (!name)
410 continue;
663996b3 411
60f067b4
JS		 412 r = strv_extend(&l, name);
413 if (r < 0)
414 return -ENOMEM;
663996b3 415 }
60f067b4 416#endif
663996b3 417
60f067b4
JS		 418 strv_sort(l);
419
420 r = sd_bus_message_append_strv(reply, l);
421 if (r < 0)
422 return r;
663996b3
MS		 423
424 return 0;
425}
426
60f067b4
JS		 427static int property_get_syscall_errno(
428 sd_bus *bus,
429 const char *path,
430 const char *interface,
431 const char *property,
432 sd_bus_message *reply,
433 void *userdata,
434 sd_bus_error *error) {
663996b3 435
60f067b4 436 ExecContext *c = userdata;
663996b3 437
60f067b4
JS		 438 assert(bus);
439 assert(reply);
440 assert(c);
663996b3 441
60f067b4
JS		 442 return sd_bus_message_append(reply, "i", (int32_t) c->syscall_errno);
443}
663996b3 444
60f067b4
JS		 445static int property_get_selinux_context(
446 sd_bus *bus,
447 const char *path,
448 const char *interface,
449 const char *property,
450 sd_bus_message *reply,
451 void *userdata,
452 sd_bus_error *error) {
663996b3 453
60f067b4 454 ExecContext *c = userdata;
663996b3 455
60f067b4
JS		 456 assert(bus);
457 assert(reply);
458 assert(c);
663996b3 459
60f067b4
JS		 460 return sd_bus_message_append(reply, "(bs)", c->selinux_context_ignore, c->selinux_context);
461}
462
463static int property_get_apparmor_profile(
464 sd_bus *bus,
465 const char *path,
466 const char *interface,
467 const char *property,
468 sd_bus_message *reply,
469 void *userdata,
470 sd_bus_error *error) {
471
472 ExecContext *c = userdata;
473
474 assert(bus);
475 assert(reply);
476 assert(c);
477
478 return sd_bus_message_append(reply, "(bs)", c->apparmor_profile_ignore, c->apparmor_profile);
479}
663996b3 480
f47781d8
MP		 481static int property_get_smack_process_label(
482 sd_bus *bus,
483 const char *path,
484 const char *interface,
485 const char *property,
486 sd_bus_message *reply,
487 void *userdata,
488 sd_bus_error *error) {
489
490 ExecContext *c = userdata;
491
492 assert(bus);
493 assert(reply);
494 assert(c);
495
496 return sd_bus_message_append(reply, "(bs)", c->smack_process_label_ignore, c->smack_process_label);
497}
498
60f067b4
JS		 499static int property_get_personality(
500 sd_bus *bus,
501 const char *path,
502 const char *interface,
503 const char *property,
504 sd_bus_message *reply,
505 void *userdata,
506 sd_bus_error *error) {
507
508 ExecContext *c = userdata;
509
510 assert(bus);
511 assert(reply);
512 assert(c);
513
514 return sd_bus_message_append(reply, "s", personality_to_string(c->personality));
515}
516
517static int property_get_address_families(
518 sd_bus *bus,
519 const char *path,
520 const char *interface,
521 const char *property,
522 sd_bus_message *reply,
523 void *userdata,
524 sd_bus_error *error) {
525
526 ExecContext *c = userdata;
527 _cleanup_strv_free_ char **l = NULL;
528 Iterator i;
529 void *af;
530 int r;
531
532 assert(bus);
533 assert(reply);
534 assert(c);
535
536 r = sd_bus_message_open_container(reply, 'r', "bas");
537 if (r < 0)
538 return r;
539
540 r = sd_bus_message_append(reply, "b", c->address_families_whitelist);
541 if (r < 0)
542 return r;
543
544 SET_FOREACH(af, c->address_families, i) {
545 const char *name;
546
547 name = af_to_name(PTR_TO_INT(af));
548 if (!name)
549 continue;
550
551 r = strv_extend(&l, name);
552 if (r < 0)
663996b3
MS		 553 return -ENOMEM;
554 }
555
60f067b4 556 strv_sort(l);
663996b3 557
60f067b4
JS		 558 r = sd_bus_message_append_strv(reply, l);
559 if (r < 0)
560 return r;
561
562 return sd_bus_message_close_container(reply);
663996b3
MS		 563}
564
6300502b
MP		 565static int property_get_working_directory(
566 sd_bus *bus,
567 const char *path,
568 const char *interface,
569 const char *property,
570 sd_bus_message *reply,
571 void *userdata,
572 sd_bus_error *error) {
573
574 ExecContext *c = userdata;
575 const char *wd;
576
577 assert(bus);
578 assert(reply);
579 assert(c);
580
581 if (c->working_directory_home)
582 wd = "~";
583 else
584 wd = c->working_directory;
585
586 if (c->working_directory_missing_ok)
587 wd = strjoina("!", wd);
588
589 return sd_bus_message_append(reply, "s", wd);
590}
591
db2df898
MP		 592static int property_get_syslog_level(
593 sd_bus *bus,
594 const char *path,
595 const char *interface,
596 const char *property,
597 sd_bus_message *reply,
598 void *userdata,
599 sd_bus_error *error) {
600
601 ExecContext *c = userdata;
602
603 assert(bus);
604 assert(reply);
605 assert(c);
606
607 return sd_bus_message_append(reply, "i", LOG_PRI(c->syslog_priority));
608}
609
610static int property_get_syslog_facility(
611 sd_bus *bus,
612 const char *path,
613 const char *interface,
614 const char *property,
615 sd_bus_message *reply,
616 void *userdata,
617 sd_bus_error *error) {
618
619 ExecContext *c = userdata;
620
621 assert(bus);
622 assert(reply);
623 assert(c);
624
625 return sd_bus_message_append(reply, "i", LOG_FAC(c->syslog_priority));
626}
627
60f067b4
JS		 628const sd_bus_vtable bus_exec_vtable[] = {
629 SD_BUS_VTABLE_START(0),
630 SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(ExecContext, environment), SD_BUS_VTABLE_PROPERTY_CONST),
631 SD_BUS_PROPERTY("EnvironmentFiles", "a(sb)", property_get_environment_files, 0, SD_BUS_VTABLE_PROPERTY_CONST),
db2df898 632 SD_BUS_PROPERTY("PassEnvironment", "as", NULL, offsetof(ExecContext, pass_environment), SD_BUS_VTABLE_PROPERTY_CONST),
60f067b4 633 SD_BUS_PROPERTY("UMask", "u", bus_property_get_mode, offsetof(ExecContext, umask), SD_BUS_VTABLE_PROPERTY_CONST),
db2df898
MP		 634 SD_BUS_PROPERTY("LimitCPU", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
635 SD_BUS_PROPERTY("LimitFSIZE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
636 SD_BUS_PROPERTY("LimitDATA", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
637 SD_BUS_PROPERTY("LimitSTACK", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
638 SD_BUS_PROPERTY("LimitCORE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
639 SD_BUS_PROPERTY("LimitRSS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
640 SD_BUS_PROPERTY("LimitNOFILE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
641 SD_BUS_PROPERTY("LimitAS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
642 SD_BUS_PROPERTY("LimitNPROC", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
643 SD_BUS_PROPERTY("LimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
644 SD_BUS_PROPERTY("LimitLOCKS", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
645 SD_BUS_PROPERTY("LimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
646 SD_BUS_PROPERTY("LimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
647 SD_BUS_PROPERTY("LimitNICE", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
648 SD_BUS_PROPERTY("LimitRTPRIO", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
649 SD_BUS_PROPERTY("LimitRTTIME", "t", bus_property_get_rlimit, offsetof(ExecContext, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
6300502b 650 SD_BUS_PROPERTY("WorkingDirectory", "s", property_get_working_directory, 0, SD_BUS_VTABLE_PROPERTY_CONST),
60f067b4
JS		 651 SD_BUS_PROPERTY("RootDirectory", "s", NULL, offsetof(ExecContext, root_directory), SD_BUS_VTABLE_PROPERTY_CONST),
652 SD_BUS_PROPERTY("OOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
653 SD_BUS_PROPERTY("Nice", "i", property_get_nice, 0, SD_BUS_VTABLE_PROPERTY_CONST),
654 SD_BUS_PROPERTY("IOScheduling", "i", property_get_ioprio, 0, SD_BUS_VTABLE_PROPERTY_CONST),
655 SD_BUS_PROPERTY("CPUSchedulingPolicy", "i", property_get_cpu_sched_policy, 0, SD_BUS_VTABLE_PROPERTY_CONST),
656 SD_BUS_PROPERTY("CPUSchedulingPriority", "i", property_get_cpu_sched_priority, 0, SD_BUS_VTABLE_PROPERTY_CONST),
657 SD_BUS_PROPERTY("CPUAffinity", "ay", property_get_cpu_affinity, 0, SD_BUS_VTABLE_PROPERTY_CONST),
658 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
659 SD_BUS_PROPERTY("CPUSchedulingResetOnFork", "b", bus_property_get_bool, offsetof(ExecContext, cpu_sched_reset_on_fork), SD_BUS_VTABLE_PROPERTY_CONST),
660 SD_BUS_PROPERTY("NonBlocking", "b", bus_property_get_bool, offsetof(ExecContext, non_blocking), SD_BUS_VTABLE_PROPERTY_CONST),
661 SD_BUS_PROPERTY("StandardInput", "s", property_get_exec_input, offsetof(ExecContext, std_input), SD_BUS_VTABLE_PROPERTY_CONST),
662 SD_BUS_PROPERTY("StandardOutput", "s", bus_property_get_exec_output, offsetof(ExecContext, std_output), SD_BUS_VTABLE_PROPERTY_CONST),
663 SD_BUS_PROPERTY("StandardError", "s", bus_property_get_exec_output, offsetof(ExecContext, std_error), SD_BUS_VTABLE_PROPERTY_CONST),
664 SD_BUS_PROPERTY("TTYPath", "s", NULL, offsetof(ExecContext, tty_path), SD_BUS_VTABLE_PROPERTY_CONST),
665 SD_BUS_PROPERTY("TTYReset", "b", bus_property_get_bool, offsetof(ExecContext, tty_reset), SD_BUS_VTABLE_PROPERTY_CONST),
666 SD_BUS_PROPERTY("TTYVHangup", "b", bus_property_get_bool, offsetof(ExecContext, tty_vhangup), SD_BUS_VTABLE_PROPERTY_CONST),
667 SD_BUS_PROPERTY("TTYVTDisallocate", "b", bus_property_get_bool, offsetof(ExecContext, tty_vt_disallocate), SD_BUS_VTABLE_PROPERTY_CONST),
668 SD_BUS_PROPERTY("SyslogPriority", "i", bus_property_get_int, offsetof(ExecContext, syslog_priority), SD_BUS_VTABLE_PROPERTY_CONST),
669 SD_BUS_PROPERTY("SyslogIdentifier", "s", NULL, offsetof(ExecContext, syslog_identifier), SD_BUS_VTABLE_PROPERTY_CONST),
670 SD_BUS_PROPERTY("SyslogLevelPrefix", "b", bus_property_get_bool, offsetof(ExecContext, syslog_level_prefix), SD_BUS_VTABLE_PROPERTY_CONST),
db2df898
MP		 671 SD_BUS_PROPERTY("SyslogLevel", "i", property_get_syslog_level, 0, SD_BUS_VTABLE_PROPERTY_CONST),
672 SD_BUS_PROPERTY("SyslogFacility", "i", property_get_syslog_facility, 0, SD_BUS_VTABLE_PROPERTY_CONST),
60f067b4
JS		 673 SD_BUS_PROPERTY("Capabilities", "s", property_get_capabilities, 0, SD_BUS_VTABLE_PROPERTY_CONST),
674 SD_BUS_PROPERTY("SecureBits", "i", bus_property_get_int, offsetof(ExecContext, secure_bits), SD_BUS_VTABLE_PROPERTY_CONST),
675 SD_BUS_PROPERTY("CapabilityBoundingSet", "t", property_get_capability_bounding_set, 0, SD_BUS_VTABLE_PROPERTY_CONST),
676 SD_BUS_PROPERTY("User", "s", NULL, offsetof(ExecContext, user), SD_BUS_VTABLE_PROPERTY_CONST),
677 SD_BUS_PROPERTY("Group", "s", NULL, offsetof(ExecContext, group), SD_BUS_VTABLE_PROPERTY_CONST),
678 SD_BUS_PROPERTY("SupplementaryGroups", "as", NULL, offsetof(ExecContext, supplementary_groups), SD_BUS_VTABLE_PROPERTY_CONST),
679 SD_BUS_PROPERTY("PAMName", "s", NULL, offsetof(ExecContext, pam_name), SD_BUS_VTABLE_PROPERTY_CONST),
680 SD_BUS_PROPERTY("ReadWriteDirectories", "as", NULL, offsetof(ExecContext, read_write_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
681 SD_BUS_PROPERTY("ReadOnlyDirectories", "as", NULL, offsetof(ExecContext, read_only_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
682 SD_BUS_PROPERTY("InaccessibleDirectories", "as", NULL, offsetof(ExecContext, inaccessible_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
683 SD_BUS_PROPERTY("MountFlags", "t", bus_property_get_ulong, offsetof(ExecContext, mount_flags), SD_BUS_VTABLE_PROPERTY_CONST),
684 SD_BUS_PROPERTY("PrivateTmp", "b", bus_property_get_bool, offsetof(ExecContext, private_tmp), SD_BUS_VTABLE_PROPERTY_CONST),
685 SD_BUS_PROPERTY("PrivateNetwork", "b", bus_property_get_bool, offsetof(ExecContext, private_network), SD_BUS_VTABLE_PROPERTY_CONST),
686 SD_BUS_PROPERTY("PrivateDevices", "b", bus_property_get_bool, offsetof(ExecContext, private_devices), SD_BUS_VTABLE_PROPERTY_CONST),
687 SD_BUS_PROPERTY("ProtectHome", "s", bus_property_get_protect_home, offsetof(ExecContext, protect_home), SD_BUS_VTABLE_PROPERTY_CONST),
688 SD_BUS_PROPERTY("ProtectSystem", "s", bus_property_get_protect_system, offsetof(ExecContext, protect_system), SD_BUS_VTABLE_PROPERTY_CONST),
689 SD_BUS_PROPERTY("SameProcessGroup", "b", bus_property_get_bool, offsetof(ExecContext, same_pgrp), SD_BUS_VTABLE_PROPERTY_CONST),
690 SD_BUS_PROPERTY("UtmpIdentifier", "s", NULL, offsetof(ExecContext, utmp_id), SD_BUS_VTABLE_PROPERTY_CONST),
13d276d0 691 SD_BUS_PROPERTY("UtmpMode", "s", property_get_exec_utmp_mode, offsetof(ExecContext, utmp_mode), SD_BUS_VTABLE_PROPERTY_CONST),
60f067b4
JS		 692 SD_BUS_PROPERTY("SELinuxContext", "(bs)", property_get_selinux_context, 0, SD_BUS_VTABLE_PROPERTY_CONST),
693 SD_BUS_PROPERTY("AppArmorProfile", "(bs)", property_get_apparmor_profile, 0, SD_BUS_VTABLE_PROPERTY_CONST),
f47781d8 694 SD_BUS_PROPERTY("SmackProcessLabel", "(bs)", property_get_smack_process_label, 0, SD_BUS_VTABLE_PROPERTY_CONST),
60f067b4
JS		 695 SD_BUS_PROPERTY("IgnoreSIGPIPE", "b", bus_property_get_bool, offsetof(ExecContext, ignore_sigpipe), SD_BUS_VTABLE_PROPERTY_CONST),
696 SD_BUS_PROPERTY("NoNewPrivileges", "b", bus_property_get_bool, offsetof(ExecContext, no_new_privileges), SD_BUS_VTABLE_PROPERTY_CONST),
697 SD_BUS_PROPERTY("SystemCallFilter", "(bas)", property_get_syscall_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
698 SD_BUS_PROPERTY("SystemCallArchitectures", "as", property_get_syscall_archs, 0, SD_BUS_VTABLE_PROPERTY_CONST),
699 SD_BUS_PROPERTY("SystemCallErrorNumber", "i", property_get_syscall_errno, 0, SD_BUS_VTABLE_PROPERTY_CONST),
700 SD_BUS_PROPERTY("Personality", "s", property_get_personality, 0, SD_BUS_VTABLE_PROPERTY_CONST),
701 SD_BUS_PROPERTY("RestrictAddressFamilies", "(bas)", property_get_address_families, 0, SD_BUS_VTABLE_PROPERTY_CONST),
702 SD_BUS_PROPERTY("RuntimeDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, runtime_directory_mode), SD_BUS_VTABLE_PROPERTY_CONST),
703 SD_BUS_PROPERTY("RuntimeDirectory", "as", NULL, offsetof(ExecContext, runtime_directory), SD_BUS_VTABLE_PROPERTY_CONST),
704 SD_BUS_VTABLE_END
705};
663996b3 706
60f067b4
JS		 707static int append_exec_command(sd_bus_message *reply, ExecCommand *c) {
708 int r;
709
710 assert(reply);
663996b3
MS		 711 assert(c);
712
60f067b4
JS		 713 if (!c->path)
714 return 0;
715
716 r = sd_bus_message_open_container(reply, 'r', "sasbttttuii");
717 if (r < 0)
718 return r;
719
720 r = sd_bus_message_append(reply, "s", c->path);
721 if (r < 0)
722 return r;
723
724 r = sd_bus_message_append_strv(reply, c->argv);
725 if (r < 0)
726 return r;
727
728 r = sd_bus_message_append(reply, "bttttuii",
729 c->ignore,
730 c->exec_status.start_timestamp.realtime,
731 c->exec_status.start_timestamp.monotonic,
732 c->exec_status.exit_timestamp.realtime,
733 c->exec_status.exit_timestamp.monotonic,
734 (uint32_t) c->exec_status.pid,
735 (int32_t) c->exec_status.code,
736 (int32_t) c->exec_status.status);
737 if (r < 0)
738 return r;
739
740 return sd_bus_message_close_container(reply);
741}
663996b3 742
60f067b4
JS		 743int bus_property_get_exec_command(
744 sd_bus *bus,
745 const char *path,
746 const char *interface,
747 const char *property,
748 sd_bus_message *reply,
749 void *userdata,
750 sd_bus_error *ret_error) {
663996b3 751
60f067b4
JS		 752 ExecCommand *c = (ExecCommand*) userdata;
753 int r;
663996b3 754
60f067b4
JS		 755 assert(bus);
756 assert(reply);
663996b3 757
60f067b4
JS		 758 r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
759 if (r < 0)
760 return r;
761
762 r = append_exec_command(reply, c);
763 if (r < 0)
764 return r;
765
766 return sd_bus_message_close_container(reply);
663996b3
MS		 767}
768
60f067b4
JS		 769int bus_property_get_exec_command_list(
770 sd_bus *bus,
771 const char *path,
772 const char *interface,
773 const char *property,
774 sd_bus_message *reply,
775 void *userdata,
776 sd_bus_error *ret_error) {
777
778 ExecCommand *c = *(ExecCommand**) userdata;
779 int r;
780
781 assert(bus);
782 assert(reply);
783
784 r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
785 if (r < 0)
786 return r;
787
788 LIST_FOREACH(command, c, c) {
789 r = append_exec_command(reply, c);
790 if (r < 0)
791 return r;
792 }
793
794 return sd_bus_message_close_container(reply);
795}
796
797int bus_exec_context_set_transient_property(
798 Unit *u,
799 ExecContext *c,
800 const char *name,
801 sd_bus_message *message,
802 UnitSetPropertiesMode mode,
803 sd_bus_error *error) {
804
805 int r;
806
807 assert(u);
808 assert(c);
809 assert(name);
810 assert(message);
811
812 if (streq(name, "User")) {
813 const char *uu;
814
815 r = sd_bus_message_read(message, "s", &uu);
816 if (r < 0)
817 return r;
818
819 if (mode != UNIT_CHECK) {
820
821 if (isempty(uu)) {
6300502b 822 c->user = mfree(c->user);
60f067b4
JS		 823 } else {
824 char *t;
825
826 t = strdup(uu);
827 if (!t)
828 return -ENOMEM;
829
830 free(c->user);
831 c->user = t;
832 }
833
834 unit_write_drop_in_private_format(u, mode, name, "User=%s\n", uu);
835 }
836
837 return 1;
838
839 } else if (streq(name, "Group")) {
840 const char *gg;
841
842 r = sd_bus_message_read(message, "s", &gg);
843 if (r < 0)
844 return r;
845
846 if (mode != UNIT_CHECK) {
847
848 if (isempty(gg)) {
6300502b 849 c->group = mfree(c->group);
60f067b4
JS		 850 } else {
851 char *t;
852
853 t = strdup(gg);
854 if (!t)
855 return -ENOMEM;
856
857 free(c->group);
858 c->group = t;
859 }
860
861 unit_write_drop_in_private_format(u, mode, name, "Group=%s\n", gg);
862 }
863
864 return 1;
db2df898
MP		 865 } else if (streq(name, "SyslogIdentifier")) {
866 const char *id;
867
868 r = sd_bus_message_read(message, "s", &id);
869 if (r < 0)
870 return r;
871
872 if (mode != UNIT_CHECK) {
873
874 if (isempty(id)) {
875 c->syslog_identifier = mfree(c->syslog_identifier);
876 } else {
877 char *t;
878
879 t = strdup(id);
880 if (!t)
881 return -ENOMEM;
882
883 free(c->syslog_identifier);
884 c->syslog_identifier = t;
885 }
886
887 unit_write_drop_in_private_format(u, mode, name, "SyslogIdentifier=%s\n", id);
888 }
889
890 return 1;
891 } else if (streq(name, "SyslogLevel")) {
892 int level;
893
894 r = sd_bus_message_read(message, "i", &level);
895 if (r < 0)
896 return r;
897
898 if (!log_level_is_valid(level))
899 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log level value out of range");
900
901 if (mode != UNIT_CHECK) {
902 c->syslog_priority = (c->syslog_priority & LOG_FACMASK) | level;
903 unit_write_drop_in_private_format(u, mode, name, "SyslogLevel=%i\n", level);
904 }
905
906 return 1;
907 } else if (streq(name, "SyslogFacility")) {
908 int facility;
909
910 r = sd_bus_message_read(message, "i", &facility);
911 if (r < 0)
912 return r;
913
914 if (!log_facility_unshifted_is_valid(facility))
915 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log facility value out of range");
916
917 if (mode != UNIT_CHECK) {
918 c->syslog_priority = (facility << 3) | LOG_PRI(c->syslog_priority);
919 unit_write_drop_in_private_format(u, mode, name, "SyslogFacility=%i\n", facility);
920 }
60f067b4 921
db2df898 922 return 1;
60f067b4
JS		 923 } else if (streq(name, "Nice")) {
924 int n;
925
926 r = sd_bus_message_read(message, "i", &n);
927 if (r < 0)
928 return r;
929
930 if (n < PRIO_MIN || n >= PRIO_MAX)
931 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Nice value out of range");
932
933 if (mode != UNIT_CHECK) {
934 c->nice = n;
935 unit_write_drop_in_private_format(u, mode, name, "Nice=%i\n", n);
936 }
937
938 return 1;
939
6300502b
MP		 940 } else if (STR_IN_SET(name, "TTYPath", "RootDirectory")) {
941 const char *s;
e735f4d4 942
6300502b 943 r = sd_bus_message_read(message, "s", &s);
e735f4d4
MP		 944 if (r < 0)
945 return r;
946
6300502b
MP		 947 if (!path_is_absolute(s))
948 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s takes an absolute path", name);
e735f4d4
MP		 949
950 if (mode != UNIT_CHECK) {
6300502b
MP		 951 if (streq(name, "TTYPath"))
952 r = free_and_strdup(&c->tty_path, s);
953 else {
954 assert(streq(name, "RootDirectory"));
955 r = free_and_strdup(&c->root_directory, s);
956 }
957 if (r < 0)
958 return r;
959
960 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, s);
961 }
962
963 return 1;
964
965 } else if (streq(name, "WorkingDirectory")) {
966 const char *s;
967 bool missing_ok;
968
969 r = sd_bus_message_read(message, "s", &s);
970 if (r < 0)
971 return r;
972
973 if (s[0] == '-') {
974 missing_ok = true;
975 s++;
976 } else
977 missing_ok = false;
978
979 if (!streq(s, "~") && !path_is_absolute(s))
980 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "WorkingDirectory= expects an absolute path or '~'");
e735f4d4 981
6300502b
MP		 982 if (mode != UNIT_CHECK) {
983 if (streq(s, "~")) {
984 c->working_directory = mfree(c->working_directory);
985 c->working_directory_home = true;
986 } else {
987 r = free_and_strdup(&c->working_directory, s);
988 if (r < 0)
989 return r;
e735f4d4 990
6300502b
MP		 991 c->working_directory_home = false;
992 }
e735f4d4 993
6300502b
MP		 994 c->working_directory_missing_ok = missing_ok;
995 unit_write_drop_in_private_format(u, mode, name, "WorkingDirectory=%s%s", missing_ok ? "-" : "", s);
e735f4d4
MP		 996 }
997
998 return 1;
999
1000 } else if (streq(name, "StandardInput")) {
1001 const char *s;
1002 ExecInput p;
1003
1004 r = sd_bus_message_read(message, "s", &s);
1005 if (r < 0)
1006 return r;
1007
1008 p = exec_input_from_string(s);
1009 if (p < 0)
1010 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid standard input name");
1011
1012 if (mode != UNIT_CHECK) {
1013 c->std_input = p;
1014
1015 unit_write_drop_in_private_format(u, mode, name, "StandardInput=%s\n", exec_input_to_string(p));
1016 }
1017
1018 return 1;
1019
1020
1021 } else if (streq(name, "StandardOutput")) {
1022 const char *s;
1023 ExecOutput p;
1024
1025 r = sd_bus_message_read(message, "s", &s);
1026 if (r < 0)
1027 return r;
1028
1029 p = exec_output_from_string(s);
1030 if (p < 0)
1031 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid standard output name");
1032
1033 if (mode != UNIT_CHECK) {
1034 c->std_output = p;
1035
1036 unit_write_drop_in_private_format(u, mode, name, "StandardOutput=%s\n", exec_output_to_string(p));
1037 }
1038
1039 return 1;
1040
1041 } else if (streq(name, "StandardError")) {
1042 const char *s;
1043 ExecOutput p;
1044
1045 r = sd_bus_message_read(message, "s", &s);
1046 if (r < 0)
1047 return r;
1048
1049 p = exec_output_from_string(s);
1050 if (p < 0)
1051 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid standard error name");
1052
1053 if (mode != UNIT_CHECK) {
1054 c->std_error = p;
1055
1056 unit_write_drop_in_private_format(u, mode, name, "StandardError=%s\n", exec_output_to_string(p));
1057 }
1058
1059 return 1;
1060
6300502b
MP		 1061 } else if (STR_IN_SET(name,
1062 "IgnoreSIGPIPE", "TTYVHangup", "TTYReset",
1063 "PrivateTmp", "PrivateDevices", "PrivateNetwork",
db2df898 1064 "NoNewPrivileges", "SyslogLevelPrefix")) {
13d276d0
MP		 1065 int b;
1066
1067 r = sd_bus_message_read(message, "b", &b);
1068 if (r < 0)
1069 return r;
1070
1071 if (mode != UNIT_CHECK) {
6300502b
MP		 1072 if (streq(name, "IgnoreSIGPIPE"))
1073 c->ignore_sigpipe = b;
1074 else if (streq(name, "TTYVHangup"))
1075 c->tty_vhangup = b;
1076 else if (streq(name, "TTYReset"))
1077 c->tty_reset = b;
1078 else if (streq(name, "PrivateTmp"))
1079 c->private_tmp = b;
1080 else if (streq(name, "PrivateDevices"))
1081 c->private_devices = b;
1082 else if (streq(name, "PrivateNetwork"))
1083 c->private_network = b;
1084 else if (streq(name, "NoNewPrivileges"))
1085 c->no_new_privileges = b;
db2df898
MP		 1086 else if (streq(name, "SyslogLevelPrefix"))
1087 c->syslog_level_prefix = b;
6300502b
MP		 1088
1089 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, yes_no(b));
13d276d0
MP		 1090 }
1091
1092 return 1;
1093
1094 } else if (streq(name, "UtmpIdentifier")) {
1095 const char *id;
1096
1097 r = sd_bus_message_read(message, "s", &id);
1098 if (r < 0)
1099 return r;
1100
1101 if (mode != UNIT_CHECK) {
1102 if (isempty(id))
1103 c->utmp_id = mfree(c->utmp_id);
1104 else if (free_and_strdup(&c->utmp_id, id) < 0)
1105 return -ENOMEM;
1106
1107 unit_write_drop_in_private_format(u, mode, name, "UtmpIdentifier=%s\n", strempty(id));
1108 }
1109
1110 return 1;
1111
1112 } else if (streq(name, "UtmpMode")) {
1113 const char *s;
1114 ExecUtmpMode m;
1115
1116 r = sd_bus_message_read(message, "s", &s);
1117 if (r < 0)
1118 return r;
1119
1120 m = exec_utmp_mode_from_string(s);
1121 if (m < 0)
1122 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid utmp mode");
1123
1124 if (mode != UNIT_CHECK) {
1125 c->utmp_mode = m;
1126
1127 unit_write_drop_in_private_format(u, mode, name, "UtmpMode=%s\n", exec_utmp_mode_to_string(m));
1128 }
1129
1130 return 1;
1131
1132 } else if (streq(name, "PAMName")) {
1133 const char *n;
1134
1135 r = sd_bus_message_read(message, "s", &n);
1136 if (r < 0)
1137 return r;
1138
1139 if (mode != UNIT_CHECK) {
1140 if (isempty(n))
1141 c->pam_name = mfree(c->pam_name);
1142 else if (free_and_strdup(&c->pam_name, n) < 0)
1143 return -ENOMEM;
1144
1145 unit_write_drop_in_private_format(u, mode, name, "PAMName=%s\n", strempty(n));
1146 }
1147
1148 return 1;
1149
60f067b4
JS		 1150 } else if (streq(name, "Environment")) {
1151
1152 _cleanup_strv_free_ char **l = NULL;
1153
1154 r = sd_bus_message_read_strv(message, &l);
1155 if (r < 0)
1156 return r;
1157
1158 if (!strv_env_is_valid(l))
1159 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment block.");
1160
1161 if (mode != UNIT_CHECK) {
1162 _cleanup_free_ char *joined = NULL;
1163 char **e;
1164
db2df898
MP		 1165 if (strv_length(l) == 0) {
1166 c->environment = strv_free(c->environment);
1167 unit_write_drop_in_private_format(u, mode, name, "Environment=\n");
1168 } else {
1169 e = strv_env_merge(2, c->environment, l);
1170 if (!e)
1171 return -ENOMEM;
60f067b4 1172
db2df898
MP		 1173 strv_free(c->environment);
1174 c->environment = e;
60f067b4 1175
db2df898
MP		 1176 joined = strv_join_quoted(c->environment);
1177 if (!joined)
1178 return -ENOMEM;
1179
1180 unit_write_drop_in_private_format(u, mode, name, "Environment=%s\n", joined);
1181 }
1182 }
1183
1184 return 1;
1185
1186 } else if (streq(name, "TimerSlackNSec")) {
1187
1188 nsec_t n;
1189
1190 r = sd_bus_message_read(message, "t", &n);
1191 if (r < 0)
1192 return r;
1193
1194 if (mode != UNIT_CHECK) {
1195 c->timer_slack_nsec = n;
1196 unit_write_drop_in_private_format(u, mode, name, "TimerSlackNSec=" NSEC_FMT "\n", n);
1197 }
1198
1199 return 1;
1200
1201 } else if (streq(name, "OOMScoreAdjust")) {
1202 int oa;
1203
1204 r = sd_bus_message_read(message, "i", &oa);
1205 if (r < 0)
1206 return r;
1207
1208 if (!oom_score_adjust_is_valid(oa))
1209 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "OOM score adjust value out of range");
1210
1211 if (mode != UNIT_CHECK) {
1212 c->oom_score_adjust = oa;
1213 c->oom_score_adjust_set = true;
1214 unit_write_drop_in_private_format(u, mode, name, "OOMScoreAdjust=%i\n", oa);
1215 }
1216
1217 return 1;
1218
1219 } else if (streq(name, "EnvironmentFiles")) {
1220
1221 _cleanup_free_ char *joined = NULL;
1222 _cleanup_fclose_ FILE *f = NULL;
1223 _cleanup_free_ char **l = NULL;
1224 size_t size = 0;
1225 char **i;
60f067b4 1226
db2df898
MP		 1227 r = sd_bus_message_enter_container(message, 'a', "(sb)");
1228 if (r < 0)
1229 return r;
1230
1231 f = open_memstream(&joined, &size);
1232 if (!f)
1233 return -ENOMEM;
1234
1235 STRV_FOREACH(i, c->environment_files)
1236 fprintf(f, "EnvironmentFile=%s\n", *i);
1237
1238 while ((r = sd_bus_message_enter_container(message, 'r', "sb")) > 0) {
1239 const char *path;
1240 int b;
1241
1242 r = sd_bus_message_read(message, "sb", &path, &b);
1243 if (r < 0)
1244 return r;
1245
1246 r = sd_bus_message_exit_container(message);
1247 if (r < 0)
1248 return r;
1249
1250 if (!isempty(path) && !path_is_absolute(path))
1251 return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);
1252
1253 if (mode != UNIT_CHECK) {
1254 char *buf = NULL;
1255
1256 buf = strjoin(b ? "-" : "", path, NULL);
1257 if (!buf)
1258 return -ENOMEM;
1259
1260 fprintf(f, "EnvironmentFile=%s\n", buf);
1261
1262 r = strv_consume(&l, buf);
1263 if (r < 0)
1264 return r;
1265 }
1266 }
1267 if (r < 0)
1268 return r;
1269
1270 r = sd_bus_message_exit_container(message);
1271 if (r < 0)
1272 return r;
1273
1274 r = fflush_and_check(f);
1275 if (r < 0)
1276 return r;
1277
1278 if (mode != UNIT_CHECK) {
1279 if (strv_isempty(l)) {
1280 c->environment_files = strv_free(c->environment_files);
1281 unit_write_drop_in_private(u, mode, name, "EnvironmentFile=\n");
1282 } else {
1283 r = strv_extend_strv(&c->environment_files, l, true);
1284 if (r < 0)
1285 return r;
1286
1287 unit_write_drop_in_private(u, mode, name, joined);
1288 }
1289 }
1290
1291 return 1;
1292
1293 } else if (streq(name, "PassEnvironment")) {
1294
1295 _cleanup_strv_free_ char **l = NULL;
1296
1297 r = sd_bus_message_read_strv(message, &l);
1298 if (r < 0)
1299 return r;
1300
1301 if (!strv_env_name_is_valid(l))
1302 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PassEnvironment block.");
1303
1304 if (mode != UNIT_CHECK) {
1305 if (strv_isempty(l)) {
1306 c->pass_environment = strv_free(c->pass_environment);
1307 unit_write_drop_in_private_format(u, mode, name, "PassEnvironment=\n");
1308 } else {
1309 _cleanup_free_ char *joined = NULL;
1310
1311 r = strv_extend_strv(&c->pass_environment, l, true);
1312 if (r < 0)
1313 return r;
1314
1315 joined = strv_join_quoted(c->pass_environment);
1316 if (!joined)
1317 return -ENOMEM;
1318
1319 unit_write_drop_in_private_format(u, mode, name, "PassEnvironment=%s\n", joined);
1320 }
1321 }
1322
1323 return 1;
1324
1325 } else if (STR_IN_SET(name, "ReadWriteDirectories", "ReadOnlyDirectories", "InaccessibleDirectories")) {
1326
1327 _cleanup_strv_free_ char **l = NULL;
1328 char ***dirs;
1329 char **p;
1330
1331 r = sd_bus_message_read_strv(message, &l);
1332 if (r < 0)
1333 return r;
1334
1335 STRV_FOREACH(p, l) {
1336 int offset;
1337 if (!utf8_is_valid(*p))
1338 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s", name);
1339
1340 offset = **p == '-';
1341 if (!path_is_absolute(*p + offset))
1342 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s", name);
1343 }
1344
1345 if (mode != UNIT_CHECK) {
1346 _cleanup_free_ char *joined = NULL;
1347
1348 if (streq(name, "ReadWriteDirectories"))
1349 dirs = &c->read_write_dirs;
1350 else if (streq(name, "ReadOnlyDirectories"))
1351 dirs = &c->read_only_dirs;
1352 else if (streq(name, "InaccessibleDirectories"))
1353 dirs = &c->inaccessible_dirs;
1354
1355 if (strv_length(l) == 0) {
1356 *dirs = strv_free(*dirs);
1357 unit_write_drop_in_private_format(u, mode, name, "%s=\n", name);
1358 } else {
1359 r = strv_extend_strv(dirs, l, true);
1360
1361 if (r < 0)
1362 return -ENOMEM;
1363
1364 joined = strv_join_quoted(*dirs);
1365 if (!joined)
1366 return -ENOMEM;
1367
1368 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, joined);
1369 }
1370
1371 }
1372
1373 return 1;
1374
1375 } else if (streq(name, "ProtectSystem")) {
1376 const char *s;
1377 ProtectSystem ps;
1378
1379 r = sd_bus_message_read(message, "s", &s);
1380 if (r < 0)
1381 return r;
1382
1383 r = parse_boolean(s);
1384 if (r > 0)
1385 ps = PROTECT_SYSTEM_YES;
1386 else if (r == 0)
1387 ps = PROTECT_SYSTEM_NO;
1388 else {
1389 ps = protect_system_from_string(s);
1390 if (ps < 0)
1391 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Failed to parse protect system value");
1392 }
1393
1394 if (mode != UNIT_CHECK) {
1395 c->protect_system = ps;
1396 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, s);
1397 }
1398
1399 return 1;
1400
1401 } else if (streq(name, "ProtectHome")) {
1402 const char *s;
1403 ProtectHome ph;
1404
1405 r = sd_bus_message_read(message, "s", &s);
1406 if (r < 0)
1407 return r;
1408
1409 r = parse_boolean(s);
1410 if (r > 0)
1411 ph = PROTECT_HOME_YES;
1412 else if (r == 0)
1413 ph = PROTECT_HOME_NO;
1414 else {
1415 ph = protect_home_from_string(s);
1416 if (ph < 0)
1417 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Failed to parse protect home value");
1418 }
1419
1420 if (mode != UNIT_CHECK) {
1421 c->protect_home = ph;
1422 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, s);
1423 }
1424
1425 return 1;
1426
1427 } else if (streq(name, "RuntimeDirectory")) {
1428 _cleanup_strv_free_ char **l = NULL;
1429 char **p;
1430
1431 r = sd_bus_message_read_strv(message, &l);
1432 if (r < 0)
1433 return r;
1434
1435 STRV_FOREACH(p, l) {
1436 if (!filename_is_valid(*p))
1437 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Runtime directory is not valid %s", *p);
1438 }
1439
1440 if (mode != UNIT_CHECK) {
1441 _cleanup_free_ char *joined = NULL;
1442
1443 if (strv_isempty(l)) {
1444 c->runtime_directory = strv_free(c->runtime_directory);
1445 unit_write_drop_in_private_format(u, mode, name, "%s=\n", name);
1446 } else {
1447 r = strv_extend_strv(&c->runtime_directory, l, true);
1448
1449 if (r < 0)
1450 return -ENOMEM;
1451
1452 joined = strv_join_quoted(c->runtime_directory);
1453 if (!joined)
1454 return -ENOMEM;
1455
1456 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, joined);
1457 }
60f067b4
JS		 1458 }
1459
1460 return 1;
1461
1462 } else if (rlimit_from_string(name) >= 0) {
1463 uint64_t rl;
1464 rlim_t x;
1465
1466 r = sd_bus_message_read(message, "t", &rl);
1467 if (r < 0)
1468 return r;
1469
1470 if (rl == (uint64_t) -1)
1471 x = RLIM_INFINITY;
1472 else {
1473 x = (rlim_t) rl;
1474
1475 if ((uint64_t) x != rl)
1476 return -ERANGE;
1477 }
1478
1479 if (mode != UNIT_CHECK) {
1480 int z;
1481
1482 z = rlimit_from_string(name);
1483
1484 if (!c->rlimit[z]) {
1485 c->rlimit[z] = new(struct rlimit, 1);
1486 if (!c->rlimit[z])
1487 return -ENOMEM;
1488 }
1489
1490 c->rlimit[z]->rlim_cur = c->rlimit[z]->rlim_max = x;
1491
1492 if (x == RLIM_INFINITY)
1493 unit_write_drop_in_private_format(u, mode, name, "%s=infinity\n", name);
1494 else
1495 unit_write_drop_in_private_format(u, mode, name, "%s=%" PRIu64 "\n", name, rl);
1496 }
1497
1498 return 1;
1499 }
1500
1501 return 0;
1502}
systemd for Proxmox projects