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("SupplementaryGroups", "as", NULL, offsetof(ExecContext, supplementary_groups), SD_BUS_VTABLE_PROPERTY_CONST),
 697         SD_BUS_PROPERTY("PAMName", "s", NULL, offsetof(ExecContext, pam_name), SD_BUS_VTABLE_PROPERTY_CONST),
 698         SD_BUS_PROPERTY("ReadWriteDirectories", "as", NULL, offsetof(ExecContext, read_write_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
 699         SD_BUS_PROPERTY("ReadOnlyDirectories", "as", NULL, offsetof(ExecContext, read_only_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
 700         SD_BUS_PROPERTY("InaccessibleDirectories", "as", NULL, offsetof(ExecContext, inaccessible_dirs), SD_BUS_VTABLE_PROPERTY_CONST),
 701         SD_BUS_PROPERTY("MountFlags", "t", bus_property_get_ulong, offsetof(ExecContext, mount_flags), SD_BUS_VTABLE_PROPERTY_CONST),
 702         SD_BUS_PROPERTY("PrivateTmp", "b", bus_property_get_bool, offsetof(ExecContext, private_tmp), SD_BUS_VTABLE_PROPERTY_CONST),
 703         SD_BUS_PROPERTY("PrivateNetwork", "b", bus_property_get_bool, offsetof(ExecContext, private_network), SD_BUS_VTABLE_PROPERTY_CONST),
 704         SD_BUS_PROPERTY("PrivateDevices", "b", bus_property_get_bool, offsetof(ExecContext, private_devices), SD_BUS_VTABLE_PROPERTY_CONST),
 705         SD_BUS_PROPERTY("ProtectHome", "s", bus_property_get_protect_home, offsetof(ExecContext, protect_home), SD_BUS_VTABLE_PROPERTY_CONST),
 706         SD_BUS_PROPERTY("ProtectSystem", "s", bus_property_get_protect_system, offsetof(ExecContext, protect_system), SD_BUS_VTABLE_PROPERTY_CONST),
 707         SD_BUS_PROPERTY("SameProcessGroup", "b", bus_property_get_bool, offsetof(ExecContext, same_pgrp), SD_BUS_VTABLE_PROPERTY_CONST),
 708         SD_BUS_PROPERTY("UtmpIdentifier", "s", NULL, offsetof(ExecContext, utmp_id), SD_BUS_VTABLE_PROPERTY_CONST),
 709         SD_BUS_PROPERTY("UtmpMode", "s", property_get_exec_utmp_mode, offsetof(ExecContext, utmp_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 710         SD_BUS_PROPERTY("SELinuxContext", "(bs)", property_get_selinux_context, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 711         SD_BUS_PROPERTY("AppArmorProfile", "(bs)", property_get_apparmor_profile, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 712         SD_BUS_PROPERTY("SmackProcessLabel", "(bs)", property_get_smack_process_label, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 713         SD_BUS_PROPERTY("IgnoreSIGPIPE", "b", bus_property_get_bool, offsetof(ExecContext, ignore_sigpipe), SD_BUS_VTABLE_PROPERTY_CONST),
 714         SD_BUS_PROPERTY("NoNewPrivileges", "b", bus_property_get_bool, offsetof(ExecContext, no_new_privileges), SD_BUS_VTABLE_PROPERTY_CONST),
 715         SD_BUS_PROPERTY("SystemCallFilter", "(bas)", property_get_syscall_filter, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 716         SD_BUS_PROPERTY("SystemCallArchitectures", "as", property_get_syscall_archs, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 717         SD_BUS_PROPERTY("SystemCallErrorNumber", "i", property_get_syscall_errno, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 718         SD_BUS_PROPERTY("Personality", "s", property_get_personality, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 719         SD_BUS_PROPERTY("RestrictAddressFamilies", "(bas)", property_get_address_families, 0, SD_BUS_VTABLE_PROPERTY_CONST),
 720         SD_BUS_PROPERTY("RuntimeDirectoryMode", "u", bus_property_get_mode, offsetof(ExecContext, runtime_directory_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 721         SD_BUS_PROPERTY("RuntimeDirectory", "as", NULL, offsetof(ExecContext, runtime_directory), SD_BUS_VTABLE_PROPERTY_CONST),
 722         SD_BUS_VTABLE_END
 723 };
 724
 725 static int append_exec_command(sd_bus_message *reply, ExecCommand *c) {
 726         int r;
 727
 728         assert(reply);
 729         assert(c);
 730
 731         if (!c->path)
 732                 return 0;
 733
 734         r = sd_bus_message_open_container(reply, 'r', "sasbttttuii");
 735         if (r < 0)
 736                 return r;
 737
 738         r = sd_bus_message_append(reply, "s", c->path);
 739         if (r < 0)
 740                 return r;
 741
 742         r = sd_bus_message_append_strv(reply, c->argv);
 743         if (r < 0)
 744                 return r;
 745
 746         r = sd_bus_message_append(reply, "bttttuii",
 747                                   c->ignore,
 748                                   c->exec_status.start_timestamp.realtime,
 749                                   c->exec_status.start_timestamp.monotonic,
 750                                   c->exec_status.exit_timestamp.realtime,
 751                                   c->exec_status.exit_timestamp.monotonic,
 752                                   (uint32_t) c->exec_status.pid,
 753                                   (int32_t) c->exec_status.code,
 754                                   (int32_t) c->exec_status.status);
 755         if (r < 0)
 756                 return r;
 757
 758         return sd_bus_message_close_container(reply);
 759 }
 760
 761 int bus_property_get_exec_command(
 762                 sd_bus *bus,
 763                 const char *path,
 764                 const char *interface,
 765                 const char *property,
 766                 sd_bus_message *reply,
 767                 void *userdata,
 768                 sd_bus_error *ret_error) {
 769
 770         ExecCommand *c = (ExecCommand*) userdata;
 771         int r;
 772
 773         assert(bus);
 774         assert(reply);
 775
 776         r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
 777         if (r < 0)
 778                 return r;
 779
 780         r = append_exec_command(reply, c);
 781         if (r < 0)
 782                 return r;
 783
 784         return sd_bus_message_close_container(reply);
 785 }
 786
 787 int bus_property_get_exec_command_list(
 788                 sd_bus *bus,
 789                 const char *path,
 790                 const char *interface,
 791                 const char *property,
 792                 sd_bus_message *reply,
 793                 void *userdata,
 794                 sd_bus_error *ret_error) {
 795
 796         ExecCommand *c = *(ExecCommand**) userdata;
 797         int r;
 798
 799         assert(bus);
 800         assert(reply);
 801
 802         r = sd_bus_message_open_container(reply, 'a', "(sasbttttuii)");
 803         if (r < 0)
 804                 return r;
 805
 806         LIST_FOREACH(command, c, c) {
 807                 r = append_exec_command(reply, c);
 808                 if (r < 0)
 809                         return r;
 810         }
 811
 812         return sd_bus_message_close_container(reply);
 813 }
 814
 815 int bus_exec_context_set_transient_property(
 816                 Unit *u,
 817                 ExecContext *c,
 818                 const char *name,
 819                 sd_bus_message *message,
 820                 UnitSetPropertiesMode mode,
 821                 sd_bus_error *error) {
 822
 823         const char *soft = NULL;
 824         int r, ri;
 825
 826         assert(u);
 827         assert(c);
 828         assert(name);
 829         assert(message);
 830
 831         if (streq(name, "User")) {
 832                 const char *uu;
 833
 834                 r = sd_bus_message_read(message, "s", &uu);
 835                 if (r < 0)
 836                         return r;
 837
 838                 if (mode != UNIT_CHECK) {
 839
 840                         if (isempty(uu))
 841                                 c->user = mfree(c->user);
 842                         else {
 843                                 char *t;
 844
 845                                 t = strdup(uu);
 846                                 if (!t)
 847                                         return -ENOMEM;
 848
 849                                 free(c->user);
 850                                 c->user = t;
 851                         }
 852
 853                         unit_write_drop_in_private_format(u, mode, name, "User=%s\n", uu);
 854                 }
 855
 856                 return 1;
 857
 858         } else if (streq(name, "Group")) {
 859                 const char *gg;
 860
 861                 r = sd_bus_message_read(message, "s", &gg);
 862                 if (r < 0)
 863                         return r;
 864
 865                 if (mode != UNIT_CHECK) {
 866
 867                         if (isempty(gg))
 868                                 c->group = mfree(c->group);
 869                         else {
 870                                 char *t;
 871
 872                                 t = strdup(gg);
 873                                 if (!t)
 874                                         return -ENOMEM;
 875
 876                                 free(c->group);
 877                                 c->group = t;
 878                         }
 879
 880                         unit_write_drop_in_private_format(u, mode, name, "Group=%s\n", gg);
 881                 }
 882
 883                 return 1;
 884         } else if (streq(name, "SyslogIdentifier")) {
 885                 const char *id;
 886
 887                 r = sd_bus_message_read(message, "s", &id);
 888                 if (r < 0)
 889                         return r;
 890
 891                 if (mode != UNIT_CHECK) {
 892
 893                         if (isempty(id)) {
 894                                 c->syslog_identifier = mfree(c->syslog_identifier);
 895                         } else {
 896                                 char *t;
 897
 898                                 t = strdup(id);
 899                                 if (!t)
 900                                         return -ENOMEM;
 901
 902                                 free(c->syslog_identifier);
 903                                 c->syslog_identifier = t;
 904                         }
 905
 906                         unit_write_drop_in_private_format(u, mode, name, "SyslogIdentifier=%s\n", id);
 907                 }
 908
 909                 return 1;
 910         } else if (streq(name, "SyslogLevel")) {
 911                 int level;
 912
 913                 r = sd_bus_message_read(message, "i", &level);
 914                 if (r < 0)
 915                         return r;
 916
 917                 if (!log_level_is_valid(level))
 918                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log level value out of range");
 919
 920                 if (mode != UNIT_CHECK) {
 921                         c->syslog_priority = (c->syslog_priority & LOG_FACMASK) | level;
 922                         unit_write_drop_in_private_format(u, mode, name, "SyslogLevel=%i\n", level);
 923                 }
 924
 925                 return 1;
 926         } else if (streq(name, "SyslogFacility")) {
 927                 int facility;
 928
 929                 r = sd_bus_message_read(message, "i", &facility);
 930                 if (r < 0)
 931                         return r;
 932
 933                 if (!log_facility_unshifted_is_valid(facility))
 934                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Log facility value out of range");
 935
 936                 if (mode != UNIT_CHECK) {
 937                         c->syslog_priority = (facility << 3) | LOG_PRI(c->syslog_priority);
 938                         unit_write_drop_in_private_format(u, mode, name, "SyslogFacility=%i\n", facility);
 939                 }
 940
 941                 return 1;
 942         } else if (streq(name, "Nice")) {
 943                 int n;
 944
 945                 r = sd_bus_message_read(message, "i", &n);
 946                 if (r < 0)
 947                         return r;
 948
 949                 if (n < PRIO_MIN || n >= PRIO_MAX)
 950                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Nice value out of range");
 951
 952                 if (mode != UNIT_CHECK) {
 953                         c->nice = n;
 954                         unit_write_drop_in_private_format(u, mode, name, "Nice=%i\n", n);
 955                 }
 956
 957                 return 1;
 958
 959         } else if (STR_IN_SET(name, "TTYPath", "RootDirectory")) {
 960                 const char *s;
 961
 962                 r = sd_bus_message_read(message, "s", &s);
 963                 if (r < 0)
 964                         return r;
 965
 966                 if (!path_is_absolute(s))
 967                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s takes an absolute path", name);
 968
 969                 if (mode != UNIT_CHECK) {
 970                         if (streq(name, "TTYPath"))
 971                                 r = free_and_strdup(&c->tty_path, s);
 972                         else {
 973                                 assert(streq(name, "RootDirectory"));
 974                                 r = free_and_strdup(&c->root_directory, s);
 975                         }
 976                         if (r < 0)
 977                                 return r;
 978
 979                         unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, s);
 980                 }
 981
 982                 return 1;
 983
 984         } else if (streq(name, "WorkingDirectory")) {
 985                 const char *s;
 986                 bool missing_ok;
 987
 988                 r = sd_bus_message_read(message, "s", &s);
 989                 if (r < 0)
 990                         return r;
 991
 992                 if (s[0] == '-') {
 993                         missing_ok = true;
 994                         s++;
 995                 } else
 996                         missing_ok = false;
 997
 998                 if (!streq(s, "~") && !path_is_absolute(s))
 999                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "WorkingDirectory= expects an absolute path or '~'");
1000
1001                 if (mode != UNIT_CHECK) {
1002                         if (streq(s, "~")) {
1003                                 c->working_directory = mfree(c->working_directory);
1004                                 c->working_directory_home = true;
1005                         } else {
1006                                 r = free_and_strdup(&c->working_directory, s);
1007                                 if (r < 0)
1008                                         return r;
1009
1010                                 c->working_directory_home = false;
1011                         }
1012
1013                         c->working_directory_missing_ok = missing_ok;
1014                         unit_write_drop_in_private_format(u, mode, name, "WorkingDirectory=%s%s", missing_ok ? "-" : "", s);
1015                 }
1016
1017                 return 1;
1018
1019         } else if (streq(name, "StandardInput")) {
1020                 const char *s;
1021                 ExecInput p;
1022
1023                 r = sd_bus_message_read(message, "s", &s);
1024                 if (r < 0)
1025                         return r;
1026
1027                 p = exec_input_from_string(s);
1028                 if (p < 0)
1029                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid standard input name");
1030
1031                 if (mode != UNIT_CHECK) {
1032                         c->std_input = p;
1033
1034                         unit_write_drop_in_private_format(u, mode, name, "StandardInput=%s\n", exec_input_to_string(p));
1035                 }
1036
1037                 return 1;
1038
1039
1040         } else if (streq(name, "StandardOutput")) {
1041                 const char *s;
1042                 ExecOutput p;
1043
1044                 r = sd_bus_message_read(message, "s", &s);
1045                 if (r < 0)
1046                         return r;
1047
1048                 p = exec_output_from_string(s);
1049                 if (p < 0)
1050                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid standard output name");
1051
1052                 if (mode != UNIT_CHECK) {
1053                         c->std_output = p;
1054
1055                         unit_write_drop_in_private_format(u, mode, name, "StandardOutput=%s\n", exec_output_to_string(p));
1056                 }
1057
1058                 return 1;
1059
1060         } else if (streq(name, "StandardError")) {
1061                 const char *s;
1062                 ExecOutput p;
1063
1064                 r = sd_bus_message_read(message, "s", &s);
1065                 if (r < 0)
1066                         return r;
1067
1068                 p = exec_output_from_string(s);
1069                 if (p < 0)
1070                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid standard error name");
1071
1072                 if (mode != UNIT_CHECK) {
1073                         c->std_error = p;
1074
1075                         unit_write_drop_in_private_format(u, mode, name, "StandardError=%s\n", exec_output_to_string(p));
1076                 }
1077
1078                 return 1;
1079
1080         } else if (STR_IN_SET(name,
1081                               "IgnoreSIGPIPE", "TTYVHangup", "TTYReset",
1082                               "PrivateTmp", "PrivateDevices", "PrivateNetwork",
1083                               "NoNewPrivileges", "SyslogLevelPrefix")) {
1084                 int b;
1085
1086                 r = sd_bus_message_read(message, "b", &b);
1087                 if (r < 0)
1088                         return r;
1089
1090                 if (mode != UNIT_CHECK) {
1091                         if (streq(name, "IgnoreSIGPIPE"))
1092                                 c->ignore_sigpipe = b;
1093                         else if (streq(name, "TTYVHangup"))
1094                                 c->tty_vhangup = b;
1095                         else if (streq(name, "TTYReset"))
1096                                 c->tty_reset = b;
1097                         else if (streq(name, "PrivateTmp"))
1098                                 c->private_tmp = b;
1099                         else if (streq(name, "PrivateDevices"))
1100                                 c->private_devices = b;
1101                         else if (streq(name, "PrivateNetwork"))
1102                                 c->private_network = b;
1103                         else if (streq(name, "NoNewPrivileges"))
1104                                 c->no_new_privileges = b;
1105                         else if (streq(name, "SyslogLevelPrefix"))
1106                                 c->syslog_level_prefix = b;
1107
1108                         unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, yes_no(b));
1109                 }
1110
1111                 return 1;
1112
1113         } else if (streq(name, "UtmpIdentifier")) {
1114                 const char *id;
1115
1116                 r = sd_bus_message_read(message, "s", &id);
1117                 if (r < 0)
1118                         return r;
1119
1120                 if (mode != UNIT_CHECK) {
1121                         if (isempty(id))
1122                                 c->utmp_id = mfree(c->utmp_id);
1123                         else if (free_and_strdup(&c->utmp_id, id) < 0)
1124                                 return -ENOMEM;
1125
1126                         unit_write_drop_in_private_format(u, mode, name, "UtmpIdentifier=%s\n", strempty(id));
1127                 }
1128
1129                 return 1;
1130
1131         } else if (streq(name, "UtmpMode")) {
1132                 const char *s;
1133                 ExecUtmpMode m;
1134
1135                 r = sd_bus_message_read(message, "s", &s);
1136                 if (r < 0)
1137                         return r;
1138
1139                 m = exec_utmp_mode_from_string(s);
1140                 if (m < 0)
1141                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid utmp mode");
1142
1143                 if (mode != UNIT_CHECK) {
1144                         c->utmp_mode = m;
1145
1146                         unit_write_drop_in_private_format(u, mode, name, "UtmpMode=%s\n", exec_utmp_mode_to_string(m));
1147                 }
1148
1149                 return 1;
1150
1151         } else if (streq(name, "PAMName")) {
1152                 const char *n;
1153
1154                 r = sd_bus_message_read(message, "s", &n);
1155                 if (r < 0)
1156                         return r;
1157
1158                 if (mode != UNIT_CHECK) {
1159                         if (isempty(n))
1160                                 c->pam_name = mfree(c->pam_name);
1161                         else if (free_and_strdup(&c->pam_name, n) < 0)
1162                                 return -ENOMEM;
1163
1164                         unit_write_drop_in_private_format(u, mode, name, "PAMName=%s\n", strempty(n));
1165                 }
1166
1167                 return 1;
1168
1169         } else if (streq(name, "Environment")) {
1170
1171                 _cleanup_strv_free_ char **l = NULL;
1172
1173                 r = sd_bus_message_read_strv(message, &l);
1174                 if (r < 0)
1175                         return r;
1176
1177                 if (!strv_env_is_valid(l))
1178                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment block.");
1179
1180                 if (mode != UNIT_CHECK) {
1181                         _cleanup_free_ char *joined = NULL;
1182                         char **e;
1183
1184                         if (strv_length(l) == 0) {
1185                                 c->environment = strv_free(c->environment);
1186                                 unit_write_drop_in_private_format(u, mode, name, "Environment=\n");
1187                         } else {
1188                                 e = strv_env_merge(2, c->environment, l);
1189                                 if (!e)
1190                                         return -ENOMEM;
1191
1192                                 strv_free(c->environment);
1193                                 c->environment = e;
1194
1195                                 joined = strv_join_quoted(c->environment);
1196                                 if (!joined)
1197                                         return -ENOMEM;
1198
1199                                 unit_write_drop_in_private_format(u, mode, name, "Environment=%s\n", joined);
1200                         }
1201                 }
1202
1203                 return 1;
1204
1205         } else if (streq(name, "TimerSlackNSec")) {
1206
1207                 nsec_t n;
1208
1209                 r = sd_bus_message_read(message, "t", &n);
1210                 if (r < 0)
1211                         return r;
1212
1213                 if (mode != UNIT_CHECK) {
1214                         c->timer_slack_nsec = n;
1215                         unit_write_drop_in_private_format(u, mode, name, "TimerSlackNSec=" NSEC_FMT "\n", n);
1216                 }
1217
1218                 return 1;
1219
1220         } else if (streq(name, "OOMScoreAdjust")) {
1221                 int oa;
1222
1223                 r = sd_bus_message_read(message, "i", &oa);
1224                 if (r < 0)
1225                         return r;
1226
1227                 if (!oom_score_adjust_is_valid(oa))
1228                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "OOM score adjust value out of range");
1229
1230                 if (mode != UNIT_CHECK) {
1231                         c->oom_score_adjust = oa;
1232                         c->oom_score_adjust_set = true;
1233                         unit_write_drop_in_private_format(u, mode, name, "OOMScoreAdjust=%i\n", oa);
1234                 }
1235
1236                 return 1;
1237
1238         } else if (streq(name, "EnvironmentFiles")) {
1239
1240                 _cleanup_free_ char *joined = NULL;
1241                 _cleanup_fclose_ FILE *f = NULL;
1242                 _cleanup_free_ char **l = NULL;
1243                 size_t size = 0;
1244                 char **i;
1245
1246                 r = sd_bus_message_enter_container(message, 'a', "(sb)");
1247                 if (r < 0)
1248                         return r;
1249
1250                 f = open_memstream(&joined, &size);
1251                 if (!f)
1252                         return -ENOMEM;
1253
1254                 STRV_FOREACH(i, c->environment_files)
1255                         fprintf(f, "EnvironmentFile=%s\n", *i);
1256
1257                 while ((r = sd_bus_message_enter_container(message, 'r', "sb")) > 0) {
1258                         const char *path;
1259                         int b;
1260
1261                         r = sd_bus_message_read(message, "sb", &path, &b);
1262                         if (r < 0)
1263                                 return r;
1264
1265                         r = sd_bus_message_exit_container(message);
1266                         if (r < 0)
1267                                 return r;
1268
1269                         if (!isempty(path) && !path_is_absolute(path))
1270                                 return sd_bus_error_set_errnof(error, EINVAL, "Path %s is not absolute.", path);
1271
1272                         if (mode != UNIT_CHECK) {
1273                                 char *buf = NULL;
1274
1275                                 buf = strjoin(b ? "-" : "", path, NULL);
1276                                 if (!buf)
1277                                         return -ENOMEM;
1278
1279                                 fprintf(f, "EnvironmentFile=%s\n", buf);
1280
1281                                 r = strv_consume(&l, buf);
1282                                 if (r < 0)
1283                                         return r;
1284                         }
1285                 }
1286                 if (r < 0)
1287                         return r;
1288
1289                 r = sd_bus_message_exit_container(message);
1290                 if (r < 0)
1291                         return r;
1292
1293                 r = fflush_and_check(f);
1294                 if (r < 0)
1295                         return r;
1296
1297                 if (mode != UNIT_CHECK) {
1298                         if (strv_isempty(l)) {
1299                                 c->environment_files = strv_free(c->environment_files);
1300                                 unit_write_drop_in_private(u, mode, name, "EnvironmentFile=\n");
1301                         } else {
1302                                 r = strv_extend_strv(&c->environment_files, l, true);
1303                                 if (r < 0)
1304                                         return r;
1305
1306                                 unit_write_drop_in_private(u, mode, name, joined);
1307                         }
1308                 }
1309
1310                 return 1;
1311
1312         } else if (streq(name, "PassEnvironment")) {
1313
1314                 _cleanup_strv_free_ char **l = NULL;
1315
1316                 r = sd_bus_message_read_strv(message, &l);
1317                 if (r < 0)
1318                         return r;
1319
1320                 if (!strv_env_name_is_valid(l))
1321                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PassEnvironment block.");
1322
1323                 if (mode != UNIT_CHECK) {
1324                         if (strv_isempty(l)) {
1325                                 c->pass_environment = strv_free(c->pass_environment);
1326                                 unit_write_drop_in_private_format(u, mode, name, "PassEnvironment=\n");
1327                         } else {
1328                                 _cleanup_free_ char *joined = NULL;
1329
1330                                 r = strv_extend_strv(&c->pass_environment, l, true);
1331                                 if (r < 0)
1332                                         return r;
1333
1334                                 joined = strv_join_quoted(c->pass_environment);
1335                                 if (!joined)
1336                                         return -ENOMEM;
1337
1338                                 unit_write_drop_in_private_format(u, mode, name, "PassEnvironment=%s\n", joined);
1339                         }
1340                 }
1341
1342                 return 1;
1343
1344         } else if (STR_IN_SET(name, "ReadWriteDirectories", "ReadOnlyDirectories", "InaccessibleDirectories")) {
1345
1346                 _cleanup_strv_free_ char **l = NULL;
1347                 char ***dirs;
1348                 char **p;
1349
1350                 r = sd_bus_message_read_strv(message, &l);
1351                 if (r < 0)
1352                         return r;
1353
1354                 STRV_FOREACH(p, l) {
1355                         int offset;
1356                         if (!utf8_is_valid(*p))
1357                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s", name);
1358
1359                         offset = **p == '-';
1360                         if (!path_is_absolute(*p + offset))
1361                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid %s", name);
1362                 }
1363
1364                 if (mode != UNIT_CHECK) {
1365                         _cleanup_free_ char *joined = NULL;
1366
1367                         if (streq(name, "ReadWriteDirectories"))
1368                                 dirs = &c->read_write_dirs;
1369                         else if (streq(name, "ReadOnlyDirectories"))
1370                                 dirs = &c->read_only_dirs;
1371                         else /* "InaccessibleDirectories" */
1372                                 dirs = &c->inaccessible_dirs;
1373
1374                         if (strv_length(l) == 0) {
1375                                 *dirs = strv_free(*dirs);
1376                                 unit_write_drop_in_private_format(u, mode, name, "%s=\n", name);
1377                         } else {
1378                                 r = strv_extend_strv(dirs, l, true);
1379
1380                                 if (r < 0)
1381                                         return -ENOMEM;
1382
1383                                 joined = strv_join_quoted(*dirs);
1384                                 if (!joined)
1385                                         return -ENOMEM;
1386
1387                                 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, joined);
1388                         }
1389
1390                 }
1391
1392                 return 1;
1393
1394         } else if (streq(name, "ProtectSystem")) {
1395                 const char *s;
1396                 ProtectSystem ps;
1397
1398                 r = sd_bus_message_read(message, "s", &s);
1399                 if (r < 0)
1400                         return r;
1401
1402                 r = parse_boolean(s);
1403                 if (r > 0)
1404                         ps = PROTECT_SYSTEM_YES;
1405                 else if (r == 0)
1406                         ps = PROTECT_SYSTEM_NO;
1407                 else {
1408                         ps = protect_system_from_string(s);
1409                         if (ps < 0)
1410                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Failed to parse protect system value");
1411                 }
1412
1413                 if (mode != UNIT_CHECK) {
1414                         c->protect_system = ps;
1415                         unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, s);
1416                 }
1417
1418                 return 1;
1419
1420         } else if (streq(name, "ProtectHome")) {
1421                 const char *s;
1422                 ProtectHome ph;
1423
1424                 r = sd_bus_message_read(message, "s", &s);
1425                 if (r < 0)
1426                         return r;
1427
1428                 r = parse_boolean(s);
1429                 if (r > 0)
1430                         ph = PROTECT_HOME_YES;
1431                 else if (r == 0)
1432                         ph = PROTECT_HOME_NO;
1433                 else {
1434                         ph = protect_home_from_string(s);
1435                         if (ph < 0)
1436                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Failed to parse protect home value");
1437                 }
1438
1439                 if (mode != UNIT_CHECK) {
1440                         c->protect_home = ph;
1441                         unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, s);
1442                 }
1443
1444                 return 1;
1445
1446         } else if (streq(name, "RuntimeDirectory")) {
1447                 _cleanup_strv_free_ char **l = NULL;
1448                 char **p;
1449
1450                 r = sd_bus_message_read_strv(message, &l);
1451                 if (r < 0)
1452                         return r;
1453
1454                 STRV_FOREACH(p, l) {
1455                         if (!filename_is_valid(*p))
1456                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Runtime directory is not valid %s", *p);
1457                 }
1458
1459                 if (mode != UNIT_CHECK) {
1460                         _cleanup_free_ char *joined = NULL;
1461
1462                         if (strv_isempty(l)) {
1463                                 c->runtime_directory = strv_free(c->runtime_directory);
1464                                 unit_write_drop_in_private_format(u, mode, name, "%s=\n", name);
1465                         } else {
1466                                 r = strv_extend_strv(&c->runtime_directory, l, true);
1467
1468                                 if (r < 0)
1469                                         return -ENOMEM;
1470
1471                                 joined = strv_join_quoted(c->runtime_directory);
1472                                 if (!joined)
1473                                         return -ENOMEM;
1474
1475                                 unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, joined);
1476                         }
1477                 }
1478
1479                 return 1;
1480
1481         }
1482
1483         ri = rlimit_from_string(name);
1484         if (ri < 0) {
1485                 soft = endswith(name, "Soft");
1486                 if (soft) {
1487                         const char *n;
1488
1489                         n = strndupa(name, soft - name);
1490                         ri = rlimit_from_string(n);
1491                         if (ri >= 0)
1492                                 name = n;
1493
1494                 }
1495         }
1496
1497         if (ri >= 0) {
1498                 uint64_t rl;
1499                 rlim_t x;
1500
1501                 r = sd_bus_message_read(message, "t", &rl);
1502                 if (r < 0)
1503                         return r;
1504
1505                 if (rl == (uint64_t) -1)
1506                         x = RLIM_INFINITY;
1507                 else {
1508                         x = (rlim_t) rl;
1509
1510                         if ((uint64_t) x != rl)
1511                                 return -ERANGE;
1512                 }
1513
1514                 if (mode != UNIT_CHECK) {
1515                         _cleanup_free_ char *f = NULL;
1516                         struct rlimit nl;
1517
1518                         if (c->rlimit[ri]) {
1519                                 nl = *c->rlimit[ri];
1520
1521                                 if (soft)
1522                                         nl.rlim_cur = x;
1523                                 else
1524                                         nl.rlim_max = x;
1525                         } else
1526                                 /* When the resource limit is not initialized yet, then assign the value to both fields */
1527                                 nl = (struct rlimit) {
1528                                         .rlim_cur = x,
1529                                         .rlim_max = x,
1530                                 };
1531
1532                         r = rlimit_format(&nl, &f);
1533                         if (r < 0)
1534                                 return r;
1535
1536                         if (c->rlimit[ri])
1537                                 *c->rlimit[ri] = nl;
1538                         else {
1539                                 c->rlimit[ri] = newdup(struct rlimit, &nl, 1);
1540                                 if (!c->rlimit[ri])
1541                                         return -ENOMEM;
1542                         }
1543
1544                         unit_write_drop_in_private_format(u, mode, name, "%s=%s\n", name, f);
1545                 }
1546
1547                 return 1;
1548         }
1549
1550         return 0;
1551 }