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