src/core/dbus-execute.c

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