src/shared/bus-unit-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "bus-error.h"
   5 #include "bus-unit-util.h"
   6 #include "bus-util.h"
   7 #include "cap-list.h"
   8 #include "cgroup-setup.h"
   9 #include "cgroup-util.h"
  10 #include "condition.h"
  11 #include "cpu-set-util.h"
  12 #include "escape.h"
  13 #include "exec-util.h"
  14 #include "exit-status.h"
  15 #include "hexdecoct.h"
  16 #include "hostname-util.h"
  17 #include "in-addr-util.h"
  18 #include "ip-protocol-list.h"
  19 #include "locale-util.h"
  20 #include "log.h"
  21 #include "missing_fs.h"
  22 #include "mountpoint-util.h"
  23 #include "nsflags.h"
  24 #include "parse-util.h"
  25 #include "process-util.h"
  26 #include "rlimit-util.h"
  27 #include "securebits-util.h"
  28 #include "signal-util.h"
  29 #include "socket-util.h"
  30 #include "sort-util.h"
  31 #include "string-util.h"
  32 #include "syslog-util.h"
  33 #include "terminal-util.h"
  34 #include "unit-def.h"
  35 #include "user-util.h"
  36 #include "utf8.h"
  37
  38 int bus_parse_unit_info(sd_bus_message *message, UnitInfo *u) {
  39         assert(message);
  40         assert(u);
  41
  42         u->machine = NULL;
  43
  44         return sd_bus_message_read(
  45                         message,
  46                         "(ssssssouso)",
  47                         &u->id,
  48                         &u->description,
  49                         &u->load_state,
  50                         &u->active_state,
  51                         &u->sub_state,
  52                         &u->following,
  53                         &u->unit_path,
  54                         &u->job_id,
  55                         &u->job_type,
  56                         &u->job_path);
  57 }
  58
  59 #define DEFINE_BUS_APPEND_PARSE_PTR(bus_type, cast_type, type, parse_func) \
  60         static int bus_append_##parse_func(                             \
  61                         sd_bus_message *m,                              \
  62                         const char *field,                              \
  63                         const char *eq) {                               \
  64                 type val;                                               \
  65                 int r;                                                  \
  66                                                                         \
  67                 r = parse_func(eq, &val);                               \
  68                 if (r < 0)                                              \
  69                         return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq); \
  70                                                                         \
  71                 r = sd_bus_message_append(m, "(sv)", field,             \
  72                                           bus_type, (cast_type) val);   \
  73                 if (r < 0)                                              \
  74                         return bus_log_create_error(r);                 \
  75                                                                         \
  76                 return 1;                                               \
  77         }
  78
  79 #define DEFINE_BUS_APPEND_PARSE(bus_type, parse_func)                   \
  80         static int bus_append_##parse_func(                             \
  81                         sd_bus_message *m,                              \
  82                         const char *field,                              \
  83                         const char *eq) {                               \
  84                 int r;                                                  \
  85                                                                         \
  86                 r = parse_func(eq);                                     \
  87                 if (r < 0)                                              \
  88                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse %s: %s", field, eq);                                 \
  89                                                                         \
  90                 r = sd_bus_message_append(m, "(sv)", field,             \
  91                                           bus_type, (int32_t) r);       \
  92                 if (r < 0)                                              \
  93                         return bus_log_create_error(r);                 \
  94                                                                         \
  95                 return 1;                                               \
  96         }
  97
  98 DEFINE_BUS_APPEND_PARSE("b", parse_boolean);
  99 DEFINE_BUS_APPEND_PARSE("i", ioprio_class_from_string);
 100 DEFINE_BUS_APPEND_PARSE("i", ip_tos_from_string);
 101 DEFINE_BUS_APPEND_PARSE("i", log_facility_unshifted_from_string);
 102 DEFINE_BUS_APPEND_PARSE("i", log_level_from_string);
 103 DEFINE_BUS_APPEND_PARSE("i", parse_errno);
 104 DEFINE_BUS_APPEND_PARSE("i", sched_policy_from_string);
 105 DEFINE_BUS_APPEND_PARSE("i", secure_bits_from_string);
 106 DEFINE_BUS_APPEND_PARSE("i", signal_from_string);
 107 DEFINE_BUS_APPEND_PARSE("i", parse_ip_protocol);
 108 DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, ioprio_parse_priority);
 109 DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, parse_nice);
 110 DEFINE_BUS_APPEND_PARSE_PTR("i", int32_t, int, safe_atoi);
 111 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, nsec_t, parse_nsec);
 112 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_blkio_weight_parse);
 113 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_cpu_shares_parse);
 114 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, cg_weight_parse);
 115 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, unsigned long, mount_propagation_flags_from_string);
 116 DEFINE_BUS_APPEND_PARSE_PTR("t", uint64_t, uint64_t, safe_atou64);
 117 DEFINE_BUS_APPEND_PARSE_PTR("u", uint32_t, mode_t, parse_mode);
 118 DEFINE_BUS_APPEND_PARSE_PTR("u", uint32_t, unsigned, safe_atou);
 119 DEFINE_BUS_APPEND_PARSE_PTR("x", int64_t, int64_t, safe_atoi64);
 120
 121 static int bus_append_string(sd_bus_message *m, const char *field, const char *eq) {
 122         int r;
 123
 124         r = sd_bus_message_append(m, "(sv)", field, "s", eq);
 125         if (r < 0)
 126                 return bus_log_create_error(r);
 127
 128         return 1;
 129 }
 130
 131 static int bus_append_strv(sd_bus_message *m, const char *field, const char *eq, ExtractFlags flags) {
 132         const char *p;
 133         int r;
 134
 135         r = sd_bus_message_open_container(m, 'r', "sv");
 136         if (r < 0)
 137                 return bus_log_create_error(r);
 138
 139         r = sd_bus_message_append_basic(m, 's', field);
 140         if (r < 0)
 141                 return bus_log_create_error(r);
 142
 143         r = sd_bus_message_open_container(m, 'v', "as");
 144         if (r < 0)
 145                 return bus_log_create_error(r);
 146
 147         r = sd_bus_message_open_container(m, 'a', "s");
 148         if (r < 0)
 149                 return bus_log_create_error(r);
 150
 151         for (p = eq;;) {
 152                 _cleanup_free_ char *word = NULL;
 153
 154                 r = extract_first_word(&p, &word, NULL, flags);
 155                 if (r == 0)
 156                         break;
 157                 if (r == -ENOMEM)
 158                         return log_oom();
 159                 if (r < 0)
 160                         return log_error_errno(r, "Invalid syntax: %s", eq);
 161
 162                 r = sd_bus_message_append_basic(m, 's', word);
 163                 if (r < 0)
 164                         return bus_log_create_error(r);
 165         }
 166
 167         r = sd_bus_message_close_container(m);
 168         if (r < 0)
 169                 return bus_log_create_error(r);
 170
 171         r = sd_bus_message_close_container(m);
 172         if (r < 0)
 173                 return bus_log_create_error(r);
 174
 175         r = sd_bus_message_close_container(m);
 176         if (r < 0)
 177                 return bus_log_create_error(r);
 178
 179         return 1;
 180 }
 181
 182 static int bus_append_byte_array(sd_bus_message *m, const char *field, const void *buf, size_t n) {
 183         int r;
 184
 185         r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
 186         if (r < 0)
 187                 return bus_log_create_error(r);
 188
 189         r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
 190         if (r < 0)
 191                 return bus_log_create_error(r);
 192
 193         r = sd_bus_message_open_container(m, 'v', "ay");
 194         if (r < 0)
 195                 return bus_log_create_error(r);
 196
 197         r = sd_bus_message_append_array(m, 'y', buf, n);
 198         if (r < 0)
 199                 return bus_log_create_error(r);
 200
 201         r = sd_bus_message_close_container(m);
 202         if (r < 0)
 203                 return bus_log_create_error(r);
 204
 205         r = sd_bus_message_close_container(m);
 206         if (r < 0)
 207                 return bus_log_create_error(r);
 208
 209         return 1;
 210 }
 211
 212 static int bus_append_parse_sec_rename(sd_bus_message *m, const char *field, const char *eq) {
 213         char *n;
 214         usec_t t;
 215         size_t l;
 216         int r;
 217
 218         r = parse_sec(eq, &t);
 219         if (r < 0)
 220                 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq);
 221
 222         l = strlen(field);
 223         n = newa(char, l + 2);
 224         /* Change suffix Sec → USec */
 225         strcpy(mempcpy(n, field, l - 3), "USec");
 226
 227         r = sd_bus_message_append(m, "(sv)", n, "t", t);
 228         if (r < 0)
 229                 return bus_log_create_error(r);
 230
 231         return 1;
 232 }
 233
 234 static int bus_append_parse_size(sd_bus_message *m, const char *field, const char *eq, uint64_t base) {
 235         uint64_t v;
 236         int r;
 237
 238         r = parse_size(eq, base, &v);
 239         if (r < 0)
 240                 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq);
 241
 242         r = sd_bus_message_append(m, "(sv)", field, "t", v);
 243         if (r < 0)
 244                 return bus_log_create_error(r);
 245
 246         return 1;
 247 }
 248
 249 static int bus_append_exec_command(sd_bus_message *m, const char *field, const char *eq) {
 250         bool explicit_path = false, done = false;
 251         _cleanup_strv_free_ char **l = NULL, **ex_opts = NULL;
 252         _cleanup_free_ char *path = NULL, *upgraded_name = NULL;
 253         ExecCommandFlags flags = 0;
 254         bool is_ex_prop = endswith(field, "Ex");
 255         int r;
 256
 257         do {
 258                 switch (*eq) {
 259
 260                 case '-':
 261                         if (FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE))
 262                                 done = true;
 263                         else {
 264                                 flags |= EXEC_COMMAND_IGNORE_FAILURE;
 265                                 eq++;
 266                         }
 267                         break;
 268
 269                 case '@':
 270                         if (explicit_path)
 271                                 done = true;
 272                         else {
 273                                 explicit_path = true;
 274                                 eq++;
 275                         }
 276                         break;
 277
 278                 case ':':
 279                         if (FLAGS_SET(flags, EXEC_COMMAND_NO_ENV_EXPAND))
 280                                 done = true;
 281                         else {
 282                                 flags |= EXEC_COMMAND_NO_ENV_EXPAND;
 283                                 eq++;
 284                         }
 285                         break;
 286
 287                 case '+':
 288                         if (flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC))
 289                                 done = true;
 290                         else {
 291                                 flags |= EXEC_COMMAND_FULLY_PRIVILEGED;
 292                                 eq++;
 293                         }
 294                         break;
 295
 296                 case '!':
 297                         if (flags & (EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_AMBIENT_MAGIC))
 298                                 done = true;
 299                         else if (FLAGS_SET(flags, EXEC_COMMAND_NO_SETUID)) {
 300                                 flags &= ~EXEC_COMMAND_NO_SETUID;
 301                                 flags |= EXEC_COMMAND_AMBIENT_MAGIC;
 302                                 eq++;
 303                         } else {
 304                                 flags |= EXEC_COMMAND_NO_SETUID;
 305                                 eq++;
 306                         }
 307                         break;
 308
 309                 default:
 310                         done = true;
 311                         break;
 312                 }
 313         } while (!done);
 314
 315         if (!is_ex_prop && (flags & (EXEC_COMMAND_NO_ENV_EXPAND|EXEC_COMMAND_FULLY_PRIVILEGED|EXEC_COMMAND_NO_SETUID|EXEC_COMMAND_AMBIENT_MAGIC))) {
 316                 /* Upgrade the ExecXYZ= property to ExecXYZEx= for convenience */
 317                 is_ex_prop = true;
 318                 upgraded_name = strjoin(field, "Ex");
 319                 if (!upgraded_name)
 320                         return log_oom();
 321         }
 322
 323         if (is_ex_prop) {
 324                 r = exec_command_flags_to_strv(flags, &ex_opts);
 325                 if (r < 0)
 326                         return log_error_errno(r, "Failed to convert ExecCommandFlags to strv: %m");
 327         }
 328
 329         if (explicit_path) {
 330                 r = extract_first_word(&eq, &path, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
 331                 if (r < 0)
 332                         return log_error_errno(r, "Failed to parse path: %m");
 333         }
 334
 335         r = strv_split_extract(&l, eq, NULL, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
 336         if (r < 0)
 337                 return log_error_errno(r, "Failed to parse command line: %m");
 338
 339         r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
 340         if (r < 0)
 341                 return bus_log_create_error(r);
 342
 343         r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, upgraded_name ?: field);
 344         if (r < 0)
 345                 return bus_log_create_error(r);
 346
 347         r = sd_bus_message_open_container(m, 'v', is_ex_prop ? "a(sasas)" : "a(sasb)");
 348         if (r < 0)
 349                 return bus_log_create_error(r);
 350
 351         r = sd_bus_message_open_container(m, 'a', is_ex_prop ? "(sasas)" : "(sasb)");
 352         if (r < 0)
 353                 return bus_log_create_error(r);
 354
 355         if (!strv_isempty(l)) {
 356
 357                 r = sd_bus_message_open_container(m, 'r', is_ex_prop ? "sasas" : "sasb");
 358                 if (r < 0)
 359                         return bus_log_create_error(r);
 360
 361                 r = sd_bus_message_append(m, "s", path ?: l[0]);
 362                 if (r < 0)
 363                         return bus_log_create_error(r);
 364
 365                 r = sd_bus_message_append_strv(m, l);
 366                 if (r < 0)
 367                         return bus_log_create_error(r);
 368
 369                 r = is_ex_prop ? sd_bus_message_append_strv(m, ex_opts) : sd_bus_message_append(m, "b", FLAGS_SET(flags, EXEC_COMMAND_IGNORE_FAILURE));
 370                 if (r < 0)
 371                         return bus_log_create_error(r);
 372
 373                 r = sd_bus_message_close_container(m);
 374                 if (r < 0)
 375                         return bus_log_create_error(r);
 376         }
 377
 378         r = sd_bus_message_close_container(m);
 379         if (r < 0)
 380                 return bus_log_create_error(r);
 381
 382         r = sd_bus_message_close_container(m);
 383         if (r < 0)
 384                 return bus_log_create_error(r);
 385
 386         r = sd_bus_message_close_container(m);
 387         if (r < 0)
 388                 return bus_log_create_error(r);
 389
 390         return 1;
 391 }
 392
 393 static int bus_append_ip_address_access(sd_bus_message *m, int family, const union in_addr_union *prefix, unsigned char prefixlen) {
 394         int r;
 395
 396         assert(m);
 397         assert(prefix);
 398
 399         r = sd_bus_message_open_container(m, 'r', "iayu");
 400         if (r < 0)
 401                 return r;
 402
 403         r = sd_bus_message_append(m, "i", family);
 404         if (r < 0)
 405                 return r;
 406
 407         r = sd_bus_message_append_array(m, 'y', prefix, FAMILY_ADDRESS_SIZE(family));
 408         if (r < 0)
 409                 return r;
 410
 411         r = sd_bus_message_append(m, "u", prefixlen);
 412         if (r < 0)
 413                 return r;
 414
 415         return sd_bus_message_close_container(m);
 416 }
 417
 418 static int bus_append_cgroup_property(sd_bus_message *m, const char *field, const char *eq) {
 419         int r;
 420
 421         if (STR_IN_SET(field, "DevicePolicy", "Slice"))
 422                 return bus_append_string(m, field, eq);
 423
 424         if (STR_IN_SET(field,
 425                        "CPUAccounting", "MemoryAccounting", "IOAccounting", "BlockIOAccounting",
 426                        "TasksAccounting", "IPAccounting"))
 427                 return bus_append_parse_boolean(m, field, eq);
 428
 429         if (STR_IN_SET(field, "CPUWeight", "StartupCPUWeight", "IOWeight", "StartupIOWeight"))
 430                 return bus_append_cg_weight_parse(m, field, eq);
 431
 432         if (STR_IN_SET(field, "CPUShares", "StartupCPUShares"))
 433                 return bus_append_cg_cpu_shares_parse(m, field, eq);
 434
 435         if (STR_IN_SET(field, "AllowedCPUs", "AllowedMemoryNodes")) {
 436                 _cleanup_(cpu_set_reset) CPUSet cpuset = {};
 437                 _cleanup_free_ uint8_t *array = NULL;
 438                 size_t allocated;
 439
 440                 r = parse_cpu_set(eq, &cpuset);
 441                 if (r < 0)
 442                         return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
 443
 444                 r = cpu_set_to_dbus(&cpuset, &array, &allocated);
 445                 if (r < 0)
 446                         return log_error_errno(r, "Failed to serialize CPUSet: %m");
 447
 448                 return bus_append_byte_array(m, field, array, allocated);
 449         }
 450
 451         if (STR_IN_SET(field, "BlockIOWeight", "StartupBlockIOWeight"))
 452                 return bus_append_cg_blkio_weight_parse(m, field, eq);
 453
 454         if (streq(field, "DisableControllers"))
 455                 return bus_append_strv(m, "DisableControllers", eq, EXTRACT_UNQUOTE);
 456
 457         if (streq(field, "Delegate")) {
 458                 r = parse_boolean(eq);
 459                 if (r < 0)
 460                         return bus_append_strv(m, "DelegateControllers", eq, EXTRACT_UNQUOTE);
 461
 462                 r = sd_bus_message_append(m, "(sv)", "Delegate", "b", r);
 463                 if (r < 0)
 464                         return bus_log_create_error(r);
 465
 466                 return 1;
 467         }
 468
 469         if (STR_IN_SET(field, "MemoryMin",
 470                               "DefaultMemoryLow",
 471                               "DefaultMemoryMin",
 472                               "MemoryLow",
 473                               "MemoryHigh",
 474                               "MemoryMax",
 475                               "MemorySwapMax",
 476                               "MemoryLimit",
 477                               "TasksMax")) {
 478
 479                 if (isempty(eq) || streq(eq, "infinity")) {
 480                         r = sd_bus_message_append(m, "(sv)", field, "t", CGROUP_LIMIT_MAX);
 481                         if (r < 0)
 482                                 return bus_log_create_error(r);
 483                         return 1;
 484                 }
 485
 486                 r = parse_permille(eq);
 487                 if (r >= 0) {
 488                         char *n;
 489
 490                         /* When this is a percentage we'll convert this into a relative value in the range 0…UINT32_MAX
 491                          * and pass it in the MemoryLowScale property (and related ones). This way the physical memory
 492                          * size can be determined server-side. */
 493
 494                         n = strjoina(field, "Scale");
 495                         r = sd_bus_message_append(m, "(sv)", n, "u", (uint32_t) (((uint64_t) r * UINT32_MAX) / 1000U));
 496                         if (r < 0)
 497                                 return bus_log_create_error(r);
 498
 499                         return 1;
 500                 }
 501
 502                 if (streq(field, "TasksMax"))
 503                         return bus_append_safe_atou64(m, field, eq);
 504
 505                 return bus_append_parse_size(m, field, eq, 1024);
 506         }
 507
 508         if (streq(field, "CPUQuota")) {
 509                 if (isempty(eq))
 510                         r = sd_bus_message_append(m, "(sv)", "CPUQuotaPerSecUSec", "t", USEC_INFINITY);
 511                 else {
 512                         r = parse_permille_unbounded(eq);
 513                         if (r == 0)
 514                                 return log_error_errno(SYNTHETIC_ERRNO(ERANGE),
 515                                                        "CPU quota too small.");
 516                         if (r < 0)
 517                                 return log_error_errno(r, "CPU quota '%s' invalid.", eq);
 518
 519                         r = sd_bus_message_append(m, "(sv)", "CPUQuotaPerSecUSec", "t", (((uint64_t) r * USEC_PER_SEC) / 1000U));
 520                 }
 521
 522                 if (r < 0)
 523                         return bus_log_create_error(r);
 524
 525                 return 1;
 526         }
 527
 528         if (streq(field, "CPUQuotaPeriodSec")) {
 529                 usec_t u = USEC_INFINITY;
 530
 531                 r = parse_sec_def_infinity(eq, &u);
 532                 if (r < 0)
 533                         return log_error_errno(r, "CPU quota period '%s' invalid.", eq);
 534
 535                 r = sd_bus_message_append(m, "(sv)", "CPUQuotaPeriodUSec", "t", u);
 536                 if (r < 0)
 537                         return bus_log_create_error(r);
 538
 539                 return 1;
 540         }
 541
 542         if (streq(field, "DeviceAllow")) {
 543                 if (isempty(eq))
 544                         r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 0);
 545                 else {
 546                         const char *path = eq, *rwm = NULL, *e;
 547
 548                         e = strchr(eq, ' ');
 549                         if (e) {
 550                                 path = strndupa(eq, e - eq);
 551                                 rwm = e+1;
 552                         }
 553
 554                         r = sd_bus_message_append(m, "(sv)", field, "a(ss)", 1, path, strempty(rwm));
 555                 }
 556
 557                 if (r < 0)
 558                         return bus_log_create_error(r);
 559
 560                 return 1;
 561         }
 562
 563         if (cgroup_io_limit_type_from_string(field) >= 0 || STR_IN_SET(field, "BlockIOReadBandwidth", "BlockIOWriteBandwidth")) {
 564                 if (isempty(eq))
 565                         r = sd_bus_message_append(m, "(sv)", field, "a(st)", 0);
 566                 else {
 567                         const char *path, *bandwidth, *e;
 568                         uint64_t bytes;
 569
 570                         e = strchr(eq, ' ');
 571                         if (!e)
 572                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 573                                                        "Failed to parse %s value %s.",
 574                                                        field, eq);
 575
 576                         path = strndupa(eq, e - eq);
 577                         bandwidth = e+1;
 578
 579                         if (streq(bandwidth, "infinity"))
 580                                 bytes = CGROUP_LIMIT_MAX;
 581                         else {
 582                                 r = parse_size(bandwidth, 1000, &bytes);
 583                                 if (r < 0)
 584                                         return log_error_errno(r, "Failed to parse byte value %s: %m", bandwidth);
 585                         }
 586
 587                         r = sd_bus_message_append(m, "(sv)", field, "a(st)", 1, path, bytes);
 588                 }
 589
 590                 if (r < 0)
 591                         return bus_log_create_error(r);
 592
 593                 return 1;
 594         }
 595
 596         if (STR_IN_SET(field, "IODeviceWeight", "BlockIODeviceWeight")) {
 597                 if (isempty(eq))
 598                         r = sd_bus_message_append(m, "(sv)", field, "a(st)", 0);
 599                 else {
 600                         const char *path, *weight, *e;
 601                         uint64_t u;
 602
 603                         e = strchr(eq, ' ');
 604                         if (!e)
 605                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 606                                                        "Failed to parse %s value %s.",
 607                                                        field, eq);
 608
 609                         path = strndupa(eq, e - eq);
 610                         weight = e+1;
 611
 612                         r = safe_atou64(weight, &u);
 613                         if (r < 0)
 614                                 return log_error_errno(r, "Failed to parse %s value %s: %m", field, weight);
 615
 616                         r = sd_bus_message_append(m, "(sv)", field, "a(st)", 1, path, u);
 617                 }
 618
 619                 if (r < 0)
 620                         return bus_log_create_error(r);
 621
 622                 return 1;
 623         }
 624
 625         if (streq(field, "IODeviceLatencyTargetSec")) {
 626                 const char *field_usec = "IODeviceLatencyTargetUSec";
 627
 628                 if (isempty(eq))
 629                         r = sd_bus_message_append(m, "(sv)", field_usec, "a(st)", USEC_INFINITY);
 630                 else {
 631                         const char *path, *target, *e;
 632                         usec_t usec;
 633
 634                         e = strchr(eq, ' ');
 635                         if (!e)
 636                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 637                                                        "Failed to parse %s value %s.",
 638                                                        field, eq);
 639
 640                         path = strndupa(eq, e - eq);
 641                         target = e+1;
 642
 643                         r = parse_sec(target, &usec);
 644                         if (r < 0)
 645                                 return log_error_errno(r, "Failed to parse %s value %s: %m", field, target);
 646
 647                         r = sd_bus_message_append(m, "(sv)", field_usec, "a(st)", 1, path, usec);
 648                 }
 649
 650                 if (r < 0)
 651                         return bus_log_create_error(r);
 652
 653                 return 1;
 654         }
 655
 656         if (STR_IN_SET(field, "IPAddressAllow", "IPAddressDeny")) {
 657                 unsigned char prefixlen;
 658                 union in_addr_union prefix = {};
 659                 int family;
 660
 661                 if (isempty(eq)) {
 662                         r = sd_bus_message_append(m, "(sv)", field, "a(iayu)", 0);
 663                         if (r < 0)
 664                                 return bus_log_create_error(r);
 665
 666                         return 1;
 667                 }
 668
 669                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
 670                 if (r < 0)
 671                         return bus_log_create_error(r);
 672
 673                 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
 674                 if (r < 0)
 675                         return bus_log_create_error(r);
 676
 677                 r = sd_bus_message_open_container(m, 'v', "a(iayu)");
 678                 if (r < 0)
 679                         return bus_log_create_error(r);
 680
 681                 r = sd_bus_message_open_container(m, 'a', "(iayu)");
 682                 if (r < 0)
 683                         return bus_log_create_error(r);
 684
 685                 if (streq(eq, "any")) {
 686                         /* "any" is a shortcut for 0.0.0.0/0 and ::/0 */
 687
 688                         r = bus_append_ip_address_access(m, AF_INET, &prefix, 0);
 689                         if (r < 0)
 690                                 return bus_log_create_error(r);
 691
 692                         r = bus_append_ip_address_access(m, AF_INET6, &prefix, 0);
 693                         if (r < 0)
 694                                 return bus_log_create_error(r);
 695
 696                 } else if (is_localhost(eq)) {
 697                         /* "localhost" is a shortcut for 127.0.0.0/8 and ::1/128 */
 698
 699                         prefix.in.s_addr = htobe32(0x7f000000);
 700                         r = bus_append_ip_address_access(m, AF_INET, &prefix, 8);
 701                         if (r < 0)
 702                                 return bus_log_create_error(r);
 703
 704                         prefix.in6 = (struct in6_addr) IN6ADDR_LOOPBACK_INIT;
 705                         r = bus_append_ip_address_access(m, AF_INET6, &prefix, 128);
 706                         if (r < 0)
 707                                 return r;
 708
 709                 } else if (streq(eq, "link-local")) {
 710                         /* "link-local" is a shortcut for 169.254.0.0/16 and fe80::/64 */
 711
 712                         prefix.in.s_addr = htobe32((UINT32_C(169) << 24 | UINT32_C(254) << 16));
 713                         r = bus_append_ip_address_access(m, AF_INET, &prefix, 16);
 714                         if (r < 0)
 715                                 return bus_log_create_error(r);
 716
 717                         prefix.in6 = (struct in6_addr) {
 718                                 .s6_addr32[0] = htobe32(0xfe800000)
 719                         };
 720                         r = bus_append_ip_address_access(m, AF_INET6, &prefix, 64);
 721                         if (r < 0)
 722                                 return bus_log_create_error(r);
 723
 724                 } else if (streq(eq, "multicast")) {
 725                         /* "multicast" is a shortcut for 224.0.0.0/4 and ff00::/8 */
 726
 727                         prefix.in.s_addr = htobe32((UINT32_C(224) << 24));
 728                         r = bus_append_ip_address_access(m, AF_INET, &prefix, 4);
 729                         if (r < 0)
 730                                 return bus_log_create_error(r);
 731
 732                         prefix.in6 = (struct in6_addr) {
 733                                 .s6_addr32[0] = htobe32(0xff000000)
 734                         };
 735                         r = bus_append_ip_address_access(m, AF_INET6, &prefix, 8);
 736                         if (r < 0)
 737                                 return bus_log_create_error(r);
 738
 739                 } else {
 740                         for (;;) {
 741                                 _cleanup_free_ char *word = NULL;
 742
 743                                 r = extract_first_word(&eq, &word, NULL, 0);
 744                                 if (r == 0)
 745                                         break;
 746                                 if (r == -ENOMEM)
 747                                         return log_oom();
 748                                 if (r < 0)
 749                                         return log_error_errno(r, "Failed to parse %s: %s", field, eq);
 750
 751                                 r = in_addr_prefix_from_string_auto(word, &family, &prefix, &prefixlen);
 752                                 if (r < 0)
 753                                         return log_error_errno(r, "Failed to parse IP address prefix: %s", word);
 754
 755                                 r = bus_append_ip_address_access(m, family, &prefix, prefixlen);
 756                                 if (r < 0)
 757                                         return bus_log_create_error(r);
 758                         }
 759                 }
 760
 761                 r = sd_bus_message_close_container(m);
 762                 if (r < 0)
 763                         return bus_log_create_error(r);
 764
 765                 r = sd_bus_message_close_container(m);
 766                 if (r < 0)
 767                         return bus_log_create_error(r);
 768
 769                 r = sd_bus_message_close_container(m);
 770                 if (r < 0)
 771                         return bus_log_create_error(r);
 772
 773                 return 1;
 774         }
 775
 776         if (STR_IN_SET(field, "IPIngressFilterPath", "IPEgressFilterPath")) {
 777                 if (isempty(eq))
 778                         r = sd_bus_message_append(m, "(sv)", field, "as", 0);
 779                 else
 780                         r = sd_bus_message_append(m, "(sv)", field, "as", 1, eq);
 781
 782                 if (r < 0)
 783                         return bus_log_create_error(r);
 784
 785                 return 1;
 786         }
 787
 788         return 0;
 789 }
 790
 791 static int bus_append_automount_property(sd_bus_message *m, const char *field, const char *eq) {
 792         if (streq(field, "Where"))
 793                 return bus_append_string(m, field, eq);
 794
 795         if (streq(field, "DirectoryMode"))
 796                 return bus_append_parse_mode(m, field, eq);
 797
 798         if (streq(field, "TimeoutIdleSec"))
 799                 return bus_append_parse_sec_rename(m, field, eq);
 800
 801         return 0;
 802 }
 803
 804 static int bus_append_execute_property(sd_bus_message *m, const char *field, const char *eq) {
 805         const char *suffix;
 806         int r;
 807
 808         if (STR_IN_SET(field,
 809                        "User", "Group",
 810                        "UtmpIdentifier", "UtmpMode", "PAMName", "TTYPath",
 811                        "WorkingDirectory", "RootDirectory", "SyslogIdentifier",
 812                        "ProtectSystem", "ProtectHome", "SELinuxContext", "RootImage",
 813                        "RuntimeDirectoryPreserve", "Personality", "KeyringMode", "NetworkNamespacePath"))
 814                 return bus_append_string(m, field, eq);
 815
 816         if (STR_IN_SET(field,
 817                        "IgnoreSIGPIPE", "TTYVHangup", "TTYReset", "TTYVTDisallocate", "PrivateTmp",
 818                        "PrivateDevices", "PrivateNetwork", "PrivateUsers", "PrivateMounts",
 819                        "NoNewPrivileges", "SyslogLevelPrefix", "MemoryDenyWriteExecute", "RestrictRealtime",
 820                        "DynamicUser", "RemoveIPC", "ProtectKernelTunables", "ProtectKernelModules",
 821                        "ProtectControlGroups", "MountAPIVFS", "CPUSchedulingResetOnFork", "LockPersonality",
 822                        "ProtectHostname", "RestrictSUIDSGID"))
 823                 return bus_append_parse_boolean(m, field, eq);
 824
 825         if (STR_IN_SET(field,
 826                        "ReadWriteDirectories", "ReadOnlyDirectories", "InaccessibleDirectories",
 827                        "ReadWritePaths", "ReadOnlyPaths", "InaccessiblePaths",
 828                        "RuntimeDirectory", "StateDirectory", "CacheDirectory", "LogsDirectory", "ConfigurationDirectory",
 829                        "SupplementaryGroups", "SystemCallArchitectures"))
 830                 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE);
 831
 832         if (STR_IN_SET(field, "SyslogLevel", "LogLevelMax"))
 833                 return bus_append_log_level_from_string(m, field, eq);
 834
 835         if (streq(field, "SyslogFacility"))
 836                 return bus_append_log_facility_unshifted_from_string(m, field, eq);
 837
 838         if (streq(field, "SecureBits"))
 839                 return bus_append_secure_bits_from_string(m, field, eq);
 840
 841         if (streq(field, "CPUSchedulingPolicy"))
 842                 return bus_append_sched_policy_from_string(m, field, eq);
 843
 844         if (STR_IN_SET(field, "CPUSchedulingPriority", "OOMScoreAdjust"))
 845                 return bus_append_safe_atoi(m, field, eq);
 846
 847         if (streq(field, "Nice"))
 848                 return bus_append_parse_nice(m, field, eq);
 849
 850         if (streq(field, "SystemCallErrorNumber"))
 851                 return bus_append_parse_errno(m, field, eq);
 852
 853         if (streq(field, "IOSchedulingClass"))
 854                 return bus_append_ioprio_class_from_string(m, field, eq);
 855
 856         if (streq(field, "IOSchedulingPriority"))
 857                 return bus_append_ioprio_parse_priority(m, field, eq);
 858
 859         if (STR_IN_SET(field,
 860                        "RuntimeDirectoryMode", "StateDirectoryMode", "CacheDirectoryMode",
 861                        "LogsDirectoryMode", "ConfigurationDirectoryMode", "UMask"))
 862                 return bus_append_parse_mode(m, field, eq);
 863
 864         if (streq(field, "TimerSlackNSec"))
 865                 return bus_append_parse_nsec(m, field, eq);
 866
 867         if (streq(field, "LogRateLimitIntervalSec"))
 868                 return bus_append_parse_sec_rename(m, field, eq);
 869
 870         if (streq(field, "LogRateLimitBurst"))
 871                 return bus_append_safe_atou(m, field, eq);
 872
 873         if (streq(field, "MountFlags"))
 874                 return bus_append_mount_propagation_flags_from_string(m, field, eq);
 875
 876         if (STR_IN_SET(field, "Environment", "UnsetEnvironment", "PassEnvironment"))
 877                 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE|EXTRACT_CUNESCAPE);
 878
 879         if (streq(field, "EnvironmentFile")) {
 880                 if (isempty(eq))
 881                         r = sd_bus_message_append(m, "(sv)", "EnvironmentFiles", "a(sb)", 0);
 882                 else
 883                         r = sd_bus_message_append(m, "(sv)", "EnvironmentFiles", "a(sb)", 1,
 884                                                   eq[0] == '-' ? eq + 1 : eq,
 885                                                   eq[0] == '-');
 886                 if (r < 0)
 887                         return bus_log_create_error(r);
 888
 889                 return 1;
 890         }
 891
 892         if (streq(field, "LogExtraFields")) {
 893                 r = sd_bus_message_open_container(m, 'r', "sv");
 894                 if (r < 0)
 895                         return bus_log_create_error(r);
 896
 897                 r = sd_bus_message_append_basic(m, 's', "LogExtraFields");
 898                 if (r < 0)
 899                         return bus_log_create_error(r);
 900
 901                 r = sd_bus_message_open_container(m, 'v', "aay");
 902                 if (r < 0)
 903                         return bus_log_create_error(r);
 904
 905                 r = sd_bus_message_open_container(m, 'a', "ay");
 906                 if (r < 0)
 907                         return bus_log_create_error(r);
 908
 909                 r = sd_bus_message_append_array(m, 'y', eq, strlen(eq));
 910                 if (r < 0)
 911                         return bus_log_create_error(r);
 912
 913                 r = sd_bus_message_close_container(m);
 914                 if (r < 0)
 915                         return bus_log_create_error(r);
 916
 917                 r = sd_bus_message_close_container(m);
 918                 if (r < 0)
 919                         return bus_log_create_error(r);
 920
 921                 r = sd_bus_message_close_container(m);
 922                 if (r < 0)
 923                         return bus_log_create_error(r);
 924
 925                 return 1;
 926         }
 927
 928         if (STR_IN_SET(field, "StandardInput", "StandardOutput", "StandardError")) {
 929                 const char *n, *appended;
 930
 931                 if ((n = startswith(eq, "fd:"))) {
 932                         appended = strjoina(field, "FileDescriptorName");
 933                         r = sd_bus_message_append(m, "(sv)", appended, "s", n);
 934                 } else if ((n = startswith(eq, "file:"))) {
 935                         appended = strjoina(field, "File");
 936                         r = sd_bus_message_append(m, "(sv)", appended, "s", n);
 937                 } else if ((n = startswith(eq, "append:"))) {
 938                         appended = strjoina(field, "FileToAppend");
 939                         r = sd_bus_message_append(m, "(sv)", appended, "s", n);
 940                 } else
 941                         r = sd_bus_message_append(m, "(sv)", field, "s", eq);
 942                 if (r < 0)
 943                         return bus_log_create_error(r);
 944
 945                 return 1;
 946         }
 947
 948         if (streq(field, "StandardInputText")) {
 949                 _cleanup_free_ char *unescaped = NULL;
 950
 951                 r = cunescape(eq, 0, &unescaped);
 952                 if (r < 0)
 953                         return log_error_errno(r, "Failed to unescape text '%s': %m", eq);
 954
 955                 if (!strextend(&unescaped, "\n", NULL))
 956                         return log_oom();
 957
 958                 /* Note that we don't expand specifiers here, but that should be OK, as this is a programmatic
 959                  * interface anyway */
 960
 961                 return bus_append_byte_array(m, field, unescaped, strlen(unescaped));
 962         }
 963
 964         if (streq(field, "StandardInputData")) {
 965                 _cleanup_free_ void *decoded = NULL;
 966                 size_t sz;
 967
 968                 r = unbase64mem(eq, (size_t) -1, &decoded, &sz);
 969                 if (r < 0)
 970                         return log_error_errno(r, "Failed to decode base64 data '%s': %m", eq);
 971
 972                 return bus_append_byte_array(m, field, decoded, sz);
 973         }
 974
 975         if ((suffix = startswith(field, "Limit"))) {
 976                 int rl;
 977
 978                 rl = rlimit_from_string(suffix);
 979                 if (rl >= 0) {
 980                         const char *sn;
 981                         struct rlimit l;
 982
 983                         r = rlimit_parse(rl, eq, &l);
 984                         if (r < 0)
 985                                 return log_error_errno(r, "Failed to parse resource limit: %s", eq);
 986
 987                         r = sd_bus_message_append(m, "(sv)", field, "t", l.rlim_max);
 988                         if (r < 0)
 989                                 return bus_log_create_error(r);
 990
 991                         sn = strjoina(field, "Soft");
 992                         r = sd_bus_message_append(m, "(sv)", sn, "t", l.rlim_cur);
 993                         if (r < 0)
 994                                 return bus_log_create_error(r);
 995
 996                         return 1;
 997                 }
 998         }
 999
1000         if (STR_IN_SET(field, "AppArmorProfile", "SmackProcessLabel")) {
1001                 int ignore = 0;
1002                 const char *s = eq;
1003
1004                 if (eq[0] == '-') {
1005                         ignore = 1;
1006                         s = eq + 1;
1007                 }
1008
1009                 r = sd_bus_message_append(m, "(sv)", field, "(bs)", ignore, s);
1010                 if (r < 0)
1011                         return bus_log_create_error(r);
1012
1013                 return 1;
1014         }
1015
1016         if (STR_IN_SET(field, "CapabilityBoundingSet", "AmbientCapabilities")) {
1017                 uint64_t sum = 0;
1018                 bool invert = false;
1019                 const char *p = eq;
1020
1021                 if (*p == '~') {
1022                         invert = true;
1023                         p++;
1024                 }
1025
1026                 r = capability_set_from_string(p, &sum);
1027                 if (r < 0)
1028                         return log_error_errno(r, "Failed to parse %s value %s: %m", field, eq);
1029
1030                 sum = invert ? ~sum : sum;
1031
1032                 r = sd_bus_message_append(m, "(sv)", field, "t", sum);
1033                 if (r < 0)
1034                         return bus_log_create_error(r);
1035
1036                 return 1;
1037         }
1038
1039         if (streq(field, "CPUAffinity")) {
1040                 _cleanup_(cpu_set_reset) CPUSet cpuset = {};
1041                 _cleanup_free_ uint8_t *array = NULL;
1042                 size_t allocated;
1043
1044                 r = parse_cpu_set(eq, &cpuset);
1045                 if (r < 0)
1046                         return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
1047
1048                 r = cpu_set_to_dbus(&cpuset, &array, &allocated);
1049                 if (r < 0)
1050                         return log_error_errno(r, "Failed to serialize CPUAffinity: %m");
1051
1052                 return bus_append_byte_array(m, field, array, allocated);
1053         }
1054
1055         if (streq(field, "NUMAPolicy")) {
1056                 r = mpol_from_string(eq);
1057                 if (r < 0)
1058                         return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
1059
1060                 r = sd_bus_message_append(m, "(sv)", field, "i", (int32_t) r);
1061                 if (r < 0)
1062                         return bus_log_create_error(r);
1063
1064                 return 1;
1065         }
1066
1067         if (streq(field, "NUMAMask")) {
1068                 _cleanup_(cpu_set_reset) CPUSet nodes = {};
1069                 _cleanup_free_ uint8_t *array = NULL;
1070                 size_t allocated;
1071
1072                 r = parse_cpu_set(eq, &nodes);
1073                 if (r < 0)
1074                         return log_error_errno(r, "Failed to parse %s value: %s", field, eq);
1075
1076                 r = cpu_set_to_dbus(&nodes, &array, &allocated);
1077                 if (r < 0)
1078                         return log_error_errno(r, "Failed to serialize NUMAMask: %m");
1079
1080                 return bus_append_byte_array(m, field, array, allocated);
1081         }
1082
1083         if (STR_IN_SET(field, "RestrictAddressFamilies", "SystemCallFilter")) {
1084                 int whitelist = 1;
1085                 const char *p = eq;
1086
1087                 if (*p == '~') {
1088                         whitelist = 0;
1089                         p++;
1090                 }
1091
1092                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1093                 if (r < 0)
1094                         return bus_log_create_error(r);
1095
1096                 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1097                 if (r < 0)
1098                         return bus_log_create_error(r);
1099
1100                 r = sd_bus_message_open_container(m, 'v', "(bas)");
1101                 if (r < 0)
1102                         return bus_log_create_error(r);
1103
1104                 r = sd_bus_message_open_container(m, 'r', "bas");
1105                 if (r < 0)
1106                         return bus_log_create_error(r);
1107
1108                 r = sd_bus_message_append_basic(m, 'b', &whitelist);
1109                 if (r < 0)
1110                         return bus_log_create_error(r);
1111
1112                 r = sd_bus_message_open_container(m, 'a', "s");
1113                 if (r < 0)
1114                         return bus_log_create_error(r);
1115
1116                 for (;;) {
1117                         _cleanup_free_ char *word = NULL;
1118
1119                         r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
1120                         if (r == 0)
1121                                 break;
1122                         if (r == -ENOMEM)
1123                                 return log_oom();
1124                         if (r < 0)
1125                                 return log_error_errno(r, "Invalid syntax: %s", eq);
1126
1127                         r = sd_bus_message_append_basic(m, 's', word);
1128                         if (r < 0)
1129                                 return bus_log_create_error(r);
1130                 }
1131
1132                 r = sd_bus_message_close_container(m);
1133                 if (r < 0)
1134                         return bus_log_create_error(r);
1135
1136                 r = sd_bus_message_close_container(m);
1137                 if (r < 0)
1138                         return bus_log_create_error(r);
1139
1140                 r = sd_bus_message_close_container(m);
1141                 if (r < 0)
1142                         return bus_log_create_error(r);
1143
1144                 r = sd_bus_message_close_container(m);
1145                 if (r < 0)
1146                         return bus_log_create_error(r);
1147
1148                 return 1;
1149         }
1150
1151         if (streq(field, "RestrictNamespaces")) {
1152                 bool invert = false;
1153                 unsigned long flags;
1154
1155                 r = parse_boolean(eq);
1156                 if (r > 0)
1157                         flags = 0;
1158                 else if (r == 0)
1159                         flags = NAMESPACE_FLAGS_ALL;
1160                 else {
1161                         if (eq[0] == '~') {
1162                                 invert = true;
1163                                 eq++;
1164                         }
1165
1166                         r = namespace_flags_from_string(eq, &flags);
1167                         if (r < 0)
1168                                 return log_error_errno(r, "Failed to parse %s value %s.", field, eq);
1169                 }
1170
1171                 if (invert)
1172                         flags = (~flags) & NAMESPACE_FLAGS_ALL;
1173
1174                 r = sd_bus_message_append(m, "(sv)", field, "t", (uint64_t) flags);
1175                 if (r < 0)
1176                         return bus_log_create_error(r);
1177
1178                 return 1;
1179         }
1180
1181         if (STR_IN_SET(field, "BindPaths", "BindReadOnlyPaths")) {
1182                 const char *p = eq;
1183
1184                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1185                 if (r < 0)
1186                         return bus_log_create_error(r);
1187
1188                 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1189                 if (r < 0)
1190                         return bus_log_create_error(r);
1191
1192                 r = sd_bus_message_open_container(m, 'v', "a(ssbt)");
1193                 if (r < 0)
1194                         return bus_log_create_error(r);
1195
1196                 r = sd_bus_message_open_container(m, 'a', "(ssbt)");
1197                 if (r < 0)
1198                         return bus_log_create_error(r);
1199
1200                 for (;;) {
1201                         _cleanup_free_ char *source = NULL, *destination = NULL;
1202                         char *s = NULL, *d = NULL;
1203                         bool ignore_enoent = false;
1204                         uint64_t flags = MS_REC;
1205
1206                         r = extract_first_word(&p, &source, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
1207                         if (r < 0)
1208                                 return log_error_errno(r, "Failed to parse argument: %m");
1209                         if (r == 0)
1210                                 break;
1211
1212                         s = source;
1213                         if (s[0] == '-') {
1214                                 ignore_enoent = true;
1215                                 s++;
1216                         }
1217
1218                         if (p && p[-1] == ':') {
1219                                 r = extract_first_word(&p, &destination, ":" WHITESPACE, EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS);
1220                                 if (r < 0)
1221                                         return log_error_errno(r, "Failed to parse argument: %m");
1222                                 if (r == 0)
1223                                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1224                                                                "Missing argument after ':': %s",
1225                                                                eq);
1226
1227                                 d = destination;
1228
1229                                 if (p && p[-1] == ':') {
1230                                         _cleanup_free_ char *options = NULL;
1231
1232                                         r = extract_first_word(&p, &options, NULL, EXTRACT_UNQUOTE);
1233                                         if (r < 0)
1234                                                 return log_error_errno(r, "Failed to parse argument: %m");
1235
1236                                         if (isempty(options) || streq(options, "rbind"))
1237                                                 flags = MS_REC;
1238                                         else if (streq(options, "norbind"))
1239                                                 flags = 0;
1240                                         else
1241                                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1242                                                                        "Unknown options: %s",
1243                                                                        eq);
1244                                 }
1245                         } else
1246                                 d = s;
1247
1248                         r = sd_bus_message_append(m, "(ssbt)", s, d, ignore_enoent, flags);
1249                         if (r < 0)
1250                                 return bus_log_create_error(r);
1251                 }
1252
1253                 r = sd_bus_message_close_container(m);
1254                 if (r < 0)
1255                         return bus_log_create_error(r);
1256
1257                 r = sd_bus_message_close_container(m);
1258                 if (r < 0)
1259                         return bus_log_create_error(r);
1260
1261                 r = sd_bus_message_close_container(m);
1262                 if (r < 0)
1263                         return bus_log_create_error(r);
1264
1265                 return 1;
1266         }
1267
1268         if (streq(field, "TemporaryFileSystem")) {
1269                 const char *p = eq;
1270
1271                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1272                 if (r < 0)
1273                         return bus_log_create_error(r);
1274
1275                 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1276                 if (r < 0)
1277                         return bus_log_create_error(r);
1278
1279                 r = sd_bus_message_open_container(m, 'v', "a(ss)");
1280                 if (r < 0)
1281                         return bus_log_create_error(r);
1282
1283                 r = sd_bus_message_open_container(m, 'a', "(ss)");
1284                 if (r < 0)
1285                         return bus_log_create_error(r);
1286
1287                 for (;;) {
1288                         _cleanup_free_ char *word = NULL, *path = NULL;
1289                         const char *w;
1290
1291                         r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
1292                         if (r < 0)
1293                                 return log_error_errno(r, "Failed to parse argument: %m");
1294                         if (r == 0)
1295                                 break;
1296
1297                         w = word;
1298                         r = extract_first_word(&w, &path, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1299                         if (r < 0)
1300                                 return log_error_errno(r, "Failed to parse argument: %m");
1301                         if (r == 0)
1302                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1303                                                        "Failed to parse argument: %s",
1304                                                        p);
1305
1306                         r = sd_bus_message_append(m, "(ss)", path, w);
1307                         if (r < 0)
1308                                 return bus_log_create_error(r);
1309                 }
1310
1311                 r = sd_bus_message_close_container(m);
1312                 if (r < 0)
1313                         return bus_log_create_error(r);
1314
1315                 r = sd_bus_message_close_container(m);
1316                 if (r < 0)
1317                         return bus_log_create_error(r);
1318
1319                 r = sd_bus_message_close_container(m);
1320                 if (r < 0)
1321                         return bus_log_create_error(r);
1322
1323                 return 1;
1324         }
1325
1326         return 0;
1327 }
1328
1329 static int bus_append_kill_property(sd_bus_message *m, const char *field, const char *eq) {
1330         if (streq(field, "KillMode"))
1331                 return bus_append_string(m, field, eq);
1332
1333         if (STR_IN_SET(field, "SendSIGHUP", "SendSIGKILL"))
1334                 return bus_append_parse_boolean(m, field, eq);
1335
1336         if (STR_IN_SET(field, "KillSignal", "RestartKillSignal", "FinalKillSignal", "WatchdogSignal"))
1337                 return bus_append_signal_from_string(m, field, eq);
1338
1339         return 0;
1340 }
1341
1342 static int bus_append_mount_property(sd_bus_message *m, const char *field, const char *eq) {
1343
1344         if (STR_IN_SET(field, "What", "Where", "Options", "Type"))
1345                 return bus_append_string(m, field, eq);
1346
1347         if (streq(field, "TimeoutSec"))
1348                 return bus_append_parse_sec_rename(m, field, eq);
1349
1350         if (streq(field, "DirectoryMode"))
1351                 return bus_append_parse_mode(m, field, eq);
1352
1353         if (STR_IN_SET(field, "SloppyOptions", "LazyUnmount", "ForceUnmount"))
1354                 return bus_append_parse_boolean(m, field, eq);
1355
1356         return 0;
1357 }
1358
1359 static int bus_append_path_property(sd_bus_message *m, const char *field, const char *eq) {
1360         int r;
1361
1362         if (streq(field, "MakeDirectory"))
1363                 return bus_append_parse_boolean(m, field, eq);
1364
1365         if (streq(field, "DirectoryMode"))
1366                 return bus_append_parse_mode(m, field, eq);
1367
1368         if (STR_IN_SET(field,
1369                        "PathExists", "PathExistsGlob", "PathChanged",
1370                        "PathModified", "DirectoryNotEmpty")) {
1371                 if (isempty(eq))
1372                         r = sd_bus_message_append(m, "(sv)", "Paths", "a(ss)", 0);
1373                 else
1374                         r = sd_bus_message_append(m, "(sv)", "Paths", "a(ss)", 1, field, eq);
1375                 if (r < 0)
1376                         return bus_log_create_error(r);
1377
1378                 return 1;
1379         }
1380
1381         return 0;
1382 }
1383
1384 static int bus_append_service_property(sd_bus_message *m, const char *field, const char *eq) {
1385         int r;
1386
1387         if (STR_IN_SET(field,
1388                        "PIDFile", "Type", "Restart", "BusName", "NotifyAccess",
1389                        "USBFunctionDescriptors", "USBFunctionStrings", "OOMPolicy"))
1390                 return bus_append_string(m, field, eq);
1391
1392         if (STR_IN_SET(field, "PermissionsStartOnly", "RootDirectoryStartOnly", "RemainAfterExit", "GuessMainPID"))
1393                 return bus_append_parse_boolean(m, field, eq);
1394
1395         if (STR_IN_SET(field, "RestartSec", "TimeoutStartSec", "TimeoutStopSec", "RuntimeMaxSec", "WatchdogSec"))
1396                 return bus_append_parse_sec_rename(m, field, eq);
1397
1398         if (streq(field, "TimeoutSec")) {
1399                 r = bus_append_parse_sec_rename(m, "TimeoutStartSec", eq);
1400                 if (r < 0)
1401                         return r;
1402
1403                 return bus_append_parse_sec_rename(m, "TimeoutStopSec", eq);
1404         }
1405
1406         if (streq(field, "FileDescriptorStoreMax"))
1407                 return bus_append_safe_atou(m, field, eq);
1408
1409         if (STR_IN_SET(field,
1410                        "ExecCondition", "ExecStartPre", "ExecStart", "ExecStartPost",
1411                        "ExecConditionEx", "ExecStartPreEx", "ExecStartEx", "ExecStartPostEx",
1412                        "ExecReload", "ExecStop", "ExecStopPost",
1413                        "ExecReloadEx", "ExecStopEx", "ExecStopPostEx"))
1414                 return bus_append_exec_command(m, field, eq);
1415
1416         if (STR_IN_SET(field, "RestartPreventExitStatus", "RestartForceExitStatus", "SuccessExitStatus")) {
1417                 _cleanup_free_ int *status = NULL, *signal = NULL;
1418                 size_t n_status = 0, n_signal = 0;
1419                 const char *p;
1420
1421                 for (p = eq;;) {
1422                         _cleanup_free_ char *word = NULL;
1423
1424                         r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
1425                         if (r == 0)
1426                                 break;
1427                         if (r == -ENOMEM)
1428                                 return log_oom();
1429                         if (r < 0)
1430                                 return log_error_errno(r, "Invalid syntax in %s: %s", field, eq);
1431
1432                         /* We need to call exit_status_from_string() first, because we want
1433                          * to parse numbers as exit statuses, not signals. */
1434
1435                         r = exit_status_from_string(word);
1436                         if (r >= 0) {
1437                                 assert(r >= 0 && r < 256);
1438
1439                                 status = reallocarray(status, n_status + 1, sizeof(int));
1440                                 if (!status)
1441                                         return log_oom();
1442
1443                                 status[n_status++] = r;
1444
1445                         } else if ((r = signal_from_string(word)) >= 0) {
1446                                 signal = reallocarray(signal, n_signal + 1, sizeof(int));
1447                                 if (!signal)
1448                                         return log_oom();
1449
1450                                 signal[n_signal++] = r;
1451
1452                         } else
1453                                 /* original r from exit_status_to_string() */
1454                                 return log_error_errno(r, "Invalid status or signal %s in %s: %m",
1455                                                        word, field);
1456                 }
1457
1458                 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
1459                 if (r < 0)
1460                         return bus_log_create_error(r);
1461
1462                 r = sd_bus_message_append_basic(m, SD_BUS_TYPE_STRING, field);
1463                 if (r < 0)
1464                         return bus_log_create_error(r);
1465
1466                 r = sd_bus_message_open_container(m, 'v', "(aiai)");
1467                 if (r < 0)
1468                         return bus_log_create_error(r);
1469
1470                 r = sd_bus_message_open_container(m, 'r', "aiai");
1471                 if (r < 0)
1472                         return bus_log_create_error(r);
1473
1474                 r = sd_bus_message_append_array(m, 'i', status, n_status * sizeof(int));
1475                 if (r < 0)
1476                         return bus_log_create_error(r);
1477
1478                 r = sd_bus_message_append_array(m, 'i', signal, n_signal * sizeof(int));
1479                 if (r < 0)
1480                         return bus_log_create_error(r);
1481
1482                 r = sd_bus_message_close_container(m);
1483                 if (r < 0)
1484                         return bus_log_create_error(r);
1485
1486                 r = sd_bus_message_close_container(m);
1487                 if (r < 0)
1488                         return bus_log_create_error(r);
1489
1490                 r = sd_bus_message_close_container(m);
1491                 if (r < 0)
1492                         return bus_log_create_error(r);
1493
1494                 return 1;
1495         }
1496
1497         return 0;
1498 }
1499
1500 static int bus_append_socket_property(sd_bus_message *m, const char *field, const char *eq) {
1501         int r;
1502
1503         if (STR_IN_SET(field,
1504                        "Accept", "Writable", "KeepAlive", "NoDelay", "FreeBind", "Transparent", "Broadcast",
1505                        "PassCredentials", "PassSecurity", "ReusePort", "RemoveOnStop", "SELinuxContextFromNet"))
1506                 return bus_append_parse_boolean(m, field, eq);
1507
1508         if (STR_IN_SET(field, "Priority", "IPTTL", "Mark"))
1509                 return bus_append_safe_atoi(m, field, eq);
1510
1511         if (streq(field, "IPTOS"))
1512                 return bus_append_ip_tos_from_string(m, field, eq);
1513
1514         if (STR_IN_SET(field, "Backlog", "MaxConnections", "MaxConnectionsPerSource", "KeepAliveProbes", "TriggerLimitBurst"))
1515                 return bus_append_safe_atou(m, field, eq);
1516
1517         if (STR_IN_SET(field, "SocketMode", "DirectoryMode"))
1518                 return bus_append_parse_mode(m, field, eq);
1519
1520         if (STR_IN_SET(field, "MessageQueueMaxMessages", "MessageQueueMessageSize"))
1521                 return bus_append_safe_atoi64(m, field, eq);
1522
1523         if (STR_IN_SET(field, "TimeoutSec", "KeepAliveTimeSec", "KeepAliveIntervalSec", "DeferAcceptSec", "TriggerLimitIntervalSec"))
1524                 return bus_append_parse_sec_rename(m, field, eq);
1525
1526         if (STR_IN_SET(field, "ReceiveBuffer", "SendBuffer", "PipeSize"))
1527                 return bus_append_parse_size(m, field, eq, 1024);
1528
1529         if (STR_IN_SET(field, "ExecStartPre", "ExecStartPost", "ExecReload", "ExecStopPost"))
1530                 return bus_append_exec_command(m, field, eq);
1531
1532         if (STR_IN_SET(field,
1533                        "SmackLabel", "SmackLabelIPIn", "SmackLabelIPOut", "TCPCongestion",
1534                        "BindToDevice", "BindIPv6Only", "FileDescriptorName",
1535                        "SocketUser", "SocketGroup"))
1536                 return bus_append_string(m, field, eq);
1537
1538         if (streq(field, "Symlinks"))
1539                 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE);
1540
1541         if (streq(field, "SocketProtocol"))
1542                 return bus_append_parse_ip_protocol(m, field, eq);
1543
1544         if (STR_IN_SET(field,
1545                        "ListenStream", "ListenDatagram", "ListenSequentialPacket", "ListenNetlink",
1546                        "ListenSpecial", "ListenMessageQueue", "ListenFIFO", "ListenUSBFunction")) {
1547                 if (isempty(eq))
1548                         r = sd_bus_message_append(m, "(sv)", "Listen", "a(ss)", 0);
1549                 else
1550                         r = sd_bus_message_append(m, "(sv)", "Listen", "a(ss)", 1, field + STRLEN("Listen"), eq);
1551                 if (r < 0)
1552                         return bus_log_create_error(r);
1553
1554                 return 1;
1555         }
1556
1557         return 0;
1558 }
1559 static int bus_append_timer_property(sd_bus_message *m, const char *field, const char *eq) {
1560         int r;
1561
1562         if (STR_IN_SET(field, "WakeSystem", "RemainAfterElapse", "Persistent",
1563                        "OnTimezoneChange", "OnClockChange"))
1564                 return bus_append_parse_boolean(m, field, eq);
1565
1566         if (STR_IN_SET(field, "AccuracySec", "RandomizedDelaySec"))
1567                 return bus_append_parse_sec_rename(m, field, eq);
1568
1569         if (STR_IN_SET(field,
1570                        "OnActiveSec", "OnBootSec", "OnStartupSec",
1571                        "OnUnitActiveSec","OnUnitInactiveSec")) {
1572                 if (isempty(eq))
1573                         r = sd_bus_message_append(m, "(sv)", "TimersMonotonic", "a(st)", 0);
1574                 else {
1575                         usec_t t;
1576                         r = parse_sec(eq, &t);
1577                         if (r < 0)
1578                                 return log_error_errno(r, "Failed to parse %s=%s: %m", field, eq);
1579
1580                         r = sd_bus_message_append(m, "(sv)", "TimersMonotonic", "a(st)", 1, field, t);
1581                 }
1582                 if (r < 0)
1583                         return bus_log_create_error(r);
1584
1585                 return 1;
1586         }
1587
1588         if (streq(field, "OnCalendar")) {
1589                 if (isempty(eq))
1590                         r = sd_bus_message_append(m, "(sv)", "TimersCalendar", "a(ss)", 0);
1591                 else
1592                         r = sd_bus_message_append(m, "(sv)", "TimersCalendar", "a(ss)", 1, field, eq);
1593                 if (r < 0)
1594                         return bus_log_create_error(r);
1595
1596                 return 1;
1597         }
1598
1599         return 0;
1600 }
1601
1602 static int bus_append_unit_property(sd_bus_message *m, const char *field, const char *eq) {
1603         ConditionType t = _CONDITION_TYPE_INVALID;
1604         bool is_condition = false;
1605         int r;
1606
1607         if (STR_IN_SET(field,
1608                        "Description", "SourcePath", "OnFailureJobMode",
1609                        "JobTimeoutAction", "JobTimeoutRebootArgument",
1610                        "StartLimitAction", "FailureAction", "SuccessAction",
1611                        "RebootArgument", "CollectMode"))
1612                 return bus_append_string(m, field, eq);
1613
1614         if (STR_IN_SET(field,
1615                        "StopWhenUnneeded", "RefuseManualStart", "RefuseManualStop",
1616                        "AllowIsolate", "IgnoreOnIsolate", "DefaultDependencies"))
1617                 return bus_append_parse_boolean(m, field, eq);
1618
1619         if (STR_IN_SET(field, "JobTimeoutSec", "JobRunningTimeoutSec", "StartLimitIntervalSec"))
1620                 return bus_append_parse_sec_rename(m, field, eq);
1621
1622         if (streq(field, "StartLimitBurst"))
1623                 return bus_append_safe_atou(m, field, eq);
1624
1625         if (STR_IN_SET(field, "SuccessActionExitStatus", "FailureActionExitStatus")) {
1626                 if (isempty(eq))
1627                         r = sd_bus_message_append(m, "(sv)", field, "i", -1);
1628                 else {
1629                         uint8_t u;
1630
1631                         r = safe_atou8(eq, &u);
1632                         if (r < 0)
1633                                 return log_error_errno(r, "Failed to parse %s=%s", field, eq);
1634
1635                         r = sd_bus_message_append(m, "(sv)", field, "i", (int) u);
1636                 }
1637                 if (r < 0)
1638                         return bus_log_create_error(r);
1639
1640                 return 1;
1641         }
1642
1643         if (unit_dependency_from_string(field) >= 0 ||
1644             STR_IN_SET(field, "Documentation", "RequiresMountsFor"))
1645                 return bus_append_strv(m, field, eq, EXTRACT_UNQUOTE);
1646
1647         t = condition_type_from_string(field);
1648         if (t >= 0)
1649                 is_condition = true;
1650         else
1651                 t = assert_type_from_string(field);
1652         if (t >= 0) {
1653                 if (isempty(eq))
1654                         r = sd_bus_message_append(m, "(sv)", is_condition ? "Conditions" : "Asserts", "a(sbbs)", 0);
1655                 else {
1656                         const char *p = eq;
1657                         int trigger, negate;
1658
1659                         trigger = *p == '|';
1660                         if (trigger)
1661                                 p++;
1662
1663                         negate = *p == '!';
1664                         if (negate)
1665                                 p++;
1666
1667                         r = sd_bus_message_append(m, "(sv)", is_condition ? "Conditions" : "Asserts", "a(sbbs)", 1,
1668                                                   field, trigger, negate, p);
1669                 }
1670                 if (r < 0)
1671                         return bus_log_create_error(r);
1672
1673                 return 1;
1674         }
1675
1676         return 0;
1677 }
1678
1679 int bus_append_unit_property_assignment(sd_bus_message *m, UnitType t, const char *assignment) {
1680         const char *eq, *field;
1681         int r;
1682
1683         assert(m);
1684         assert(assignment);
1685
1686         eq = strchr(assignment, '=');
1687         if (!eq)
1688                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1689                                        "Not an assignment: %s", assignment);
1690
1691         field = strndupa(assignment, eq - assignment);
1692         eq++;
1693
1694         switch (t) {
1695         case UNIT_SERVICE:
1696                 r = bus_append_cgroup_property(m, field, eq);
1697                 if (r != 0)
1698                         return r;
1699
1700                 r = bus_append_execute_property(m, field, eq);
1701                 if (r != 0)
1702                         return r;
1703
1704                 r = bus_append_kill_property(m, field, eq);
1705                 if (r != 0)
1706                         return r;
1707
1708                 r = bus_append_service_property(m, field, eq);
1709                 if (r != 0)
1710                         return r;
1711                 break;
1712
1713         case UNIT_SOCKET:
1714                 r = bus_append_cgroup_property(m, field, eq);
1715                 if (r != 0)
1716                         return r;
1717
1718                 r = bus_append_execute_property(m, field, eq);
1719                 if (r != 0)
1720                         return r;
1721
1722                 r = bus_append_kill_property(m, field, eq);
1723                 if (r != 0)
1724                         return r;
1725
1726                 r = bus_append_socket_property(m, field, eq);
1727                 if (r != 0)
1728                         return r;
1729                 break;
1730
1731         case UNIT_TIMER:
1732                 r = bus_append_timer_property(m, field, eq);
1733                 if (r != 0)
1734                         return r;
1735                 break;
1736
1737         case UNIT_PATH:
1738                 r = bus_append_path_property(m, field, eq);
1739                 if (r != 0)
1740                         return r;
1741                 break;
1742
1743         case UNIT_SLICE:
1744                 r = bus_append_cgroup_property(m, field, eq);
1745                 if (r != 0)
1746                         return r;
1747                 break;
1748
1749         case UNIT_SCOPE:
1750
1751                 if (streq(field, "TimeoutStopSec"))
1752                         return bus_append_parse_sec_rename(m, field, eq);
1753
1754                 r = bus_append_cgroup_property(m, field, eq);
1755                 if (r != 0)
1756                         return r;
1757
1758                 r = bus_append_kill_property(m, field, eq);
1759                 if (r != 0)
1760                         return r;
1761                 break;
1762
1763         case UNIT_MOUNT:
1764                 r = bus_append_cgroup_property(m, field, eq);
1765                 if (r != 0)
1766                         return r;
1767
1768                 r = bus_append_execute_property(m, field, eq);
1769                 if (r != 0)
1770                         return r;
1771
1772                 r = bus_append_kill_property(m, field, eq);
1773                 if (r != 0)
1774                         return r;
1775
1776                 r = bus_append_mount_property(m, field, eq);
1777                 if (r != 0)
1778                         return r;
1779
1780                 break;
1781
1782         case UNIT_AUTOMOUNT:
1783                 r = bus_append_automount_property(m, field, eq);
1784                 if (r != 0)
1785                         return r;
1786
1787                 break;
1788
1789         case UNIT_TARGET:
1790         case UNIT_DEVICE:
1791         case UNIT_SWAP:
1792                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1793                                        "Not supported unit type");
1794
1795         default:
1796                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1797                                        "Invalid unit type");
1798         }
1799
1800         r = bus_append_unit_property(m, field, eq);
1801         if (r != 0)
1802                 return r;
1803
1804         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1805                                "Unknown assignment: %s", assignment);
1806 }
1807
1808 int bus_append_unit_property_assignment_many(sd_bus_message *m, UnitType t, char **l) {
1809         char **i;
1810         int r;
1811
1812         assert(m);
1813
1814         STRV_FOREACH(i, l) {
1815                 r = bus_append_unit_property_assignment(m, t, *i);
1816                 if (r < 0)
1817                         return r;
1818         }
1819
1820         return 0;
1821 }
1822
1823 int bus_deserialize_and_dump_unit_file_changes(sd_bus_message *m, bool quiet, UnitFileChange **changes, size_t *n_changes) {
1824         const char *type, *path, *source;
1825         int r;
1826
1827         /* changes is dereferenced when calling unit_file_dump_changes() later,
1828          * so we have to make sure this is not NULL. */
1829         assert(changes);
1830         assert(n_changes);
1831
1832         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sss)");
1833         if (r < 0)
1834                 return bus_log_parse_error(r);
1835
1836         while ((r = sd_bus_message_read(m, "(sss)", &type, &path, &source)) > 0) {
1837                 /* We expect only "success" changes to be sent over the bus.
1838                    Hence, reject anything negative. */
1839                 UnitFileChangeType ch = unit_file_change_type_from_string(type);
1840
1841                 if (ch < 0) {
1842                         log_notice("Manager reported unknown change type \"%s\" for path \"%s\", ignoring.", type, path);
1843                         continue;
1844                 }
1845
1846                 r = unit_file_changes_add(changes, n_changes, ch, path, source);
1847                 if (r < 0)
1848                         return r;
1849         }
1850         if (r < 0)
1851                 return bus_log_parse_error(r);
1852
1853         r = sd_bus_message_exit_container(m);
1854         if (r < 0)
1855                 return bus_log_parse_error(r);
1856
1857         unit_file_dump_changes(0, NULL, *changes, *n_changes, quiet);
1858         return 0;
1859 }
1860
1861 int unit_load_state(sd_bus *bus, const char *name, char **load_state) {
1862         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1863         _cleanup_free_ char *path = NULL;
1864         int r;
1865
1866         path = unit_dbus_path_from_name(name);
1867         if (!path)
1868                 return log_oom();
1869
1870         /* This function warns on it's own, because otherwise it'd be awkward to pass
1871          * the dbus error message around. */
1872
1873         r = sd_bus_get_property_string(
1874                         bus,
1875                         "org.freedesktop.systemd1",
1876                         path,
1877                         "org.freedesktop.systemd1.Unit",
1878                         "LoadState",
1879                         &error,
1880                         load_state);
1881         if (r < 0)
1882                 return log_error_errno(r, "Failed to get load state of %s: %s", name, bus_error_message(&error, r));
1883
1884         return 0;
1885 }